Difficulty and models

Grid never asks you which model to run. A card carries a difficulty, the workspace carries a compute budget, and one table turns the two into a model and an effort for each of the three roles an agent plays on a card. Every call runs on your own provider account, through the provider's own CLI; Grid holds no API keys and adds no charge of its own.

Two dials

Difficulty is the only dial an agent or a masterplan turns when it files work. It never picks a model.

Three roles

A stage names a role, not a model, and so does every agent on the Agents tab: the difficulty on a card picks the model and effort through the agent's model role. Change what a role resolves to and every stage that uses it follows; change the difficulty on the card before you approve and the card follows.

Two rules shape the table. Research and planning always reasons one step harder than the build, because a plan should out-think its implementation. Delivery and validate is always the cheapest column, because running tests does not need reasoning.

The table

The Balanced budget resolves to this. Each cell is a model and an effort.

Economy stays on sonnet throughout. Quality moves Normal onto opus and reserves fable for Very hard. Maximum runs fable from Hard upwards. Models step through haiku, sonnet, opus and fable; efforts through low, medium, high, xhigh, max and ultracode. Ultracode names standing multi-agent orchestration rather than a depth of reasoning, and no cell in any budget resolves to it: a session runs at ultracode only where a cell has been cycled onto it by hand, or where a card pins it.

Click any cell to change it. A hand-edited cell is stored as an override and survives a change of budget, so a workspace that wants one difficulty on one model keeps it while the rest of the table moves.

Adversarial review

Each difficulty also carries a switch for adversarial review. When it is on, the arrow from Doing to Review hands the card to a fresh agent that reads the diff cold, writes a verdict of clean or findings, and only then hands the card to you. It is on for Hard and Very hard by default and off for Easy and Normal.

The reviewer raises at most five findings, tagged critical, important or minor, and a critical must be one it reproduced. Only critical findings hold the card. Everything below critical leaves the card the moment the round settles, onto one follow-up card Grid writes in the same project and adds to on every round; the review panel shows the count and a link. Approving over critical findings accepts them, records them on that follow-up card, and tells the Verify agent they are your decision and not failures to re-open. Request changes lists the critical findings for you to tick; the ticked ones are written into the card's task list as "Review finding" rows and the Doing agent is told to fix those and nothing else. A card coming back to Review keeps its rounds: the next reviewer is briefed to re-check the rows that went back rather than review the diff again, and is told what you accepted so it is not raised twice. On the card itself Grid keeps one "## Adversarial review" block with a "### Round N" subsection per round, folding the reviewer's own section into it once the round settles, so a card that has been round several times carries one short block rather than a stack of review blocks. Approve stays held while the reviewer's session is alive and no verdict is written; only a reviewer gone for three minutes, or silent for twenty, unlocks it.

Where the models come from

Grid reads the models and efforts the installed provider CLI advertises, including the long-context aliases, and clamps the table to them: a cell naming a model your CLI does not offer resolves to the nearest one it does. Codex can be chosen as the provider and its models selected, without an effort mapping. This table only ever resolves a model and an effort for Claude; a plugin-contributed provider such as Copilot decides for itself, flag by flag, in its own manifest. See Adding a provider. There is no Ollama row in this build: nothing bundled contributes one, and nothing stops a plugin from doing so now that the spawn contract exists.

Overrides

Two things sit over the table, and both are read field by field rather than as whole cells:

1. A hand-edited cell in the workspace table itself, stored as an override and kept across a change of budget.
2. stage_models, the card's own per-stage pin: one line of the card's front matter mapping prepare, doing, review, deliver or verify to a model, an effort, or both. A stage naming only an effort keeps the matrix's model, and a stage the map does not name takes the table. The map is validated whole, so a card hand-edited into something that is not one reads as no pin at all rather than failing to start.

What comes out is clamped to what the installed CLI advertises, so a pin naming a model this machine does not have steps down the ring rather than spawning a flag the CLI would refuse.

Grid's own calls

Grid Intelligence writes card titles, session summaries and the capture chips on a model of its own, haiku or sonnet, set in Settings under Agents and models. It runs on the same provider account as your cards and shows in Insights under its own purpose. Backlog refinement, topic sorting and the design chat also run apart from the table, on Claude; the design chat picks its model and effort in its own menu.

Cost

Insights breaks spend down by project, model and purpose, and shows the provider's plan window as a gauge read from the CLI's own usage snapshot, so you can see how much of the window is left before you queue more. From the terminal, grid usage --by project|model|purpose prints the same numbers.