Providers

A provider is an AI service that does the actual thinking for your workers. This is the most important tab in the app: until you connect at least one provider, your workers have no brain. It’s also the tab Settings opens on by default.

The app ships with ten providers you can connect. Each one is a card. Below the cards sit four shared sections — rate limits, web-search keys, an autonomy model, and per-tool call limits — that apply across providers.

The ten providers

You don’t need all of them — one is enough to start. They fall into three kinds:

Cloud providers (most capable, pay per use):

OpenAI
Anthropic
Gemini (Google)
xAI (Grok)
DeepSeek
Z.ai (GLM)
Moonshot (Kimi)

Local runners (private, free to run on your own hardware):

Ollama
LM Studio

Built-in (zero setup):

Built-in — a small model that ships inside the app. Always there as a fallback.

What each provider card controls

Every card has the same set of controls. Here’s each one, what it does, and when you’d touch it.

Enabled (checkbox)

What it does: turns the provider on or off for your workers.
Default: off for cloud providers; local runners and Built-in are detected automatically.
When to change it: flip it on the moment you’ve pasted a working key. Flip it off to stop workers using a provider without deleting its key.

API key (password field)

What it does: the secret token that authorises — and bills — your requests to a cloud provider.
Default: empty.
When to change it: paste your key here once. Local runners and Built-in don’t have this field — they need no key. A Get a key → link next to the label opens the provider’s sign-up console in your browser if you don’t have one yet.

Test connection (button)

What it does: manually re-runs the health check against the provider right now.
When to change it: after toggling Enabled or editing the Base URL — handy when you want to confirm a fix without re-typing the key.

Import from $ENV_VAR (button — appears only when detected)

What it does: if you already have a key set in your computer’s environment (e.g. OPENAI_API_KEY), this reads it in with one click instead of you pasting it.
Default: hidden — it only shows when the app detects a matching environment variable and the key field is still empty.
When to change it: click it whenever it appears; it’s the fastest way to connect. A green “Detected on this machine” banner at the top of the tab offers the same one-click import for every key it finds.

What it does: lets you sign in to a provider on their website instead of pasting a key. The app stores only a refresh token; the vendor handles your password. A 🔐 OAuth badge shows when a provider is linked this way, and Unlink removes it.
Default: no provider currently exposes this (the button is hidden) — it lights up automatically if and when a vendor publishes a public sign-in flow.
When to change it: use it instead of an API key if you’d rather not handle a raw key.

Base URL (text field)

