The bill follows the judgment.

Published 14 November 2026 · 8 minute read

This is the second entry in a running account of what we build with AI agents and what it costs. It covers 11–14 November 2026, and the numbers were captured on the last of those days.

The total is $128.96 across 281 priced sessions and 13,941 priced assistant messages. The window held 331 sessions; 50 of them contain no priced message at all. Unlike the last entry, this is not a floor. That one had to admit that half its week was unmeasured after a data loss. Here, 594 assistant rows carry no price, but they are failed or aborted requests rather than missing records: 559 were rejected for a provider rate limit, most of the rest were invalid requests or aborts. A rejected request is not billed.

The shape of four days

Four days is a short window, but it holds two different ways of working. Wednesday was a review day on the client portal: a local verification pass, an audit, and a set of domain steps covering contracts, invoices, time and tenancy. Thursday was quiet. Friday and Saturday were a build push: first the portal's port away from Next.js, then an eight-phase architecture change in MochaFlux.

Measured spend by day, attributed to the day each message was sent rather than the day its session started. Messages are priced assistant messages; sessions active counts any session that produced one that day, so a run spanning midnight appears twice.

Day	Sessions	Messages	Cost	Where the money went
Wed 11	159	3,882	$54.09	Opus + Sonnet, 90%
Thu 12	30	3,125	$13.24	Terra, 48%
Fri 13	49	4,132	$27.33	Terra, 79%
Sat 14	47	2,802	$34.30	Terra + Sol, 88%

Wednesday carried 42% of the bill and the highest session count in the window. It was also the only day dominated by Anthropic models: Opus and Sonnet alone took 90% of its spend. That is what a review day looks like when the output is judgment rather than code.

By Saturday the mix had inverted. Terra and Sol, both OpenAI, took 88% of the day. The rotation started with a rate limit and ended with a set of role definitions, which is the subject of the rest of this post.

The bill follows the judgment

DeepSeek Flash handled 9,077 of the 13,941 priced messages — 65% of the work — for $12.28, or 9.5% of the bill. The two most expensive models, Terra and Opus, handled 19% of the messages and 63% of the spend. Per message, Opus cost 37 times what Flash cost; Terra cost 16 times.

Measured spend by model, 11–14 November 2026. Per-message cost is total cost divided by messages, the only fair comparison across models used for very different amounts of work.

Model	Messages	Cost	Per message
openai / gpt-6.1-terra	1,953	$45.35	$0.0232
anthropic / claude-opus-5-5	674	$35.39	$0.0525
anthropic / claude-sonnet-5-5	517	$15.11	$0.0292
openai / gpt-6.1-sol	616	$12.93	$0.0210
deepseek / deepseek-flash	9,077	$12.28	$0.0014
anthropic / claude-haiku-5-5	559	$2.69	$0.0048
everything else	545	$5.21	—

That is not a story about a model being overpriced. It is a story about what the messages were. Flash carried the portal port, the architecture review, and the invoice and signature work: reading, searching, running commands, writing code against a brief. Opus reviewed five commits, closed the audit gaps and verified the portal locally. Terra carried the MochaFlux architecture phases, where each message was deciding what the next phase should be and whether the last one was done.

The cached-token number makes the same point from another direction. The window read 2.72 billion cached tokens against 20.3 million tokens of fresh input and output, roughly 134 times as much. Long sessions live in the cache, and the cache is what makes a 158-call architecture phase possible. It is also what makes an unbounded thread expensive without anyone noticing.

What the money bought

The client portal produced 77 commits in three days. The visible work was invoices: a document view, a PDF download, one designed shell for every email, batch test sends, and signing links that open in a new tab instead of dead-ending in the app. Underneath, the port away from Next.js finished and the Vite + Supabase branch merged. A parallel attempt on SpacetimeDB stayed a branch.

