Mythos

Token Inflation is the silent expansion of an 📝Large Language Model (LLM) request's billed or context-consuming token count by content the user did not author and cannot directly inspect, typically injected by the client harness or provider between the user's prompt and the model.

The term names a pattern that recurs across agentic coding tools, chat clients, and API wrappers: the visible prompt is only a fraction of what the model actually receives. System prompts, tool schemas, retrieved context, auto-attached files, safety preambles, and version-specific telemetry all expand the payload before inference. When this expansion is stable and documented, it is overhead; when it changes silently between releases — or is injected server-side after the client has dispatched the request — it becomes inflation. The defining property is opacity: the user pays for and is shaped by tokens they did not write and cannot enumerate from inside the tool. The canonical recent example is the 📝Claude Code v2.1.100 Token Inflation regression, where ~20,000 additional tokens per request were added upstream of the model without appearing in /context.

Key Facts

  • Category: LLM tooling pattern / observability concern
  • Sources: client harness system prompt, tool schemas, 📝Retrieval-Augmented Generation (RAG) context, auto-attached files, provider-side injection, telemetry preambles
  • Detection: HTTP proxy capture, billing diff across versions, context window audit
  • Primary symptoms: higher per-request cost, faster context-window saturation, reduced adherence to user-authored instructions
  • Distinguished from: documented overhead (stable, disclosed) and user-authored bloat (visible in the transcript)

How It Works

Every LLM request is assembled from layered inputs before it reaches the model. The user sees the visible prompt; the provider and client add everything else. Inflation occurs at any layer that can silently grow between releases without disclosure.

  • Client-side injection — harness system prompts, hook output, skill listings, MCP tool schemas, and auto-attached files expand locally. Most of this is inspectable with verbose flags or /context.
  • Server-side injection — the provider may prepend safety, formatting, or telemetry tokens after the client dispatches. These do not appear in the client transcript and can only be inferred from billed-token deltas.
  • Retrieval expansion — RAG memory systems, and auto-loaded context pull documents into the prompt based on heuristics the user did not specify per-turn.
  • Schema bloat — tool and function definitions can dominate the payload in tool-heavy sessions; adding a handful of tools can add thousands of tokens per turn.
  • Version drift — each release can silently change any of the above. Without diffing across versions, the drift is invisible.

Why It Matters

Token inflation has three compounding effects. First, billing: metered users pay for content they did not author. Second, context: the model's working budget is shared with the injected content, so user instructions, memory, and CLAUDE.md-style rules are diluted and quality decays faster in long sessions. Third, trust: when a model ignores a rule, the user cannot distinguish between their own authorship error and unattributable upstream content. The combination undermines the premise of a controllable agentic environment — that the user decides what the model sees. Mitigations center on observability (proxy capture, version pinning, release-note diffing) and on keeping critical instructions concentrated and high-signal so they retain weight against whatever the harness adds.

FAQ

What is token inflation?

Token inflation is the silent growth of an LLM request's token count by content the user did not author and cannot directly inspect — such as system prompts, tool schemas, retrieved context, or provider-side injections added between the visible prompt and the model.

How is token inflation different from normal prompt overhead?

Overhead is stable and disclosed: a documented system prompt, a known tool schema, a predictable retrieval budget. Inflation is opaque and drifting — it changes between releases or is injected server-side without appearing in the client transcript, so the user cannot audit or predict it.

How do I detect token inflation?

Capture full API traffic through an HTTP proxy, compare billed token counts across client versions on identical inputs, and diff release notes for changes to system prompts or tool schemas. Client-side inflation is often visible in a /context or verbose mode; server-side inflation is only detectable from the outside.

How do I reduce token inflation?

Pin client versions when a release regresses, disable unused MCP servers and tools to shrink schema payload, tighten or consolidate 📝CLAUDE.md and memory files, and prefer harnesses that expose their full assembled prompt. For provider-side inflation, the only lever is version choice and vendor pressure.

Why does token inflation degrade output quality?

The model has a fixed context window. Every injected token competes with the user's instructions for attention and for budget before auto-compaction. Inflated context means user rules carry relatively less weight, and long sessions hit quality and compaction thresholds sooner.

Related

Contexts

Created with 💜 by One Inc | Copyright 2026