What it does: the address the app talks to. For local runners this points at the program on your machine (Ollama defaults to http://localhost:11434); for cloud providers, leaving it blank uses the vendor’s standard endpoint.
Default: blank (the provider’s default), or the local runner’s localhost address.
When to change it: only for advanced setups — a self-hosted gateway, a proxy, or a non-standard port for your local runner. Most people never touch this.

Shared sections (below the cards)

🚦 Per-provider rate limits (tokens / minute)

What it does: the app paces each cloud provider before every call, so a big job never trips the vendor’s “too many requests” error mid-stream. Each row shows the conservative Default, an editable Your cap, a 🚫 No throttle button, and ↺ Reset.
Default: a conservative cap sitting under each vendor’s free-tier ceiling. Local runners have no throttle.
When to change it: raise the cap if you’ve upgraded to a paid tier and want to use the headroom you pay for. Set it to 0 (or click No throttle) to disable pacing entirely and let the vendor be the one that says “slow down.” Leave a row blank to go back to the default. Links to each vendor’s rate-limit page sit just below.

🔎 Web search keys

What it does: gives the web_search tool richer results. Add a Tavily key, a Brave Search key, or both. Without either, search still works but falls back to DuckDuckGo instant answers, which are thinner for open-ended research.
Default: no keys set (DuckDuckGo fallback). Both Tavily and Brave have free tiers.
When to change it: add a key if your workers do real research and you want fuller, more reliable search results. A ·configured ✓ marker shows when a key is saved; the value itself is never shown again. A Get a Tavily key button links to their sign-up.

🤖 Autonomy model (reliability)

What it does: picks one model that unattended work uses — Plans, Routines, channel auto-replies, and the review sweep — instead of each worker’s own model.
Default: “Each worker’s own model” — i.e. no override.
When to change it: point it at a capable (frontier) model if you also run weaker local models. The reason is reliability: a weak model can write an answer as plain text but forget to actually call the tools that mark a task done or save its result, so the work silently stalls. A strong model is far more dependable at following through. If you only ever run frontier models anyway, leave this on the default.

🧯 Per-tool call limits

What it does: caps how many times a single tool can be called in one run (one worker, one task), so a runaway loop can’t call something like a web fetch or a shell command endlessly. Refused calls hand the model an error instead of executing.
Controls: a Default calls per tool / run (applies to every tool), plus optional per-tool overrides you add by name (e.g. allow more web_search, fewer shell).
Default: blank — which means unlimited (the original behaviour). 0 also means unlimited.
When to change it: set a default (say, 20) once you start running long autonomous jobs and want a safety ceiling. Add an override for any specific tool that needs a tighter or looser cap than the rest.

Saving

Card changes are committed with the Save button at the bottom; Cancel discards them. The shared sections (search keys, autonomy model, tool limits, rate limits) save on their own as you edit them.

In practice

Three setups that make sense, depending on what you’re optimising for:

Zero cost, zero accounts — the built-in model only. No key, no bill, nothing leaves the machine, and it’s the one configuration that still works with the Wi-Fi off. Good enough for organising files, summarising your own documents and internal drafting.
One cloud key, spent deliberately — connect a single cloud provider and give it only to the two or three workers doing your hardest thinking. Best quality-per-euro for most people, and the cost stays legible because you know exactly which workers can spend.
Local for sensitive, cloud for the rest — point workers that touch contracts, customer data or anything under NDA at a local model. The split is a per-worker setting, so the sensitive worker can’t send data outward even if you forget.

Add a web-search key early. A Tavily or Brave key (both have free tiers) meaningfully improves what research workers return compared with the keyless fallback. It’s the cheapest quality upgrade available.

If you’re seeing 429s, lower the tokens-per-minute setting for that provider rather than retrying — the rate limiter exists to keep you under the vendor’s line, and a lower ceiling finishes faster than repeated rejections.

Keys are yours and stay local. They never reach askTheodor’s servers, and since v0.9.268 they’re encrypted at rest — the encryption key lives in a separate file outside the database, so a copy of the database alone doesn’t expose them. Treat them like passwords regardless: scope them narrowly at the vendor where that’s offered.

🎓 Learn it hands-on: Providers & models · Pick a brain per worker

Terms in this page

Provider / backend — an AI service that supplies the thinking for your workers. “Backend” is just another word for the same thing.
API key — a secret token from a provider that authorises and bills your requests. Stored locally; treat it like a password.
Cloud provider — an AI service that runs on the vendor’s servers and charges per use (OpenAI, Anthropic, etc.). Most capable, but every request costs money.
Local runner — a program on your own computer (Ollama or LM Studio) that runs open models. No key, no per-use cost, and nothing leaves your machine.
Built-in model — a small model packaged inside the app itself, always available even before you connect anything.
OAuth — a sign-in method where you authorise the app on the provider’s own website instead of pasting a key. The app gets a token; it never sees your password.
Environment variable — a setting stored in your computer’s shell (like OPENAI_API_KEY) that the app can read to import a key you already have.
Base URL — the web address the app sends requests to for a provider. Blank means “use the standard one.”
Health check — a quick test request the app sends to confirm a key works and the provider is reachable.
Token — the unit AI models read and write in (~¾ of a word). Providers bill per token.
Tokens per minute (TPM) — how fast you’re allowed to send tokens to a provider. Exceed it and the vendor rejects requests; the rate limiter keeps you under the line.
Rate limit / throttle — a deliberate cap on how fast requests go out, so you don’t trip the provider’s limits.
429 — the standard “too many requests” error a provider returns when you exceed its rate limit.
web_search tool — a capability that lets a worker search the web. It returns richer results with a Tavily or Brave key, and basic results without one.
Tavily / Brave — web-search services (both with free tiers) that give the search tool fuller results than the keyless fallback.
DuckDuckGo instant answers — the keyless, lighter search fallback used when no Tavily or Brave key is set.
Frontier model — a top-tier, most-capable AI model (typically from a major cloud provider).
Plan — a multi-step piece of work a worker carries out, often unattended.
Routine — a task scheduled to run automatically on a timer.
Run — one execution of a worker on a task, start to finish. Tool limits are counted per run.
Tool / tool call — a capability a worker invokes (web search, file access, running a command, etc.). One tool call is one such invocation.