The Context Economy

A learner cannot evaluate a single Tradeoff section in the library without a model of the resource being spent. Deferred-context speaks of the "context toll," baseline-skill of a "line of attention," heavy-agent of the orchestrator's window as bottleneck — the currency is quoted everywhere and defined nowhere.

The context economy is the price model for the window: what an artifact costs to admit, in which denominations, and in whose window the bill lands. It is the statics of the context-engineering family — the price list, quoted over the substrate Statelessness establishes.

Three denominations, not one

Context is priced in quality (decay as the window grows), dollars (tokens × price, compounded per-turn by statelessness), and latency (prefill time scales with uncached input length). Caching discounts dollars and latency; nothing buys back quality — the model still attends over everything in the window. That asymmetry is why quality stars in this model.

Statelessness — the first principle the arithmetic derives from

(The property itself is a foundations pillar — Statelessness; this section keeps the cost-face arithmetic.)

The model holds nothing between calls. Every API call re-ships the entire conversation, system prompt, and tool schemas, so an always-on artifact is paid once per inference pass, not once per session — a 2k-token tool schema in a 50-turn session is ~100k tokens of re-transmission. Every price below compounds through this multiplier.

Quality: decay, not a cliff

The evidence-backed curve is rise → optimum → decay:

• The rise is real. Accuracy genuinely climbs while load-bearing context accumulates — adding relevant material helps until the task's requirement is met. Context engineering is the practice of operating near the optimum, not of minimizing tokens.
• The optimum is task-relative, not a static number. It sits where the task's load-bearing context is fully admitted and nothing else. Below it the task is starved; a task requiring 2x of knowledge has its optimum at 2x — no universal "x tokens is best" claim survives. The prime window is the band around that optimum.
• Past the optimum, decay is continuous and accelerating — gradual at first, steepening with length; rotted is the right-side failure. There is no universally forgiving plateau: models at the highest capability class the 2026-07-02 curve-shape anchors covered hold a flat band on easy retrieval-shaped tasks, but on semantic and multi-hop tasks decay begins almost immediately past the optimum.
• Decay scales with absolute length, not fraction of the advertised window. Models degrade measurably at a quarter of their claimed context; the advertised window is a hard ceiling, not the scale of the curve.
• The curve feels like a cliff even though it's a slope. Decay is silent — it begins well below where outputs visibly break, and the hardest tasks (reasoning, aggregation) fall fastest, so the first noticed failure arrives late and abruptly. True cliffs do exist, but as behavioral failure modes at model-specific thresholds (refusal onset, instruction-following collapse), not as the shape of the curve. Silence is the strongest argument for budgeting at the left edge of the optimum: you cannot feel the right edge approaching.
• Two competing forces, one consequence. Quality is the task's context requirement pulling admission up against length-driven decay pulling it down. Context-hungry tasks therefore have lower achievable peaks — their optimum sits in territory where decay is already underway, and no point on their curve escapes it. That is why the mechanisms exist: distillation shrinks the requirement itself (same information, fewer tokens — the optimum moves left); offload splits the requirement across windows (no single actor pays 2x). The mechanisms don't move you along the curve — they move where your curve peaks.

Three cost classes

• Always-on — paid every pass, forever: system prompt, registered skill descriptions, tool schemas, memory files (CLAUDE.md), the growing conversation itself. The standing tax behind baseline-skill's "earn its slot," multiplied by turn count. Always-on further splits by propagation scope — how many windows carry the artifact (see The scope value of context below); the inherited subclass is billed in every descendant's window, not just one.
• On-demand — paid only when fetched, resident only from then on: a skill body, a reference file, a workspace read. Two measured production skills show the range without claiming a population median: claude-api carries a 59:1 body-to-description ratio and 391:1 full-stack ratio; consulting-patterns is approximately 1,033:1 including its deferred corpus (ADR 0013). The true ratio is information, not bytes — deferred material also substitutes for tokens the actor would otherwise burn searching or re-deriving, so the measured bytes are a floor.
• Per-dispatch — paid once per boundary crossing: the dispatch, the subagent's boot context, the return. No warm reuse across dispatches.

