---
title: "The Context Economy · Agentic Atlas"
description: "The Context Economy: statics — the price list: denominations, the quality curve, cost classes, time value."
canonical: "https://agentic-atlas.dev/nodes/context-economy"
last-updated: "2026-08-19"
---

# The Context Economy · Agentic Atlas

[← the survey](https://agentic-atlas.dev/atlas)

1. concept
   The Context Economy
   Hook
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Thesis
   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.
   Laws & fences
  - Context is priced in quality, dollars, and latency; caching discounts dollars and latency, but nothing buys back quality.
  - Quality follows a rise, optimum, decay curve with a task-relative optimum, so context engineering operates near that optimum rather than minimizing tokens.
  - The true price of admission is cost integrated over residency, so early and inherited artifacts bill widest and deferral wins by shortening residency.
   When to reach
  - Reach for it when a Tradeoff section quotes a context toll or a line of attention and you need the resource behind the quote.
  - Skip it when you want a design step; the node prices the moves, makes none, and carries no Tradeoff of its own.
   Provenance
   [context-economy/definition](https://agentic-atlas.dev/nodes/context-economy#definition) · v1.0.2
   Addresses
   atlas_cards context-economy
2. [
   Statelessness
   ](https://agentic-atlas.dev/nodes/statelessness)
3. [
   Cost Relocation
   ](https://agentic-atlas.dev/nodes/cost-relocation)
4. [
   The Session Bill
   ](https://agentic-atlas.dev/nodes/session-bill)
5. [
   Foundations
   ](https://agentic-atlas.dev/nodes/foundations)
6. [
   Context Flow
   ](https://agentic-atlas.dev/nodes/context-flow)
7. [
   Baseline Skill
   ](https://agentic-atlas.dev/nodes/baseline-skill)
8. [
   Deferred Context
   ](https://agentic-atlas.dev/nodes/deferred-context)
9. [
   LLM Dispatch
   ](https://agentic-atlas.dev/nodes/llm-dispatch)
10. [
    Momentum
    ](https://agentic-atlas.dev/nodes/momentum)
11. [
    One Guide, Three Bills
    ](https://agentic-atlas.dev/nodes/one-guide-three-bills)
12. [
    Subagent Offload
    ](https://agentic-atlas.dev/nodes/subagent-offload)
13. field notes
  - “the *user-forward* tool (the only minted child: substrates are a section, not nodes)”
  - “**objective** — value per unit of context spent (cost / state / outcome lenses)”
  - “graded access composed from deferral and distillation”

Deferred ContextLLM Dispatch +4 more unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links context-economy

On this plate

[why-it-matters-the-problem](https://agentic-atlas.dev#why-it-matters-the-problem)[definition](https://agentic-atlas.dev#definition)[model-and-claims-the-price-list](https://agentic-atlas.dev#model-and-claims-the-price-list)[scope-and-boundaries](https://agentic-atlas.dev#scope-and-boundaries)[implications-the-consequence-map](https://agentic-atlas.dev#implications-the-consequence-map)[evidence-the-dated-anchors](https://agentic-atlas.dev#evidence-the-dated-anchors)[relationships](https://agentic-atlas.dev#relationships)[lineage](https://agentic-atlas.dev#lineage)[examples](https://agentic-atlas.dev#examples) [relationships](https://agentic-atlas.dev#relationships)

Every section is addressable on its own. Read only the ground you need.

## Why it mattersthe problem

[](https://agentic-atlas.dev#why-it-matters-the-problem)

why-it-matters-the-problem.md

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](https://agentic-atlas.dev/glossary/orchestrator)'s window as bottleneck — the currency is quoted everywhere and defined nowhere.

## Definition

[](https://agentic-atlas.dev#definition)

definition.md

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](https://agentic-atlas.dev/nodes/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.

## Model and claimsthe price list

[](https://agentic-atlas.dev#model-and-claims-the-price-list)

model-and-claims-the-price-list.md

### Statelessness — the first principle the arithmetic derives from

*(The property itself is a foundations pillar — [Statelessness](https://agentic-atlas.dev/nodes/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](https://agentic-atlas.dev/glossary/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](https://agentic-atlas.dev/glossary/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](https://agentic-atlas.dev/glossary/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](https://agentic-atlas.dev/glossary/dispatch), the [subagent](https://agentic-atlas.dev/glossary/subagent)'s boot context, the [return](https://agentic-atlas.dev/glossary/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](https://agentic-atlas.dev/glossary); this table is the cost mapping.

| Artifact | Whose window | Cost class | The gotcha |
| --- | --- | --- | --- |
| Skill description | Every actor it's registered with | Always-on | Paid whether or not the skill ever fires — ~60 tokens median, × every pass, × every session. "Earn its slot." |
| Memory line (`CLAUDE.md`, rules files) | **Every descendant's**, at boot | Always-on (inherited) | The widest propagation scope in the system: known by all grandchildren, billed in every future session, evictable only by editing the file. Admission bar: critical for *every* descendant. |
| Skill body | The invoking actor | On-demand | Admitted at invocation, resident to session end unless evicted; median ~25× the description. |
| Skill reference assets | The invoking actor | On-demand (deeper tier) | Only what's read is paid; heavyweight skills carry 100k+ tokens that cost nothing until fetched. |
| Agent definition | The **subagent's**, on dispatch | Per-dispatch | Invoked *by type*: the orchestrator references it, never loads it — heavy-agent's whole trick. |
| Tool schema | The actor holding the connection | Always-on | An MCP server ships *all* its tools' schemas whether or not any fire; the heaviest common standing tax. |
| Dispatch | Authored in caller's, admitted to callee's | Per-dispatch | The callee sees nothing else — packing it *is* the interface. |
| Return | The caller's | Per-dispatch | The one cost the caller can't defer; resident from arrival to session end, so early returns bill longest. |
| [Context envelope](https://agentic-atlas.dev/glossary/context-envelope) | The receiving actor | Per-dispatch | Distillation spends the *sender's* tokens to shrink the *receiver's* residency — the trade is the point. |
| [Workspace](https://agentic-atlas.dev/glossary/workspace) file | **Nobody's, until read** | Free at rest | The only free-at-rest artifact — why the workspace channel is named (llm-dispatch → Structure). Reading admits it like anything else. |
| Conversation history | Every actor's own | Always-on (growing) | The only row that grows by itself; turn N re-ships turns 1…N−1 — the quadratic-ish row. |

## Scope and boundaries

[](https://agentic-atlas.dev#scope-and-boundaries)

scope-and-boundaries.md

*(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](https://agentic-atlas.dev/nodes/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.

## Implicationsthe consequence map

[](https://agentic-atlas.dev#implications-the-consequence-map)

implications-the-consequence-map.md

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.

## Evidencethe dated anchors

[](https://agentic-atlas.dev#evidence-the-dated-anchors)

evidence-the-dated-anchors.md

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.

## Relationships

[](https://agentic-atlas.dev#relationships)

relationships.md

- 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](https://agentic-atlas.dev/glossary/contract) makes [seams](https://agentic-atlas.dev/glossary/seam) safe; the economy explains why seams exist at all.
- Actor/artifact **definitions** live in the [glossary](https://agentic-atlas.dev/glossary); the **cost mapping** for them lives here (resolved 2026-07-02 — the actors-and-artifacts stub was dissolved into those two homes).

## Lineage

[](https://agentic-atlas.dev#lineage)

lineage.md

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.

## Examples

[](https://agentic-atlas.dev#examples)

examples.md

- [The Session Bill](https://agentic-atlas.dev/nodes/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).

The relationships ledger

Evidence-bearing references

## Relationships

Every connection keeps the section where it was found. The map above orients; this ledger carries the evidence.

### Outbound references 12

1. in-slice · occurrence 1
   [Statelessness](https://agentic-atlas.dev/nodes/statelessness)
   each turn is conditioned on retained history again; logical reinjection yields a cost face and an explicit-state recovery face
   Evidence: [Definition](https://agentic-atlas.dev/nodes/context-economy#definition) · occurrence 1
2. in-slice · occurrence 1
   [Statelessness](https://agentic-atlas.dev/nodes/statelessness)
   each turn is conditioned on retained history again; logical reinjection yields a cost face and an explicit-state recovery face
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-economy#model-and-claims-the-price-list) · occurrence 1
3. undisclosed · occurrence 2
   Undisclosed relationship
   the *user-forward* tool (the only minted child: substrates are a section, not nodes)
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-economy#model-and-claims-the-price-list) · occurrence 2
4. undisclosed · occurrence 3
   Undisclosed relationship
   the *user-forward* tool (the only minted child: substrates are a section, not nodes)
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-economy#model-and-claims-the-price-list) · occurrence 3
5. undisclosed · occurrence 4
   Undisclosed relationship
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-economy#model-and-claims-the-price-list) · occurrence 4
6. in-slice · occurrence 1
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
   **dynamics** — admission, residency, and eviction; placement and recall within residency
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-economy#scope-and-boundaries) · occurrence 1
7. undisclosed · occurrence 2
   Undisclosed relationship
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-economy#scope-and-boundaries) · occurrence 2
8. undisclosed · occurrence 1
   Undisclosed relationship
   graded access composed from deferral and distillation
   Evidence: [Implications](https://agentic-atlas.dev/nodes/context-economy#implications-the-consequence-map) · occurrence 1
9. undisclosed · occurrence 2
   Undisclosed relationship
   the *user-forward* tool (the only minted child: substrates are a section, not nodes)
   Evidence: [Implications](https://agentic-atlas.dev/nodes/context-economy#implications-the-consequence-map) · occurrence 2
10. undisclosed · occurrence 3
    Undisclosed relationship
    **objective** — value per unit of context spent (cost / state / outcome lenses)
    Evidence: [Implications](https://agentic-atlas.dev/nodes/context-economy#implications-the-consequence-map) · occurrence 3
11. undisclosed · occurrence 1
    Undisclosed relationship
    graded access composed from deferral and distillation
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-economy#relationships) · occurrence 1
12. in-slice · occurrence 1
    [The Session Bill](https://agentic-atlas.dev/nodes/session-bill)
    one 30-turn session billed, then re-billed under six single-decision shifts
    Evidence: [Examples](https://agentic-atlas.dev/nodes/context-economy#examples) · occurrence 1

### Inbound references 22

1. in-slice · occurrence 2
   [Baseline Skill](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/baseline-skill#model-and-claims) · occurrence 2
2. in-slice · occurrence 4
   [Baseline Skill](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/baseline-skill#scope-and-boundaries) · occurrence 4
3. in-slice · occurrence 1
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow#relationships)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-flow#relationships) · occurrence 1
4. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#intent-the-problem-and-the-move)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Intent](https://agentic-atlas.dev/nodes/cost-relocation#intent-the-problem-and-the-move) · occurrence 1
5. in-slice · occurrence 3
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed) · occurrence 3
6. in-slice · occurrence 2
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Structure](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · occurrence 2
7. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 1
8. in-slice · occurrence 1
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#consequences-and-tradeoffs-one-cost-shape-for-another)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/deferred-context#consequences-and-tradeoffs-one-cost-shape-for-another) · occurrence 1
9. in-slice · occurrence 4
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#relationships)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 4
10. in-slice · occurrence 1
    [Foundations](https://agentic-atlas.dev/nodes/foundations#model-and-claims)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Model and claims](https://agentic-atlas.dev/nodes/foundations#model-and-claims) · occurrence 1
11. in-slice · occurrence 1
    [Foundations](https://agentic-atlas.dev/nodes/foundations#scope-and-boundaries)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/foundations#scope-and-boundaries) · occurrence 1
12. in-slice · occurrence 8
    [Foundations](https://agentic-atlas.dev/nodes/foundations#relationships)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/foundations#relationships) · occurrence 8
13. in-slice · occurrence 4
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch#model-and-claims)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Model and claims](https://agentic-atlas.dev/nodes/llm-dispatch#model-and-claims) · occurrence 4
14. in-slice · occurrence 6
    [LLM Dispatch](https://agentic-atlas.dev/nodes/llm-dispatch#relationships)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/llm-dispatch#relationships) · occurrence 6
15. in-slice · occurrence 5
    [Momentum](https://agentic-atlas.dev/nodes/momentum#relationships)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/momentum#relationships) · occurrence 5
16. in-slice · occurrence 1
    [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills#context)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Context](https://agentic-atlas.dev/nodes/one-guide-three-bills#context) · occurrence 1
17. in-slice · occurrence 1
    [The Session Bill](https://agentic-atlas.dev/nodes/session-bill#choice-a-baseline-bill-then-one-decision-at-a-time)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Choice](https://agentic-atlas.dev/nodes/session-bill#choice-a-baseline-bill-then-one-decision-at-a-time) · occurrence 1
18. in-slice · occurrence 1
    [The Session Bill](https://agentic-atlas.dev/nodes/session-bill#verification-what-recomputes-and-what-is-illustrative)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Verification](https://agentic-atlas.dev/nodes/session-bill#verification-what-recomputes-and-what-is-illustrative) · occurrence 1
19. in-slice · occurrence 1
    [Statelessness](https://agentic-atlas.dev/nodes/statelessness#scope-and-boundaries)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/statelessness#scope-and-boundaries) · occurrence 1
20. in-slice · occurrence 1
    [Statelessness](https://agentic-atlas.dev/nodes/statelessness#implications-the-consequence-map)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Implications](https://agentic-atlas.dev/nodes/statelessness#implications-the-consequence-map) · occurrence 1
21. in-slice · occurrence 3
    [Statelessness](https://agentic-atlas.dev/nodes/statelessness#relationships)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/statelessness#relationships) · occurrence 3
22. in-slice · occurrence 2
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    Evidence: [Avoid when](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when) · occurrence 2

[↑ back to the top](https://agentic-atlas.dev#content) [← the survey](https://agentic-atlas.dev/atlas)

Node context-economy · corpus 31de4cb · Catalog revision 35263c4c415da742953d0462804fb14424e2244dae4c63efd27e468988de70ab