> ## Documentation Index
> Fetch the complete documentation index at: https://continuum-three-olive.vercel.app/docs/llms.txt
> Use this file to discover all available pages before exploring further.
# Providers
> The coding-agent providers Continuum supports, how each integrates, and which capabilities they expose.
Continuum drives eight bring-your-own-account provider lanes on top of six local CLIs — `claude`, `codex`, `agy`, `cursor-agent`, `grok`, and `opencode`. Each CLI runs as a child process on your machine. Continuum reads the local state those CLIs already maintain, spawns and steers their sessions, and surfaces their usage — it does not proxy or inspect their model network traffic.
A ninth lane, [Continuum-hosted inference](/docs/features/hosted-inference), needs no local CLI: Continuum serves the models itself and bills them to your Continuum account instead of your own provider subscription. It appears as a **Continuum** rail in the model picker, split into **Included in Free** — a roster of free models available on every plan, including no plan at all — and the frontier models a paid tier unlocks. Because the roster is served rather than bundled, read the live tray for what is currently offered; the [hosted inference](/docs/features/hosted-inference) page covers billing and org policy.
## Provider summary
| Provider | CLI | Transport | Quota gauge | Effort dial | Multiple accounts |
| -------------------------------------------------- | -------------- | ---------------------------------------------------- | ----------------- | ------------------------- | ----------------- |
| **[Claude Code](/docs/providers/claude)** | `claude` | ACP harness (Agent SDK, default) or direct PTY (CLI) | Yes | Low → Max, plus Ultracode | Yes |
| **[Codex](/docs/providers/codex)** | `codex` | `codex app-server` | Yes | Minimal → Max | Yes |
| **[Antigravity / Gemini](/docs/providers/antigravity)** | `agy` | Headless transport-owning harness | Yes | No | Yes |
| **[Cursor](/docs/providers/cursor)** | `cursor-agent` | ACP harness | Yes | No | Yes |
| **[Grok](/docs/providers/grok)** | `grok` | ACP harness, headless fallback | Yes | Low / Medium / High | Yes |
| **[OpenCode Go](/docs/providers/openrouter)** | `opencode` | `opencode serve` HTTP/SSE | Yes (see note) | No | Yes |
| **[OpenRouter](/docs/providers/openrouter)** | `opencode` | `opencode serve` HTTP/SSE | Dollar-cost lane | No | Yes |
| **[Z.ai Coding](/docs/providers/zai)** | `opencode` | `opencode serve` HTTP/SSE | Yes (5h + weekly) | No | Yes |
* **Transport** is the runtime path the daemon uses. Claude defaults to the Agent SDK's ACP adapter and switches to a real per-session PTY when you pick the CLI backend under **Settings → Advanced → Claude runtime** — that PTY is the only direct-PTY path in the app. Codex runs through `codex app-server`; Cursor runs through the native ACP harness; Grok uses ACP (`grok agent stdio`) when the installed CLI advertises it and falls back to its headless one-shot transport when it doesn't; Antigravity/Gemini runs through its own transport-owning headless harness. OpenCode Go, OpenRouter, and Z.ai Coding are three branded lanes sharing one `opencode serve` process.
* **Quota gauge** means Continuum polls a live usage source for that account and shows a rolling-quota meter in the [Usage](/docs/surfaces/usage) tab — and, for every provider except Z.ai Coding, in the Mac menu bar too. **OpenCode Go** exposes 5h / weekly / monthly windows, but only through its web dashboard — you supply a workspace id and session cookie under **Settings → Providers → Configure quota tracking**; there is no API-key usage endpoint yet. **OpenRouter** is bring-your-own-key with no subscription quota at all, so it is tracked as a **dollar-cost lane** computed from token counts and the bundled pricing snapshot. See the [OpenRouter page](/docs/providers/openrouter).
* **Effort dial** is a reasoning-effort control that actually reaches the CLI. Three providers accept one, and each accepts a different vocabulary: Claude takes `--effort low|medium|high|xhigh|max` (plus the Claude-only Ultracode mode, set through a session settings key rather than a flag), Codex takes `model_reasoning_effort` from `minimal` through `max`, and Grok takes `--reasoning-effort low|medium|high`. The composer's dial only offers the rungs the selected provider accepts, and a value carried across a provider swap clamps to the nearest supported rung at the spawn boundary — so the CLI never sees a level it would reject. Providers not listed here select a model but pass no effort value.
## Auto model routing
At the top of the model picker, above every provider rail, sits **Auto** — *"Picks the best models for the task."* Choosing it hands model selection to Continuum's router instead of pinning the session to one model.
Auto is a **choice you make when a session starts**, not a background behavior. It is not on by default, and it is not a mid-session **Change model** action: an already-running session keeps the model you gave it. What Auto replaces is the one-model assumption, not your control.
An Auto run is a state machine on the host, and you watch it move through its phases:
The router reads your request first. A small one takes a **fast path** — one executor, no ceremony. Anything substantial gets the full pipeline: a **planner** chosen for raw capability, an **executor** chosen for capability plus agentic strength (and drawn from a taste-weighted pool when the task is design- or copy-shaped), and a **verifier** deliberately taken from a *different* provider where one is available, so no model checks its own output. Each assignment carries a written reason you can read — down to "no taste ≥ 7 model available" or "same-provider fallback".
The planner produces a plan and the run parks in **awaiting approval**. Nothing is written until you press **Approve & run**. **Cancel** is the brake, at this or any later phase.
The executor does the work, the verifier checks it, and a fix pass runs if verification finds problems. Every stage is stamped with the model, provider, and account that actually ran it — including a re-stamp when a model is unavailable and the run falls back down its chain — so a finished run reads as receipts, not a guess. Live cost accrues per stage.
Auto only ever picks from providers that are **enabled, authenticated, and reachable**, and it prefers rails in a fixed order: Continuum-hosted, then your first-party subscriptions (Claude, Codex, Antigravity, Grok, Z.ai), then bring-your-own-key (OpenRouter), then aggregator lanes (Cursor, OpenCode Go). Your preferred account for a provider is carried onto every role and every fallback slot, so an Auto run bills the subscription you pinned.
Auto needs a host that serves the router. Macs and the Windows/Linux/CLI Go agent both do on current builds; against an older host the Auto entry doesn't render at all rather than failing at send time. Runs survive a host restart — an interrupted run suspends and can be resumed rather than starting over.
## Auth stays with each tool
Continuum has no model credential of its own. Where a provider signs in through its CLI (Claude, Codex, Antigravity, Grok), Continuum reads the credential that CLI already stored and never runs a login that could clobber it. Where a provider authenticates with an API key (Cursor, OpenCode Go, OpenRouter, Z.ai Coding), pasting the key in **Settings → Providers** writes it into that tool's own credential file — for the OpenCode-connector lanes that is `~/.local/share/opencode/auth.json`, the same file `opencode auth login` writes.
The one credential Continuum keeps a copy of is Claude Code's OAuth access token, imported into Continuum's own Keychain entry so the rate-limit gauge can poll without the CLI running. Where Continuum reaches a provider's billing/usage endpoint for a quota gauge, it authenticates with that stored credential, makes no destructive calls, and keeps the result on-device. The [Security](/docs/security) and [Privacy](/docs/privacy) pages describe exactly what leaves your machine.
**Multiple accounts are supported on every provider.** You can sign in more than one subscription or key and run them side by side, pinning sessions to a specific account. Each non-primary account gets a real isolation boundary: its own config root applied at spawn time (`CLAUDE_CONFIG_DIR` for Claude, `CODEX_HOME` for Codex, `XDG_DATA_HOME` for the OpenCode-connector lanes, `GROK_HOME` for Grok, an isolated `HOME` for Antigravity because `agy` reads `.gemini` from `HOME` and nothing else; Cursor has no documented config-root override, so its extra accounts are keyed on an explicit `CURSOR_API_KEY` instead), a per-account Keychain partition for Claude tokens, and an environment scrub so one account's credentials can't bleed into another's spawn. `HOME` is otherwise left untouched, so git, ssh, gh, and node keep working inside worktrees. Add an account in **Settings → Providers → "Add account…"**; the account picker appears once a provider has two or more accounts. See [multi-account](/docs/features/multi-account).
The account index lives at `~/Library/Application Support/Clawdmeter/provider-instances.json` — no secrets in that file. `Clawdmeter` is the app's internal codename and still names its on-disk paths.
## Provider pages
Agent SDK and direct-PTY backends, Plan/Code permissions, the effort dial and Ultracode, rate-limit gauges, and usage analytics from JSONL.
App-server harness, sandbox-gated approvals, the full minimal-to-max effort ramp, and respawn-lineage transcript resolution.
Headless `agy` harness with conversation-DB analytics, brain-dir plan snapshots, and a three-tier quota probe.
ACP harness sessions via `cursor-agent`, account-scoped model discovery, and a Cursor billing-period panel in Usage.
ACP or headless `grok` sessions, a three-rung effort dial, and a live weekly credit gauge.
`opencode serve` SSE integration with a bring-your-own API key and dollar-cost usage tracking.
GLM Coding Plan models through the OpenCode connector, with a 5h + weekly quota gauge and its own analytics column.
Pooled inference billed to your Continuum subscription — no provider account and no local CLI required.