Whose window pays

Every artifact's cost lands in some actor's window; the design question is always which one — and for inherited artifacts the answer is plural: every descendant's. The table below is the payoff of the whole model.

The time value of context

A token spent now costs more than the same token spent later: statelessness re-bills every resident artifact on every remaining turn, so the true price of admission is cost integrated over residency — (turns remaining × per-turn re-transmission) + (prime-window headroom held for the duration). The discounting runs opposite to money: early spending is penalized, not rewarded. Early window real estate is the most expensive, and always-on is simply maximum residency. Corollary: deferral wins by shortening residency, not by outrunning decay — just-in-time loading is cheap even in an empty window.

Residency-counting convention (family-wide; ruled 2026-07-11): an artifact's residency is tokens × the number of turns whose inference shipped the bytes as input. Content admitted with work remaining in the turn — a pasted reference, a skill body firing, a deferred fetch — counts its admission turn (the turn's remaining passes carry it): admitted at turn t of N → N − t + 1 resident turns. Content produced at a turn's end — a subagent return, the turn's own output — is first shipped the following turn: N − t. Worked examples in this family bill by this rule.

The scope value of context — the inheritance multiplier

Time value prices when a token is admitted; scope value prices how many windows it is admitted into. Always-on artifacts differ in propagation scope: a skill body is resident in one actor's window; a registered description in every actor it's registered with; and an inherited artifact — the system prompt, a CLAUDE.md line, a memory-file entry — is admitted at boot into every descendant actor's window: every subagent, every grandchild, every future session, for the life of the file. No downstream actor chose to admit it, and none can evict it.

The arithmetic, grounded: one ~20-token CLAUDE.md line in a 30-turn session that dispatches three subagents (~15 passes each) is 20 × (30 + 45) ≈ 1.5k tokens per session — trivial, and caching discounts the dollars anyway. That triviality is exactly why inherited layers rot: no single session's bill ever shows the cost. The true bill is tokens × passes × every window in the descendant tree × every session the project will ever run — a load inherently carried forever, by all descendants — and the quality denomination is undiscounted at every one of those windows: twenty tokens of attention paid by actors doing tasks the line has nothing to do with. Two consequences follow, and they are the first two entries on the consequence map below.

Caching: which denominations it discounts

(Anchors retrieved 2026-07-02 from the Anthropic prompt-caching docs; see Evidence. Ratio-shaped claims are the durable payload; the absolute numbers rot.)

• Reads ~0.1× base input price; writes ~1.25× at the 5-minute TTL, ~2× at the 1-hour TTL. Break-even at two requests — caching pays for itself almost immediately on any multi-turn session.
• A cache hit refreshes the TTL at no cost, so under steady traffic the effective lifetime is unbounded — TTL only bites across idle gaps.
• Cache reads don't count against rate limits — a throughput discount, not just dollars.
• Mechanics that shape usage: prefix-matched and byte-exact (a one-token edit upstream invalidates everything after it — stable prefixes are cacheable prefixes), ~0.5k–4k minimum cacheable length depending on model, four breakpoints per request.
• The asymmetry, restated: caching discounts dollars ~10× and latency similarly; it discounts quality 0% — the model attends over cached tokens exactly as if fresh. Cross-vendor the shapes differ (one vendor discounts reads ~0.5× automatically with no write premium; another discounts deeper but charges hourly storage) but the asymmetry is universal: no cache anywhere buys back quality.

The output side: tokens minted, not admitted

Everything above prices admission — tokens the window carries. The bill has a second line: generation. Output tokens are minted, not admitted, and they are the most expensive token class in the system — priced differently in all three denominations:

