What Coding Agents Actually Cost to Run for a Team
Published September 11, 2026 · by the AQ team
A team's coding agent bill is driven by input tokens, not output: every turn re-sends the session's accumulated context (conversation history, file reads, build logs, diffs) to the model, so long sessions and parallel agents multiply cost far faster than the code the agent writes. As of September 2026, frontier list prices run from $1 per million input tokens (Claude Haiku 4.5) to $5 (Claude Opus 5), with output at five times input, and a single engineer keeping several frontier agents busy all day can reach hundreds of dollars on pure API metering. Teams pay one of two ways (flat subscription seats with usage windows, or metered API keys) and cut the bill with four levers: route models by role so a big model plans while a cheaper one executes, keep subagent fan-out deliberate, practice context hygiene so sessions stay short and cacheable, and set hard token budgets where the CLI supports them.
The two ways teams pay
Almost every agent CLI supports two billing shapes, and the choice matters more than any single optimization:
- Subscription seats. Claude Code runs on Claude's consumer and team plans, and Codex is included in ChatGPT plans, each with usage allowances that replenish on rolling windows. The bill is flat and predictable per seat. The catch for teams is that allowances were sized for one interactive session: run several agents in parallel and a window that comfortably covers a day of single-threaded work can drain in an hour or two. Higher tiers sell multiples of the base allowance for exactly this reason.
- Metered API keys. Pay per token at list price. Nothing throttles you, which is the point and the danger: parallel agents scale the bill linearly with no ceiling unless you set one. Teams that hand out raw API keys usually add per-seat spend caps in the provider console the same week.
Most teams land on subscription seats for day-to-day work because the flat price absorbs the input-token dynamics described next, and reserve metered keys for automation that must not hit a usage window.
Where the tokens actually go
An agent turn is not a chat message. When a coding agent works, it reads files, runs commands, and feeds the output back to the model as input tokens, and on every turn the entire session so far is re-sent. Message 201 costs as much input as messages 1 through 200 combined. That is why input typically dominates an agentic session's cost, why a session's cost grows superlinearly with its length, and why the biggest single saving available is simply starting a fresh session for a fresh task.
Fan-out multiplies this. A subagent is its own model instance with its own context window, so it re-reads project context the parent already paid for. Practitioner measurements shared through 2026 consistently put a task fanned out to three subagents at roughly four times the tokens of the same work done single-threaded, and orchestration modes where agents message each other cost more again, since every inter-agent message is a round trip through the model. Fan-out buys wall-clock speed and context isolation, not efficiency. How many agents one developer can actually run covers the human limit, which usually binds before the budget does.
List prices as of September 2026
Prices below are per million tokens, from each vendor's published pricing as of September 2026. Two caveats when comparing across vendors: tokenizers differ (Anthropic documents that its newer tokenizer produces roughly 30 percent more tokens for the same text than its previous one, and other vendors' tokenizers differ again), and what matters for agents is the effective input price after caching, which the table's last column captures.
| Model | Input $/M | Output $/M | Cached input |
|---|---|---|---|
| Claude Opus 5 | $5.00 | $25.00 | $0.50 (0.1x) |
| Claude Sonnet 5 | $2.00 | $10.00 | $0.20 (0.1x) |
| Claude Haiku 4.5 | $1.00 | $5.00 | $0.10 (0.1x) |
| GPT-5.6 Sol | $4.00 | $20.00 | 0.1x input |
| GPT-5.6 Terra | $2.00 | $12.00 | 0.1x input |
| GPT-5.6 Luna | $0.20 | $1.20 | 0.1x input |
| Meta Muse Spark 1.3 | $1.25 | $4.25 | $0.002/M cached |
Notes worth knowing: Anthropic's $2/$10 Claude Sonnet 5 pricing launched as introductory and was made the standard price rather than rising to $3/$15 in September 2026 as originally scheduled, and its Batch API halves both input and output for asynchronous work. Meta also sells a discounted Muse Spark 1.3 "contributor" tier ($0.10 input, $0.20 output) in exchange for permission to use your data for product improvement, a trade most engineering teams should decline for code. All figures as of September 2026; every vendor on this list has repriced at least once this year, so re-check before budgeting.
Lever 1: route models by role
The most effective structural saving is to stop paying frontier prices for non-frontier work. A planning or review pass genuinely benefits from the strongest model; mechanical execution (applying a described refactor, writing tests to a spec, fixing lint) usually does not. Most CLIs now support this split directly: Claude Code lets you pin a model per subagent, so an Opus-class parent can delegate execution to Haiku 4.5 at one fifth the token price, and Codex lets you choose the model per thread. At September 2026 prices, a task fanned out to three cheap executors under one frontier planner can cost less than the same task run serially on the frontier model alone, while finishing faster. The failure mode is silent misrouting: environment variables and defaults can override your intended per-agent model without an obvious signal, so verify in usage dashboards which model actually served the tokens.
Lever 2: keep fan-out deliberate
Parallelism should be a decision, not a default. Reserve subagent fan-out for work that is actually independent (three unrelated bug fixes, a research sweep across a large codebase), cap the number of concurrent agents to what a person can meaningfully supervise, and prefer one agent per isolated working copy so parallel sessions do not trample each other, a setup covered in running multiple AI coding agents in parallel. A workflow that keeps spawning helpers to re-read the same context has a hygiene problem, not a parallelism need.
Lever 3: context hygiene
Since re-sent context is the bill, managing context is managing cost:
- Fresh session per task. Do not carry yesterday's exploration into today's feature. Clearing and restarting is the cheapest command in the CLI.
- Compact long sessions. Claude Code's compaction replaces history with a summary; practitioners report input-token savings around half in long multi-phase sessions. Codex added automatic recaps and experimental context management with the same goal in 2026. Compaction is lossy, so keep durable project facts in AGENTS.md or CLAUDE.md files, which reload each session for free instead of living in expensive history.
- Let caching work. Agent CLIs use prompt caching automatically, and cache reads cost a tenth of fresh input on both Anthropic and OpenAI price lists as of September 2026. Long-running sessions that keep a stable prefix cache well; workflows that constantly restructure context defeat it.
- Mind tool output. A verbose build log or a whole-file read is input tokens forever after. Point agents at focused paths and quiet down noisy commands.
Lever 4: hard budgets
In September 2026 Codex added configurable rollout token budgets: a per-thread budget tracked across agent threads, with remaining-budget reminders to the agent and turns aborted when the budget is exhausted. That turns the worst case (an agent looping through the night on a doomed approach) from an unbounded bill into a bounded one, which matters most for exactly the always-on, parallel setups teams are moving toward. If your CLI lacks native budgets, subscription usage windows serve as a crude equivalent, and provider consoles support per-key spend limits on metered keys. Set the ceiling before the overnight run, not after: overnight coding agent runs covers the rest of that discipline, and keeping Codex running after closing your laptop covers the session persistence underneath it.
Where AQ fits
AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud. On cost, AQ's position is deliberately boring: agents run as the real CLIs in persistent tmux sessions on your team's VM, each engineer logs into those CLIs with their own Claude or OpenAI account, and AQ never marks up model usage. Your token bill is whatever your plans and providers already charge, and the levers above apply unchanged.
What AQ changes is the operational side of the same equation. Each workspace gets its own isolated git worktree, so the parallel sessions this guide budgets for do not collide, and sessions survive a closed laptop and stream live to the browser, where teammates can watch and steer the same run instead of discovering an expensive loop the next morning. AQ itself is two plans: Free (a personal sandbox for one person, created by AQ in an isolated network, nothing to install, no time limit) and Team ($50 per user per month early access, standard $200, billed monthly, covering VMs you connect from your own cloud or a dedicated always-on AQ-managed VM, with your rate locked for your first 12 months).
Frequently asked questions
Are subscription plans or API keys cheaper for running coding agents?
For interactive daily use, subscription seats are almost always cheaper because the flat price absorbs the input-token growth of long sessions; a heavy engineer can consume far more than a seat's price in metered tokens. API keys win for automation that must not hit a usage window, and for light or bursty use. Many teams run both: seats for people, capped keys for pipelines.
Why do parallel coding agents cost so much more than one agent?
Each parallel agent or subagent is its own model instance with its own context window, so it re-reads project context the others already paid for, and orchestration messages between agents are themselves model calls. Practitioner measurements in 2026 put three subagents at roughly four times the tokens of the same work done single-threaded. Parallelism buys speed and isolation, not efficiency.
What is a rollout token budget?
A hard per-thread ceiling on how many tokens an agent run may consume. Codex added configurable rollout token budgets in September 2026: usage is tracked across agent threads, the agent gets remaining-budget reminders, and the turn aborts when the budget is exhausted. It bounds the worst case of an agent looping unattended, which is the main financial risk of overnight and parallel runs.
How much does prompt caching reduce coding agent costs?
Cache reads cost about a tenth of fresh input tokens on both Anthropic and OpenAI price lists as of September 2026 (Anthropic charges a small premium on the initial cache write). Since agent sessions re-send their entire history each turn, a session with a stable prefix can serve most of its input from cache. Agent CLIs manage this automatically; you mostly preserve the benefit by not restructuring context mid-session.
Does AQ charge for model usage?
No. In AQ, agents run as the real CLIs (Claude Code, Codex, Cursor Agent, Kimi, Grok) and each engineer logs in with their own Claude or OpenAI account, so model usage is billed by your providers at whatever plan or API rate you already pay. AQ never marks up model usage; its own pricing is a Free personal sandbox and a Team plan at $50 per user per month early access (standard $200, billed monthly).