109.8 billion tokens is an excellent number for a LinkedIn screenshot and a fairly bad unit for understanding what actually happened.
CodeHerder has one unusual advantage: its enormous number comes with a lot of detail.
The team published two months of history from a system that dispatches software work to coding agents. Since its first commit on May 26, it reports 1,166,207 assistant API calls, 30,134 agent sessions, 5,742 completed tasks and 109.8 billion tokens.
First correction: these are not "109.8 billion Claude tokens." The workflow runs Claude Code or Codex, depending on the agent and period.
Second correction: this is not a 109.8-billion-token bill in the ordinary credit-card sense. CodeHerder runs agents on flat-rate subscriptions and reconstructs API-list-price equivalents for its cost analysis.
The number that explains more is much smaller: 0.5%.
Almost none of the volume is output
In the window where CodeHerder recorded enough cache detail to price token categories precisely, 83.7 billion tokens, only 0.41 billion were output tokens.
The rest is reported as:
- 97.3% cache reads;
- 2.1% cache writes;
- 0.1% uncached input;
- 0.5% output.
Their calculation puts an average call at roughly 97,543 input tokens for 491 output tokens.
"Input" does not mean the agent discovers 97,543 new tokens of source code on every call. CodeHerder includes the system prompt, stage brief, conversation history, tool results, opened files, test logs and code the agent produced earlier in the session.
Most importantly, a cache read is context that was already assembled and is being sent again.
That is why the 109.8-billion headline needs care. Dividing the totals gives a rough 3.64 million accounted tokens per agent session. It does not mean every session consumed 3.64 million unique tokens of new information. Much of the volume is material repeatedly brought back onto the table.
The system emits relatively little compared with everything it keeps present in order to decide what to emit.
Five agents to move one story to done
CodeHerder does not give one agent "build this feature" and wait for the magic to fill the screen.
Its default workflow splits the job into plan → code → review → merge → verify. Each stage gets a fresh agent context in an isolated Git worktree. Review can send work back to code. Post-merge verification can do the same.
That structure produces telemetry that can attribute model calls to named stages.
In the published dataset, 2,677 user stories reportedly moved from a short description to merged code without a human writing or editing the implementation. Of those, 2,444 passed every gate on the first attempt, 91.3%.
That is an impressive number. It does not show that staged orchestration caused the rate.
CodeHerder says this explicitly: there is no matched control where the same stories ran without gates. We are observing one production process operating under its own protocol, not a randomized experiment in software orchestration.
A surprising amount of "we replaced the team with agents" writing manages to lose that sentence on the way to publication.
Post-merge verification still finds failures
The gates do reveal something practical.
At review, 233 of 3,017 resolutions were sent back to code, 7.7%. After merge, verification still sent back 63 of 2,728 cases, 2.3%.
That last number is useful.
Even after one agent implemented the change, another reviewed it and a merge stage landed it, exercising the merged state still found failures.
It does not prove that 2.3% of all agent changes would be broken without verification. The cohorts and denominators do not support that generalization. It only shows that, in this workflow, the final gate is doing non-empty work.
That fits a broader rule for agentic development: reviewing a reasoning trace or diff is not the same thing as exercising the final artifact.
Even the $7.54 cost is not an invoice
For clean stories that passed without rework, CodeHerder reports a median API-equivalent cost of $7.54 and median lead time around 50 minutes. The p10 is $4.57, p75 $10.06 and p90 $14.44.
Those dollars are notional.
The team says its agents run on flat-rate subscription plans. It calculates what each recorded call would have cost at published API rates, using the relevant model and separate prices for uncached input, cache writes, cache reads and output. Its priced window begins on June 29 because earlier logs did not preserve enough cache-lifetime information to price writes exactly.
Calling a feature "$7.54" without that sentence turns an analytical estimate into a fake receipt.
Model allocation complicates the result further. In the measured configuration, judgment stages such as planning, review and verification almost always use the reasoning tier, while code and merge mostly use a faster, cheaper tier.
Planning therefore represents 31.4% of the median story cost in the main analysis, slightly more than implementation at 28.6%. Some of that may be workload. Some is the model assigned to the workload.
CodeHerder later published a separate analysis of a reasoning-model migration. In its own telemetry, changing that model moved median story cost by 2.4x and lead time by almost 3x while the codebase and workflow stayed broadly comparable.
Still vendor data. But the shift is large enough to make one point concrete: an agent architecture also contains a model-allocation policy.
Two humans, but not the same counter
CodeHerder's current site has another attractive counter: "CodeHerder builds CodeHerder," with more than 3,100 agent tasks, 76 days and two humans as of August 10.
That number should not be merged casually with the 5,742 tasks in the 109.8-billion-token article. The pages do not define those cohorts as identical.
CustomLabs, the studio that funds and runs CodeHerder, describes itself as a small group of senior engineers. That makes the experiment interesting: a small operation can now produce enough model activity for its call accounting to resemble a much larger software service.
But "two humans produced 109.8 billion tokens" would be cleaner copy than the published data actually allows.
The CSV is still missing
The largest weakness in the investigation remains straightforward: all of these measurements come from the vendor building the orchestration product.
CodeHerder documents methodology unusually well for a production write-up. It names model confounders, distinguishes actual subscription spend from notional API pricing, excludes ambiguous sessions from some cohorts, and refuses several tempting causal conclusions.
That is useful discipline.
I still could not find a public raw dataset or independent audit that would let someone reproduce the 109.8-billion total, gate rates or cost cohorts. These remain self-reported measurements, not a public benchmark.
The most useful observation does not require pretending the dataset represents the whole industry.
On their workload, nearly all token activity goes into maintaining and rereading the context required to do the work, not emitting the final diff.
If this style of development spreads, the interesting optimization may move with it: less "how do we generate even more code?" and more "which information deserves to come back on the next call, and how do we know it is still worth reading?"