• Dollars: ~5× base input, uniformly. Across every current Anthropic tier the output price is five times the input price (anchor 2026-07-07 — see Evidence; the ratio is the durable payload, the absolutes rot). Against a cache read, the spread is ~50×: one output token costs what fifty cached input tokens cost.
• No discount exists. Caching is a prefix mechanism over input; every output token is minted fresh at full price, every time. The caching asymmetry above extends one row: input dollars discounted ~10×, input latency discounted, quality never — and output discounted in no denomination at all. (The batch API halves everything for latency-insensitive work — the one lever, and it trades away time, not the ratio.)
• Latency: serial, not parallel. Prefill processes input in parallel; decode mints output one token at a time. Wall-clock scales roughly linearly with output length, so for interactive work output length is the latency budget.
• Intermediary tokens bill as output. Thinking/reasoning tokens are billed at the output price and spend the same max_tokens budget; so do drafts, restatements, and scaffolding no reader ever sees. The top price applies whether or not the token reaches anyone.
• The statelessness kicker. Every output token immediately becomes conversation history — re-billed as always-on input on every remaining pass. Output is the only artifact minted at ~5× and then billed again, as residency, for the rest of the session.

Token inefficiency is the failure mode these prices define: spending the system's most expensive token class on work that doesn't need a model. The canonical instance is the formatting hoop — a request the model is superb at (understand the intent, generate the subjective response) with one clause bolted onto the end: "…and wrap all of this in JSON." That trailing clause:

• is a second task in the model's weak direction — byte-precise syntax and consistent structure, exactly the work the user-forward tool (the only minted child: substrates are a section, not nodes)'s match the tool to the task lesson says LLMs are bad at;
• executes at the worst window position — after the full response has been generated, the deepest and most decayed point of the pass;
• is priced as re-emission — the same information minted twice at output prices, once as substance and once as wrapper, plus the intermediary tokens spent getting the syntax right. A deterministic renderer performs the identical transform for zero tokens.

Schema-constrained decoding at the API layer (structured outputs) removes the malformed-output retry cost, but not the re-emission cost — the wrapper still bills at output prices. Only moving the transform out of the model removes the token cost. The remedy borrows its moves rather than adding one: route formatting to code via the user-forward tool (the only minted child: substrates are a section, not nodes) — the producer emits minimal structure, a renderer buys the polish — or constrain the shape at the schema/template layer rather than by trailing prose. The should is stated in objective — value per unit of context spent (cost / state / outcome lenses).

Cost linearity, per denomination

Dollars are linear per call but quadratic-ish per session (turn N resends turns 1…N−1; caching flattens this); latency is roughly linear in uncached prefill; quality follows the rise → optimum → decay curve above.

The bill: artifact → window

Definitions live in the glossary; this table is the cost mapping.

(Concept/substrate, not a move.) Nothing here prescribes a design step: the node prices the moves, it does not make one — and it carries no Tradeoff of its own.

Statics, beside dynamics and objective (three-way split settled in the 2026-07-02 context-flow grilling): this node is the price list; Context Flow models how context moves (admission, residency, placement, eviction); objective — value per unit of context spent (cost / state / outcome lenses) is the objective those prices and dynamics serve. Local prescriptions stay with the mechanics that justify them and are denominated in this node's units.

What changes once the prices are adopted. This node owns the map; each consequence is spent by the node that owns it — the first two fall out of the inheritance multiplier above.

• Value is not intrinsic to information; it is relative to the windows that will carry it. The same line is cheap in a skill body and expensive in a memory file. The required value of a line therefore scales with its propagation scope, and the widest scope carries the system's highest admission bar: an inherited line must be load-bearing for essentially every descendant. "True and occasionally useful" is precisely the material that rots inherited layers — each such line passes the local test (worth 20 tokens?) while failing the global one (worth 20 tokens in every window this project will ever spawn?).
• The bar plus graded access composed from deferral and distillation is an architecture. The inherited layer holds only two things: lines that clear the every-descendant bar, and tastes — pointers into the disclosure tree, where everything narrower lives at a depth whose propagation scope matches its actual audience. Neither half is complex; combined they generate the layered shape every heavyweight context system converges on — a lean inherited root, graded expansion below.
• The mechanisms inherit their motivation. The two-competing-forces framing (requirement vs. decay) gives the mechanisms their unified motivation: distillation moves the optimum left, offload splits the requirement across actors, deferral shortens residency.
• The output side prices the formatting-hoop failure mode; its remedy is the user-forward tool (the only minted child: substrates are a section, not nodes) (producer emits structure, renderer buys polish — formatting bought from code is free at the token layer), and the prescription — spend output tokens on judgment, not formatting — lives in objective — value per unit of context spent (cost / state / outcome lenses).
• The dependency runs one way. Every other node's Tradeoff section is denominated in this node's units.

