# Which coding agent and model should run each job on your team?

> Give planning and review to your strongest model, building and testing to faster ones in parallel, and review to a different vendor than the author.

Published November 10, 2026 · by the AQ team · Canonical: https://aq.dev/playbooks/which-agent-and-model-for-each-job/

AQ runs Claude Code, Codex, Cursor, Kimi Code, Grok and other agent CLIs in one team workspace. Its crews let a Lead agent plan the work, delegate build, test, review and research to other agents, and route the review to a different vendor than the author when one is connected.

Anthropic's playbook, [Which Claude model should you build with?](https://claude.dev/blog/which-claude-model-should-you-build-with/) (claude.dev, November 9, 2026), covers choosing between Fable, Opus, Sonnet and Haiku. This page cites it where the two overlap and adds the questions a team has on top: which vendor checks whose work, whose subscription pays, and how to set the same defaults for everyone. Vendor facts below were read on the vendors' own pages on November 10, 2026. Model names change every few months; the split of jobs lasts longer.

## The decision table

Each job needs something different. Planning and review need judgment. Building and testing need throughput, and they parallelize. Searching files and reading logs need low cost, because a wrong answer there is cheap to spot. Review also needs independence from the author.

| Job | Optimize for | Starting pick | Move up or down |
| --- | --- | --- | --- |
| Plan (the Lead) | Judgment | Opus 5.5 at medium effort, Anthropic's default; Fable 5.2 for major refactors, migrations and leading many subagents. On Codex, Astra. | Up when the plan misses constraints you had to add by hand. Skip the plan step for a small, fully specified change. |
| Build | Speed and cost, in parallel | Sonnet 5.5 at medium for well-scoped coding; on Codex, GPT-6.1 Sol, which OpenAI suggests when cost matters. | Up after the builder can run the checks itself, has had one more effort level, and still fails the same way. |
| Test | Speed and cost | The builder's model, or one size smaller for running suites and reading output. | Up when it writes tests that pass for the wrong reason. |
| Research and search | Cost and latency | Haiku 5.5 or Sonnet 5.5 for subagents that search files, read logs or summarize; on Codex, Luna for specific, high-volume tasks. | Up when its summaries drop facts the Lead needed. |
| Review | Independence and judgment | A strong model from a different vendor than the builder: Codex reviews what Claude Code built, and the reverse. | Down by choosing a smaller model from the other vendor. Keep it off the author's model. |
| Standing bot job | Cost per run, consistency | Sonnet 5.5 at medium, which Anthropic lists for repeated agent tasks such as investigation, review and drafting; Luna for extraction and classification. | Up when the job needs judgment calls a person used to make. |

