Correction (2026-10-12): This post originally said $433,200 per year was the cost "for a 10-developer team" and showed a worked example (16,000 vs 72,700 tokens per task, $3 / $15 per 1M pricing, 18 tasks a day) that is not how the figure was calculated. The $433,200 is a modelled figure per 100,000 agent sessions per month, comparing hypothetical 48,200-token and 12,100-token sessions at Claude Fable 5 input pricing ($10 / 1M tokens). The worked example now shows that calculation. We also corrected the cohort size (100 platforms, not 75) and removed the "3.1× to 6.8×" multiplier, the 61% retry-loop figure, the dimension weights, and the Confluence-docs average, none of which are supported by the published dataset. Full list with evidence: ARS 2026 errata (also in the research repository).
Every developer using an AI coding agent thinks about the same question eventually.
Why is this taking so many tokens?
The agent is calling the same endpoint repeatedly. It is reading documentation it has already read. It is re-clarifying information that should have been obvious from a single, well-structured source. And every single one of those extra calls has a cost — metered, billed, and compounding.
We modelled this problem directly.
Our State of Agent Readiness 2026 cohort covers 100 AI and developer infrastructure platforms, assessed with a simulated, deterministic agent traversal (no LLM is called; token figures are modelled from hop counts). Across that cohort, the modelled cost of one full 10-benchmark traversal ranges from 26,155 to 55,340 tokens, with a mean of 30,856. In total, the cohort's traversals carry 549,995 modelled wasted tokens — one traversal per platform, summed across all 100.
To put a price on the gap, we compared a hypothetical low-readiness session (48,200 tokens) with a hypothetical high-readiness session (12,100 tokens). At Claude Fable 5 input pricing, and at a volume of 100,000 agent sessions a month, the annual difference is $433,200 per year.
That is the documentation token tax.
This figure is a model, not a measured bill. It counts input tokens only, at Claude Fable 5 input pricing ($10 / 1M tokens), for 100,000 agent sessions per month. The two session sizes are illustrative and do not appear in the dataset. The same calculation gives $216,600 per year at GPT 5.6 Sol pricing and $64,980 at Gemini 3.6 Flash pricing.
Why Documentation Causes Token Waste
Token waste from poor documentation is not a single problem. It is a cascade.
It starts with discovery failure. The agent cannot find the right entry point quickly, so it begins searching — reading multiple pages, following dead links, consuming tokens on material that is not relevant to the task.
Then comes context fragmentation. Even when the agent finds the right documentation, the information it needs is spread across several disconnected pages. It must hold all of those fragments in working memory simultaneously, which means loading more tokens per request.
Then comes stale content correction. The agent follows an example. The example fails at runtime. The agent reads the error, reformulates its understanding, re-reads the documentation to find the discrepancy, and tries again. In our experience this retry loop is one of the most expensive patterns in agent-assisted integration. (Our benchmark is a deterministic traversal, so it does not measure retry loops directly.)
Finally, ambiguity overhead. When documentation is vague, the agent issues clarification attempts. It reads surrounding context trying to infer what a term means, how a parameter behaves, or what the expected output should look like. Every clarification attempt costs tokens without advancing the task.
Documentation quality is one of the highest-leverage variables in AI token cost optimization. It affects the number of reasoning steps required before the agent can act, not just the cost of each step.
Calculating the Token Tax: A Worked Example
Here is how the $433k figure is derived.
Take two hypothetical agent sessions against two platforms:
- On a high-readiness platform, a session consumes about 12,100 input tokens.
- On a low-readiness platform, the same session consumes about 48,200 input tokens.
That is a difference of 36,100 tokens per session; the low-readiness session is roughly 4× the size of the high-readiness one. These session sizes are illustrative; the dataset's mean modelled session (one full traversal) is 30,856 tokens.
| Metric | High-Readiness | Low-Readiness | Difference |
|---|---|---|---|
| Input tokens / session | 12,100 | 48,200 | 36,100 |
| Cost / 1,000 sessions (at $10 / 1M) | $121.00 | $482.00 | $361.00 |
| Sessions / month | 100,000 | 100,000 | — |
| Months / year | 12 | 12 | — |
At Claude Fable 5 input pricing ($10 / 1M tokens): ($482.00 − $121.00 per 1,000 sessions) × 100 × 12 = $433,200 per year, per 100,000 agent sessions a month.
| Model (input pricing) | Annual difference, 100k sessions / month |
|---|---|
| Claude Fable 5 | $433,200 |
| GPT 5.6 Sol | $216,600 |
| Gemini 3.6 Flash | $64,980 |
Scale it to your own volume: at 10,000 sessions a month, the Claude Fable 5 figure is $43,320 a year.
The Documentation Variables That Drive Token Cost
The ARS 2026 benchmark scores 10 pass/fail benchmarks rather than weighted dimensions. The documentation properties below are the ones we believe drive token overhead most — this is our guidance, not a measured correlation from the dataset.
1. Entry Point Clarity How clearly a documentation ecosystem signals where an AI agent should begin. An unstructured homepage, or a navigation that requires depth-first exploration instead of direct routing, increases discovery overhead.
2. Code Sample Validity Whether code examples in documentation are executable and current. Stale examples drive correction loop behavior, which is an expensive category of token waste.
3. Prerequisite Explicitness Whether dependencies, environment setup, and API key requirements are stated upfront. Agents without this context issue repeated clarification attempts that consume tokens without advancing the task. (Only 18% of the ARS 2026 cohort passes B-04, Quickstart Completeness.)
4. Structural Coherence Whether the documentation follows a consistent logical structure that allows an agent to build an accurate semantic map of the product surface. Inconsistent terminology, undefined acronyms, and navigation gaps all degrade coherence. (Only 16% pass B-07, Core Concept Disambiguation.)
The Platforms That Are Most Exposed
Our dataset shows where the friction sits. Almost every platform is easy to discover (95% pass B-01), but pass rates drop to 21% for auth, 18% for quickstarts and API reference, 11% for error surfaces and 0% for rate limits. Each failed step means more hops, and more hops mean more modelled tokens.
From our reading of the documentation itself (a qualitative view, not a measured result): platforms whose documentation is polished, narrative-driven and visually rich but structurally fragmented tend to be built for human discovery, not machine traversal. Platforms with dense, current, structurally rigid reference documentation tend to fare better. Even when the prose is rough, the structural integrity of the information is higher.
The platforms we would expect to be most exposed have:
- Documentation that has not been synced with source code in a long time
- No machine-readable index (
llms.txtor equivalent) - Examples using deprecated SDK versions
- Undocumented errors and rate limits
The best performers share a common trait: documentation is treated as an engineering artifact, version-controlled and validated the same way source code is.
What You Can Do Right Now
You do not need Glintbase to start reducing your documentation token tax. There are four things you can do immediately.
1. Publish an llms.txt file.
Place a structured plain-text index at yoursite.dev/llms.txt that tells AI agents exactly what your product does, where the key documentation lives, and how to navigate it. This is a cheap, high-leverage fix for entry point clarity.
2. Validate your code examples. Run your documentation code examples in a CI pipeline. Identify which examples fail against the current SDK version and prioritize fixing them. Broken examples drive one of the most expensive token waste patterns.
3. Add explicit prerequisites to every guide. Every guide should begin with a clear list: what you need installed, what credentials you need, what version of the SDK is expected. This removes a major source of clarification overhead.
4. Consolidate fragmented content. If a single concept is explained across four different pages, merge them. Fragmentation is expensive in both human and machine comprehension — but it is especially expensive for agents that must load all four fragments into working memory simultaneously.
The teams that will save the most money in the AI tooling era are not the ones who negotiate the best LLM pricing contracts. They are the ones who engineer their documentation surfaces so that every agent task requires the minimum possible context to complete successfully.
Beyond Token Cost: The Compound Effect
Token cost is the financial manifestation of a deeper problem.
When an agent spends several times more tokens to complete a documentation traversal task, it is not just costing money. It is also more likely to produce hallucinations, incorrect integrations, developer interventions, and longer time to resolution.
The token tax is a signal.
It tells you that your documentation is not operating at machine fidelity. It is telling you that AI agents are working harder than they should — and that the productivity gains you expected from AI tooling are being quietly absorbed by the overhead your documentation layer is creating.
The ARS 2026 Report scores 100 platforms. The averages are striking. But the real value is in the methodology: a repeatable scoring system that lets you measure where your platform stands and track improvement over time.
Read the full State of Agent Readiness 2026 Report for the complete dataset, scoring methodology, and platform-by-platform breakdown → glintbase.dev/research
