Models & accounts
Which model serves a turn is four questions, not one: the provider, the account, the agentic loop it runs in, and the model itself. The picker asks all four; this is what each of them changes.
On this page(8 sections)
Whose credentials these are
Every credential here belongs to your sandbox. You connect your own subscription and turns spend your allowance. intentic never resells inference, and the platform never holds the token.
Providers
| Provider | What you connect |
|---|---|
| Claude Code | A Claude subscription. The sandbox owns the credential: you sign in to Anthropic, not to intentic. |
| Codex | A ChatGPT subscription. Runs on your ChatGPT plan through the bundled translator. |
| Grok | A SuperGrok subscription. Signs in with xAI's device-code flow; there is no key to paste. |
| Kimi Code | A Kimi Code subscription. Served under the Claude Code loop. |
| A Google sign-in: no subscription. Labelled for the account rather than the model family: this one channel vends Gemini's models alongside Claude and GPT-OSS. The useful answer for anyone who has connected nothing yet. | |
| Z.ai | A GLM Coding Plan. Sign in and the sandbox mints the plan's key itself. Say which plan you hold first — international, or BigModel for a mainland one — because a key made for one is refused by the other. Pointed straight at Z.ai's own Anthropic endpoint: nothing translates it, so a GLM turn is an ordinary Claude Code turn against a different host. |
| Meta | A Muse Code subscription. Sign in with a code on Meta's page and the sandbox mints the key. Muse Spark, through Meta's own Anthropic-compatible endpoint. |
| Cursor | A Cursor Pro subscription. Runs Cursor's own agent runtime and model catalog through the SDK installed into your sandbox after you connect it. |
Two more sources are open-ended rather than built in:
| Also | What it is |
|---|---|
| A local model | The sandbox downloads the weights and serves them itself: pick a model on the Local model card and it appears in the picker. Nothing to install, nothing leaves the machine; an NVIDIA GPU is one switch and one rebuild away. Small models shine on the one-shot jobs (free commit messages, free session titles) and on work that must stay local. |
| A model endpoint | Point the sandbox at any OpenAI-compatible API you already run: Ollama on this machine, vLLM on the GPU box, a gateway. Its catalog is read from the server itself, so the picker offers what that server actually serves. |
| An ACP agent | Any agent speaking the Agent Client Protocol, added as a capability. Adding one needs no update to intentic. |
Connect them on Sandbox → Agent. A subscription connects by signing in; nothing asks you for an API key you'd have to rotate by hand.
Several accounts of one provider
A sandbox can hold more than one account per provider: a work Claude and a personal one, two ChatGPT seats, and a turn can name which serves it. Absent, it takes the provider's first.
Naming one matters most where nobody is watching. When an automation's first account runs out of headroom, or belongs to an organisation that switched the plan off, every unattended run errors against it until somebody reads the row. That is why an automation can pin an account and a chat rarely bothers.
An account belongs to a provider, so an automation can only pin one while every model on its ladder is on that same provider. Spread the ladder across providers and the pin goes: the daemon then serves each fire from whichever connected account has the most headroom, which is what you wanted from the pin anyway.
What an automation runs on
An automation names its own models, in order, and it cannot be saved without them. It is the one thing here that spends an allowance with nobody in the room, on a schedule you set once and rarely re-read — so nothing is chosen for it. There is no sandbox-wide tier behind an automation and no inheriting whatever your chat happens to be set to this week.
The list is a ladder for the same reason every other model list in this product is one, only more so: a chat refuses in front of somebody who can retry it, while a wake at 3am against a spent allowance simply does not happen and nobody finds out until morning. Each rung carries its own model, reasoning tier, speed and harness; the daemon walks them at fire time and takes the first one this sandbox can actually start. An automation whose every provider has since been disconnected records the fire as an error saying so, rather than quietly spending something else.
The harness
The harness is the agentic loop that serves the turn, and it is a different axis from the provider: the same model behaves differently under each, which is why the picker asks separately.
- Native runs each provider on its own runtime, with its own subscription sign-in.
- Claude Code runs any provider's model through the Claude Code loop instead.
For most providers there is nothing to choose: Claude and Kimi always use the Claude Code loop, Google always uses its native OpenCode-based loop, and Cursor always uses Cursor's runtime. Only Codex and Grok have both Native and Claude Code available.
The choice matters because the loops support different features, and the app tells you before you find out mid-turn. A runtime lacking mid-turn steering, clarifying questions, per-tool approvals, MCP tools or reasoning-effort control lists those limits, and the composer hides the controls it would ignore.
Per-turn controls
Beyond the model there is reasoning effort, extended thinking, and a fast-speed request: each offered only where the runtime actually honours it. A conversation remembers what its last turn ran with, so opening it again seeds the composer from that conversation rather than from whatever another tab last picked.
Permission modes are the other half. A runtime that reports the full axis gets per-tool approval cards; one that does not gets propose-then-approve or run, nothing between. There the container is the isolation boundary and every tool call inside it is pre-approved.
Models for work you didn't start
Sandbox → Agent → Models holds one ordered list per job: commit messages, session titles, the safety judge, loop verdicts, pipeline fixes, deployment fixes, maintenance chores, documentation runs, acceptance runs, pre-push fixes, automation wakes and the rest. Each list is tried top to bottom, so one spent account doesn't take a job down, and each entry carries how its model runs — effort, thinking, speed, harness — as well as which model it is.
A row you haven't touched falls back to its own default, and the two defaults are genuinely different:
- One-shot helpers — a commit message, a session title, a verdict — default to Auto: the cheapest rung of every connected provider, best first, resolved at the moment it's read. So it can never name a provider you have no credential for, and it improves by itself when you connect one. Nothing stops you pinning a frontier model to your commit subjects instead; that's a preference, and it's yours to have.
- Whole sessions — an automation's wake, a chore, an acceptance run, the fix a refused push proposes — fall back to whatever your own chat is set to. Nothing can judge what a session is worth, and a wrong guess is billed in whole sessions, so the honest default is a model you already chose.
What it costs
Two different kinds of money, and only one of them is a bill. intentic itself is free: every sandbox, every capability and team sharing, with no tiers and no card. What a turn costs is your provider subscription being spent, because the credential is yours and intentic never resells inference. The one optional charge anywhere is a hosted sandbox, described on Pricing.
Sandbox → Usage reports the durable spend ledger: a row appended when a turn ends, grouped by day, provider, account and model, with cache hit rates alongside. Rows are written daemon-side and never edited, so it records what was spent rather than estimating it. Agent cards carry their own cost, and a workflow step can be capped in dollars: the one resource you cannot recover after an unattended fan-out.
When a provider refuses a turn because an allowance is spent or a plan is off, the last refusal is kept and shown beside the account, so a fleet that has quietly stopped working says why.
Related pages
- Automations & workflows: where pinning an account and a model actually pays off.
- Full child agents: children that choose a provider and harness independently.
- Remote runners: which model credentials can serve a turn on another machine.
- Access & sharing: who else may spend this sandbox's allowance.