Sources: Anthropic's task table in [its playbook](https://claude.dev/blog/which-claude-model-should-you-build-with/) and its [model selection guide](https://platform.claude.com/docs/en/about-claude/models/choosing-a-model), which says most workloads start with Claude Opus 5.5; OpenAI's [Codex models page](https://learn.chatgpt.com/docs/models), which says Astra suits the most demanding workflows, GPT-6.1 Sol offers near-Astra performance at a lower cost, and Luna suits focused, repeatable tasks. The review row is our recommendation, explained in [the self-review problem](https://aq.dev/self-review-problem/): a model reviewing its own output tends to agree with it.

## Raise effort before you switch models

Both vendors give the same first move. Anthropic's playbook says "Before you move models, try adjusting your effort level," and its docs say tuning effort "is often a better lever than switching models." OpenAI's Codex docs say to "start with the default effort and increase it when the task needs deeper planning or analysis."

Anthropic's escalation order for a model that falls short:

1. Let it check its own work with a test, a build or a script.
2. Raise effort one level.
3. Move to the next model up, starting at a lower effort than you used on the smaller one.

Two details matter for cost. Past high, Anthropic notes, one more effort level can cost as much as a bigger model, so compare both on your own work. And effort buys more thinking, tool calls and self-checks; it adds no knowledge. A useful team rule follows from that: when an agent skipped a case or stopped early, raise effort; when it misread the architecture or used an API that does not exist, switch models. OpenAI adds that reasoning efforts do not map exactly between model generations, so re-check a familiar task when a vendor ships a new model.

## Put subagents and helpers on smaller models

Subagents bill at the rate of the model they run on. Both CLIs let you choose that model:

- **Claude Code** takes a `model` field in each subagent definition (`haiku`, `sonnet`, `opus`, `fable`, a full model ID, or `inherit`), and `CLAUDE_CODE_SUBAGENT_MODEL` sets the default for subagents that name none. Its [subagent docs](https://code.claude.com/docs/en/sub-agents) list "routing tasks to faster, lower-cost models like Haiku" as a way to control costs. The built-in Explore subagent runs on the main conversation's model unless you change it.
- **Codex** subagents inherit the parent's model and reasoning effort unless you set `agents.default_subagent_model` and `agents.default_subagent_reasoning_effort`, or a custom agent sets its own. Its [subagent docs](https://learn.chatgpt.com/codex/agent-configuration/subagents) note that subagent workflows consume more tokens than comparable single-agent runs.

Anthropic's advice is to keep small models on work where mistakes are cheap to spot (finding files, running tests, reading logs) and keep code edits and judgment on the main model. The [subagents guide](https://aq.dev/guides/subagents-in-coding-agents-explained/) covers how subagents work in general. On a team, three more things change:

- **Spend is shared.** A subagent default that lives in one person's home directory sets the bill only for that person. Check subagent definitions into the repository (Claude Code reads project subagents from `.claude/agents/`) so every run of the same job makes the same choice.
- **Someone's subscription pays.** Subagents run on the account of the session that spawned them. When a teammate picks up a session, check which account it now runs on before a long run.
- **Review needs a different author.** A reviewer subagent on the author's model shares the author's blind spots. A cheap same-vendor reviewer is fine for style and lint-level checks; the review that gates a merge goes to the other vendor.

## Where AQ fits

AQ is the multiplayer coding harness where teams build and run bots with every AI coding agent, like Claude Code and Codex: reviewed pull requests, live app previews, Genie and standing jobs, on private cloud machines of their own.

- **Crews and roles.** A crew is a Lead that plans and delegates plus roles that do the steps: Lead, Build, Review, Test and Research are built in, and the Ship, Review and Fix crews are ready to use. With the plan gate on, nothing that can edit code starts until you approve the plan. Details in [the crews docs](https://aq.dev/docs/crews/).
- **Role picks in Settings.** Each role runs on the pick your organization set for it in Settings, Crews: a subscription, an AQ model, or Auto. A crew can override those picks.
- **Review on another vendor.** When Auto chooses the reviewer, it prefers another vendor and another account than the builder's, and says so when no independent subscription is connected.
- **Auto per turn.** Auto makes one decision per turn across AQ models and the connected subscriptions that still have room, and writes the choice, its price, its confidence and the task it read on the transcript. When it is unsure, it asks.
- **Your subscriptions with no markup.** Usage on a connected Claude Code, Codex or other subscription stays on that plan. AQ models show their per-token price before you pick, and Pro includes $10 of AQ credits per seat each month. See [models and Auto](https://aq.dev/product/models/) and [pricing](https://aq.dev/pricing/).

## A starting setup to try in 10 minutes

1. Connect two subscriptions from different vendors, for example Claude Code and Codex, in Settings, Connections.
2. In Settings, Crews, set the role picks. A reasonable start: Lead on Claude Code with Opus at medium effort, Build and Test on Claude Code with Sonnet, Research on Claude Code with Haiku, and Review on Auto so it prefers Codex. If your plan lists different models, take the closest ones.
3. Open a work item on a small, real change, choose the Ship crew in the model menu (or write "run this as the Ship crew"), and approve the plan when the Lead proposes it.

To check it worked, open each member's row in the Lead's activity to read its thread, and read the crew summary when the Lead finishes: it reports time and cost per role. If the review says no independent subscription was connected, step 1 did not take.

Outside AQ, the same split takes two files. A Claude Code subagent for reading logs, checked in at `.claude/agents/log-reader.md`:

```
---
name: log-reader
description: Reads test output and logs and reports each failure. Use after a test run.
tools: Read, Grep, Glob, Bash
model: haiku
---
Read the logs you are given. Report each failure with its file, line and error message. Leave the code unchanged.
```

And Codex defaults for spawned agents in its configuration file, with the effort OpenAI suggests starting Luna at:

```
[agents]
default_subagent_model = "gpt-6-luna"
default_subagent_reasoning_effort = "high"
```

For the choice of CLI itself, read [how to choose a coding harness](https://aq.dev/guides/how-to-choose-a-coding-harness/). For tools that pick the model per request on their own, read [model routing for coding agents](https://aq.dev/guides/model-routing-for-coding-agents-explained/).

## Frequently asked questions

### Which Claude model should I use for coding?

Anthropic recommends starting most work on Opus 5.5 at its default medium effort, moving down to Sonnet 5.5 for well-scoped coding such as bug fixes and feature iteration, using Haiku 5.5 or Sonnet 5.5 for subagents that search and summarize, and moving up to Fable 5.2 for major refactors, migrations and long unattended runs. Source: [Anthropic's playbook](https://claude.dev/blog/which-claude-model-should-you-build-with/), November 9, 2026.

### Is Opus or Sonnet better for coding?

They fit different jobs. Anthropic's table puts everyday engineering, debugging and multi-PR feature work on Opus 5.5, and well-scoped coding on Sonnet 5.5. On a team, a common split is Opus planning and leading, Sonnet builders working in parallel, and a model from another vendor reviewing.

### Should subagents use a cheaper model than the main agent?

For searching files, reading logs, running tests and summarizing, yes: Anthropic recommends Haiku 5.5 or Sonnet 5.5 for that work and keeping code edits and judgment on the main model. In Claude Code, set `model` in the subagent definition or `CLAUDE_CODE_SUBAGENT_MODEL`; in Codex, set `agents.default_subagent_model`.

### Codex or Claude Code: which should my team use?

Many teams use both, and the pairing has a use: each can review what the other wrote. The choice of CLI depends on your workflow more than on one model; [how to choose a coding harness](https://aq.dev/guides/how-to-choose-a-coding-harness/) covers that decision.

### When should I raise effort instead of switching models?

When the model has the right idea and skipped a case or stopped early. Effort adds thinking and tool calls; it adds no knowledge. Switch models when the agent misreads the architecture or invents APIs, and start the bigger model at a lower effort than you used on the smaller one.

### Does AQ mark up usage on my own Claude or ChatGPT subscription?

No. Usage on a connected subscription stays on your plan with no AQ meter. AQ models show their per-token price before you pick, and Pro includes $10 of AQ credits per seat each month. See [pricing](https://aq.dev/pricing/).

---

About AQ: AQ is the multiplayer coding harness where teams build and run bots with every AI coding agent, like Claude Code and Codex: reviewed pull requests, live app previews, Genie and standing jobs, on private cloud machines of their own. Start at [aq.dev](https://aq.dev/).