MochaFlux produced 41 commits from late Friday night into Saturday afternoon. An eight-phase architecture plan — workspace authority, config writes, viewer context, atomic database operations, Snowflake views, a shared read model, refresh planning and permissions — was dispatched one phase per session, with a branch, a starting commit and a definition of done in each brief. The first phase landed with 336 backend tests green. Phase 8 was the last worker, and by Saturday afternoon a second pass was rebuilding schema tables and dataset-scoped views on top of it.

What is striking is how little conversation that took. The portal's 28 indexed sessions contain 220 human messages; MochaFlux's nine contain 37. That is a person setting a brief and checking a boundary, not a person steering every few turns. The written phase plan is what made that possible: it let the next session be handed a paragraph instead of a conversation.

The correction

Two things went wrong often enough to change how we work.

The first was review loops. One review session was running commit-review-fix-commit-review-fix cycles before anyone had decided how many rounds the task deserved. The correction was to define the loop: hand over the work, get one review, fix what it found, stop. A second round is a decision, not a default.

The second was context. On Saturday morning we asked why sessions were consuming so many input tokens. The answer was not the model. It was the size of the thread. The audit turned up one session in the 3D experiment that had run 3,377 steps and read 1.64 billion cached tokens — about a third of every input token we had ever consumed — because it never compacted and carried an 800,000-token history through every step. A MochaFlux phase session did the same thing at smaller scale: 158 model calls, 28.5 million cache reads, and a context already at 212,000 tokens by step seven, because the brief told it to read fourteen files before starting.

Three fixes went in that day. Tool output is now capped at 20KB or 600 lines. Compaction fires at 70% of the window instead of 85%. A read guard refuses unbounded reads of text files over 16KB and tells the agent to grep and range-read instead. The rules that used to live in one project's instructions now sit in the global file every session loads.

The other half was routing. The same investigation confirmed that an agent definition can pin one model and a step budget, but cannot cascade through a stack when a model hits a limit; the harness's failover is a single hop to one global fallback. So we shaped the roles around what each one actually needs.

The global subagent roles on 14 November. Steps is the hard cap on model calls; the return is what the parent session gets back.

Role	Model	Steps	Returns
scout	deepseek-flash	12	file and line references, no code
worker	deepseek-v4-pro, high	70	diff summary and commands run
worker-deep	gpt-6.1-sol, high	80	cross-module change and its risks
reviewer	gpt-6.1-terra, high	20	findings by severity
verifier	deepseek-v4.1-flash-free	10	pass or fail, failing lines only

The pins are the point. The scout reads and returns references; it does not need a frontier model. The verifier returns pass or fail; it can run on a free model. The reviewer and the cross-module worker are where a wrong call is expensive, so they get Terra and Sol at high effort. The worker in the middle gets DeepSeek's pro model, cheap enough to run often and strong enough to carry a scoped change. Every role has a step cap, because a role without one becomes the thing it was meant to prevent. The pins will move again; the budget is the durable part.

Rate limits made the routing urgent rather than theoretical. Terra carried the architecture work and was also the least available model in the window: 541 of its attempts were rejected for a token-per-minute limit, about one in five. On Friday it was one in four. A model you cannot call is not cheap at any price per token, and splitting the load across DeepSeek, Terra and Sol was as much about finishing the work as about the bill.

What we would tell another team

The tempting reading of this window is "use cheaper models". That is not what the numbers say. The cheap model already did two-thirds of the messages for a tenth of the bill. The expensive part was the judgment layer, and it earned its keep: the review that turned five commits into a list of findings, the phase plan that let eight sessions run without a person in the room.

The useful discipline is narrower. Route by the kind of judgment a task needs, cap how long any role can run, and make every role return something small enough to check. A cheap model on an unbounded thread is not cheap; an expensive model on a bounded review is not expensive. The number to watch is not the price per million tokens but the context each step has to carry, because that is the number that compounds.

The previous entry ended by saying that cost tracks how often you change what is in context. Four days later we would add a second clause: it also tracks how often you ask a model to decide something. Those turns cannot be delegated down, and they are what the bill is for. Pay for the judgment. Route the rest.