Qualitative model is the durable payload; the anchors below are evidence, dated because they rot.

• Curve shape (verdict: plateau-then-cliff weakened to rise → optimum → accelerating decay; verified by two independent sweeps, one adversarial, 2026-07-02): Chroma, Context Rot (2025) — monotonic decline across all 18 models tested; NoLiMa (ICML 2025) — near-immediate decay on semantic tasks, models halved by 32k; RULER (NVIDIA 2024) — effective length ½–¼ of claimed; Liu et al., Lost in the Middle (TACL 2024) — positional decay within modest contexts; Databricks long-context RAG study (arXiv 2411.03538) — the rise phase is real (gains to ~16–32k), and behavioral cliffs exist (refusal onset 3.7%→49.5% from 16k→64k); arXiv 2510.05381 — length alone degrades performance even with perfect retrieval (silent decay); Anthropic, Effective Context Engineering (2025) — attention-budget framing.
• Cache economics: Anthropic prompt-caching documentation, retrieved 2026-07-02 (0.1× reads; 1.25×/2× writes at 5m/1h TTL; free TTL refresh on hit; rate-limit exemption; 4 breakpoints; 512–4,096-token minimums by model).
• Output pricing (anchor 2026-07-07, from current Anthropic pricing — reference cached 2026-06-24): output = 5× base input across every current tier (Haiku 4.5 $1/$5, Sonnet 5 $3/$15, Opus 4.8 $5/$25, Fable 5 $10/$50 per MTok); thinking/reasoning tokens billed as output and counted against max_tokens; cache discounts apply to input only (reads ~0.1× → the ~50× output-vs-cached-input spread); batch API −50% on all tokens (the sole output discount, paid in latency). Decode is autoregressive (serial); prefill is parallel. Ratio-shaped claims are the durable payload.
• Deferral ratios: ADR 0013, measured 2026-08-02 from two production skills with a stated tokenizer and error band — claude-api at 59:1 body-to-description and 391:1 full-stack; consulting-patterns at approximately 1,033:1 including its deferred corpus. These are specimen measurements, not a distribution estimate.

• The resource context-engineering manages — deferral, offload, and distillation are all strategies for spending it better — reframed by the quality curve as operating near the task-relative optimum, not minimizing (../mechanisms/cost-relocation/deferred-context/deferred-context.md).
• Statics, beside dynamics and objective — the split, and what each of the three siblings owns, is stated in Scope and boundaries.
• The scope-value bar is what graded access composed from deferral and distillation relieves: the inherited layer keeps only every-descendant-critical lines plus tastes; the disclosure tree holds everything narrower at a depth matching its audience. The pairing — inheritance cost + graded access — is the generative mechanic behind the layered architecture.
• Prices baseline-skill's "namespace slot + line of attention" tax (../../foundations/baseline-skill/baseline-skill.md).
• Substrate peer of ../../foundations/contract-documentation/contract-documentation.md — the contract makes seams safe; the economy explains why seams exist at all.
• Actor/artifact definitions live in the glossary; the cost mapping for them lives here (resolved 2026-07-02 — the actors-and-artifacts stub was dissolved into those two homes).

Cost models for time and space (Bentley, Programming Pearls, 2nd ed., 1999, Appendix 3): a measured price list for the primitives, published so a design can be costed by arithmetic instead of intuition. The bill table is that model drawn over a window, changed twice: a third denomination — quality — that no cache discounts, and a price that lands in some other actor's window — for inherited artifacts, in every descendant's at once.

• The Session Bill — one realistic 30-turn session billed, then re-billed under six single-decision shifts: each law of the model shown as a lever with a visible price (deltas are the payload, totals the scaffolding).