---
title: "Context Efficiency · concept · Agentic Atlas"
description: "Context Efficiency: how much task value you get for each unit of context spent."
canonical: "https://agentic-atlas.dev/nodes/context-efficiency"
last-updated: "2026-10-20"
---

1. [Agentic Atlas](https://agentic-atlas.dev/)
2. [Patterns in the Agentic Atlas](https://agentic-atlas.dev/atlas)
3. Context Efficiency

Parent of [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment).

1. concept
   # Context Efficiency
   **How do you tell whether an agent is spending its context well?**
   Context spend is judged through three analytic lenses: tokens per task achieved, the window share load-bearing for the task, and finishing inside the prime window.
   Hook
   how much task value you get for each unit of context spent
   Laws & fences
   - Score each design within its own constraints, since no universal ranking orders quality, dollars, and latency.
   - An efficiency claim names whether it improves quality, dollars, or latency, without hiding a lost quality.
   - Deleting the records needed to reconstruct a failed run is a hidden loss, not an efficiency gain.
   - Keeping the window relevant to the task is the hypothesized lever for both quality and token cost.
   - The node's heuristic is to spend expensive output tokens on reasoning that improves the outcome, not restatement.
   When to reach
   - Reach for this when a system keeps spending window space on tasks but no objective scores the spend.
   - Reach for this when tokens are being cut without checking outcome quality, latency, or evidence for debugging failures.
   Provenance
   [context-efficiency/definition](https://agentic-atlas.dev/nodes/context-efficiency#definition) · v1.1.0
   Addresses
   atlas_cards context-efficiency
2. [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
3. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
4. [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
5. [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
6. [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
7. [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
8. [Momentum](https://agentic-atlas.dev/nodes/momentum)
9. [Verification Asymmetry](https://agentic-atlas.dev/nodes/verification-asymmetry)
10. field notes
    - “the *user-forward* tool (the only minted child: substrates are a section, not nodes)”
    - “a named scaffold supplies the fixed shape; the model fills only its declared degrees of freedom”
    - “the travelling declared-shape contract specialization”
    - “the altitude above the single skill (N skills, compounding costs)”
    - “control flow in code, judgment in dispatches”

MomentumVerification Asymmetry +3 more unfold the map fold the map

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

On this plate

[why-it-matters-the-problem](https://agentic-atlas.dev/nodes/context-efficiency#why-it-matters-the-problem) [definition](https://agentic-atlas.dev/nodes/context-efficiency#definition) [model-and-claims](https://agentic-atlas.dev/nodes/context-efficiency#model-and-claims) [scope-and-boundaries](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries) [implications-the-consequence-map](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) [evidence](https://agentic-atlas.dev/nodes/context-efficiency#evidence) [relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) [lineage](https://agentic-atlas.dev/nodes/context-efficiency#lineage) [open-questions-todo](https://agentic-atlas.dev/nodes/context-efficiency#open-questions-todo) [relationships-ledger](https://agentic-atlas.dev/nodes/context-efficiency#relationships-ledger)

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

## Why it matters — the problem

[Permalink to Why it matters — the problem section](https://agentic-atlas.dev/nodes/context-efficiency#why-it-matters-the-problem)

An agentic system spends a [window](https://agentic-atlas.dev/glossary/window-context-window) every turn, and the spending decisions never stop: which task deserves window space now, which takes the degraded end-of-window slot, which is dispatched to a cheaper [actor](https://agentic-atlas.dev/glossary/actor)'s window, how much of the top-priced output class to spend thinking before answering. A price list answers none of them — it says what context *costs* — and a pipeline model says how it *moves*. Neither says what *good* looks like. Designed without a named objective, systems fail in a symmetric pair: **blind minimization** — tokens cut until the task is *starved* of what it needed, the workflow "efficient" and wrong — and **no objective at all** — every skill answering the allocation questions implicitly, the window grown past its optimum with nobody scoring the spend. Token efficiency is a *feasibility* condition before it is a cost one: a workflow past its usable window, or economically unusable, has not achieved its goal. But it is scored against outcome quality, latency, and the evidence needed to understand a failed run — never alone.

## Definition

[Permalink to Definition section](https://agentic-atlas.dev/nodes/context-efficiency#definition)

**Context efficiency = value delivered per unit of context spent.** Value is the task's outcome, in the quality the task requires; the unit is the economy's three denominations — quality, dollars, latency — compounded per turn by [statelessness](https://agentic-atlas.dev/glossary/statelessness). One objective, three lenses:

- **Cost lens — tokens per task achieved.** Output per unit input, in the economy's units. The one lens countable today: every token is billed.
- **State lens — relevancy.** The fraction of an actor's resident window that is load-bearing *for the task at hand* ([relevancy](https://agentic-atlas.dev/glossary/relevancy)). Inspectable mid-flight; the lens the strategies under this node move.
- **Outcome lens — prime-window completion.** The task is [admitted](https://agentic-atlas.dev/glossary/admission) and finished inside the [prime window](https://agentic-atlas.dev/glossary/prime-window) — the band around the quality curve's task-relative optimum. What the user experiences.

**The lenses are analytic, not benchmarks** *(ruled 2026-09-10 — ADR 0021)*. Each could be measured; none is well-defined as a metric today. The cost lens counts. Relevancy has a per-artifact inspection, not a rubric: *would the next turn's output change if this artifact were evicted?* — the fraction that would is the reading. Prime-window completion has one measurable proxy — whether the window crossed the actor's **effective length**, the point, measured per model, where accuracy falls below 85% of its short-context score — and no curve to read completion off directly.

## Model and claims

[Permalink to Model and claims section](https://agentic-atlas.dev/nodes/context-efficiency#model-and-claims)

- **Normative rule — the objective.** Optimize value per unit spent, in all three denominations at once. There is no universal ranking of quality over dollars over latency; a design is scored within its own constraints, and **an efficiency claim names the denomination it improves and does not hide a lost quality or diagnostic capability** *(ruled 2026-07-14 — ADR 0009)*.
- **Hypothesis — the lenses chain causally.** High relevancy keeps the window in the prime window; the prime window is where completion quality peaks; completing there is what keeps tokens-per-task low. **Relevancy is the lever; the other two lenses read its effect.** The chain is inferred from the economy's curve and the interference evidence below, not measured end to end — which is why the lenses stay analytic.
- **Empirical result — non-load-bearing residents cost accuracy, and the price rises with resemblance.** Unrelated filler mostly spends window length, which already costs on its own; *near-miss* material — same entities, same topic, no answer — is what is measured to cost most: one in-topic sentence took a solved math set from 95 to 63. Retrieved-but-wrong context can be worse than none. The grounding is in *Evidence*; the task-relative fit is described by [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment).
- **Heuristic — operate in the prime window.** The economy's rise → optimum → decay curve makes the band at each task's optimum the target. Staying there is an ongoing scheduling problem, not a one-time budget — and decay past the optimum is *silent*, so the band cannot be felt from inside. Budget at the left edge.
- **Heuristic — admit just-in-time.** The time value of context makes early admission the most expensive move: cost compounds across every remaining turn. Deferral wins by shortening residency, not by outrunning decay.
- **Heuristic — end residency by design.** Compaction, summarization, truncation, and dispatch returns [evict](https://agentic-atlas.dev/glossary/eviction); deep decay can make a resident artifact ineffective, but it does not end residency. Do not wait for decay to do eviction's job.
- **Heuristic — allocate windows by task value.** Window-time is allocated by importance, like CPU time: sometimes a task simply *is* less valuable, and it gets the end-of-window slot or a cheaper actor's window.
- **Heuristic — score the throwaway class by what it returns.** Output is the system's most expensive token class (~5× input, discounted in no denomination — the economy's price). It splits in two: **delivered tokens**, the artifact a reader or the next actor consumes, and **throwaway tokens** — reasoning, drafts, restatements, wrapper — minted at the top price and delivered to nobody. Throwaway is not waste by definition: **reasoning tokens are the model buying judgment**, and the objective prices them by the quality they return, not by whether anyone reads them. The throwaway that returns nothing is *re-emission* — the same information minted twice, once as substance and once as wrapper. So the rule is *spend the top-priced class on judgment, and let nothing else be minted there*: reasoning that moves the outcome is efficient at 5×; formatting that restates it is not, at any price. The priced failure mode is the economy's **formatting hoop**; its remedies — route the transform to code, or constrain shape at the schema layer — are found with *the *user-forward* tool (the only minted child: substrates are a section, not nodes)* and *a named scaffold supplies the fixed shape; the model fills only its declared degrees of freedom*. On models that keep prior turns' reasoning resident, throwaway also pays residency — one more turn of the statelessness multiplier on tokens that already returned everything they will (*Evidence*).

## Scope and boundaries

[Permalink to Scope and boundaries section](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries)

*(Concept — the objective, not a move.)* This node scores; it does not schedule, price, or model movement. How well context fits the task is [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)'s subject; what a token costs is [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)'s; admission, residency, placement, and eviction are [Context Flow](https://agentic-atlas.dev/nodes/context-flow)'s verbs.

**Objective-derived guidance only.** The heuristics above follow from the objective and the price list, and from nothing narrower. A prescription that follows from one mechanism's mechanics — how far a pointer may be deferred, when an offload seam pays for itself, what a distilled envelope must carry — is found with that mechanism; efficiency names the objective it serves *(ruled 2026-07-14 — ADR 0009)*.

**Not a metric ranking, and not a benchmark.** The three denominations do not convert, so no design is "most efficient" without a stated constraint set. And the lenses are analytic *(ruled 2026-09-10)*: a workflow can be scored by inspection and argued about in these terms; it cannot yet be assigned a relevancy or a prime-window number that two observers would reproduce.

**Diagnosability is a term in value, not a cost to minimize.** The smallest structured evidence sufficient to reconstruct what governed a run — receipts, manifests, identifiers, compact event records — is part of what the spend buys. Retaining every intermediate token is not; deleting the receipts to save tokens is not efficiency, it is a hidden loss of capability (ADR 0009).

Nearby ideas this node does not absorb: **momentum** is resident context *steering* the model, a dynamics phenomenon, not a relevancy shortfall ([Momentum](https://agentic-atlas.dev/nodes/momentum)); **verification** decides whether the delivered artifact is right, which is the value term's *source*, not efficiency's business ([Verification Asymmetry](https://agentic-atlas.dev/nodes/verification-asymmetry)).

## Implications — the consequence map

[Permalink to Implications — the consequence map section](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map)

What changes once the objective is adopted. This node owns the map; each consequence is spent where it is owned.

- **Every mechanism is scored on the same dashboard.** Deferral moves the cost lens (shorter residency); distillation moves the state lens (more signal per resident token); offload moves the outcome lens (the requirement split so no single window leaves its prime band). The moves stop being incomparable tricks and become alternative spends of one budget. → [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context), *the travelling declared-shape contract specialization*, [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload) (each mechanism's own bill).
- **Context must fit the task.** Useful material must apply to the current question; shared subject matter alone does not establish fit. Selection, grouping, and eviction can change that fit. → [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment) (the property those moves affect).
- **Feasibility is the first score.** A workflow whose window crosses the actor's effective length has not achieved its goal, whatever its correctness on paper — token efficiency is the condition under which the task exists at all.
- **Reasoning spend is budgeted, not banned.** The throwaway class is a purchase of judgment at the top price; the design question is how much judgment the task needs, and the answer is read off the outcome lens, not off the bill.
- **Window-time is contended, so something schedules it.** N skills competing for one actor's window, or control flow in code deciding what runs where, are allocation decisions this objective scores. → *the altitude above the single skill (N skills, compounding costs)*, *control flow in code, judgment in dispatches*.

## Evidence

[Permalink to Evidence section](https://agentic-atlas.dev/nodes/context-efficiency#evidence)

The objective is analytic; the claims it leans on are grounded where they are owned.

- **Prices and the curve** — the economy's dated anchors: output at ~5× base input across every current tier, thinking tokens billed as output, residency re-billed per turn (anchor 2026-07-07); rise → optimum → decay, silent past the optimum, scaling with absolute length (two sweeps, 2026-07-02). → [The Context Economy](https://agentic-atlas.dev/nodes/context-economy), *Evidence*.
- **Relevancy as the lever** — the interference and conflict synthesis of 2026-09-09: NoLiMa's single in-topic distractor cut GPT-4o's effective length from 8K to 1K; length alone degrades accuracy with whitespace filler; GPT-3.5's 56.1% closed-book beat its own 20- and 30-document accuracy when the answer sat mid-window. No study yields a turn-indexed decay curve, which is why the outcome lens bills an effective-length crossing and not a slope. → research synthesis.
- **Throwaway residency** — Anthropic's thinking documentation (retrieved 2026-09-10): thinking tokens count against `max_tokens` and are reported in `usage.output_tokens_details.thinking_tokens`; models numbered 4.6 and higher (and Opus 4.5) keep prior turns' thinking blocks in context and bill them as input, where Sonnet 4.5, Haiku 4.5, and earlier stripped them. The residency clause above holds on the former; on the latter, throwaway is paid once.
- **What would revise the claims.** A turn-indexed decay curve for a named model would make prime-window completion measurable and promote the outcome lens from analytic to read. A relevancy rubric that two observers reproduce would do the same for the state lens. A head-to-head showing reasoning tokens with no outcome effect at the task's difficulty would move reasoning from *judgment bought* to *re-emission* for that task class.

## Relationships

[Permalink to Relationships section](https://agentic-atlas.dev/nodes/context-efficiency#relationships)

- **Objective, beside statics and dynamics:** [The Context Economy](https://agentic-atlas.dev/nodes/context-economy) prices what residency costs; [Context Flow](https://agentic-atlas.dev/nodes/context-flow) models how context moves; this node says what to optimize.
- **Child: [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)** — how well the available context fits the task at hand.
- **The mechanisms are scored here and executed there:** [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context), [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload), *the travelling declared-shape contract specialization*.
- **The formatting hoop is priced at the economy and remedied at the mechanisms:** *the *user-forward* tool (the only minted child: substrates are a section, not nodes)*, *a named scaffold supplies the fixed shape; the model fills only its declared degrees of freedom*.
- Task prioritization touches *the altitude above the single skill (N skills, compounding costs)* (N skills contending for the same windows) and *control flow in code, judgment in dispatches* (control flow in code deciding what runs where).
- *Relevancy* and *prime window* are defined in the [glossary](https://agentic-atlas.dev/glossary); this node teaches the objective they serve.

## Lineage

[Permalink to Lineage section](https://agentic-atlas.dev/nodes/context-efficiency#lineage)

The working-set principle and thrashing (Denning, *The Working Set Model for Program Behavior*, CACM, 1968): a process is run only while the pages it is actively using are resident, because a resident set that does not match the work at hand collapses throughput — the objective is *resident matches required*, not *resident minimized*. Relevancy is that principle over a window. The delta runs two ways: the working set is read off recent references, where relevancy is judged against the task ahead; and thrashing announces itself in the page-fault rate, where decay past the optimum is silent. (Flow takes the same lineage's mechanism — admission, residency, eviction, stack distance; this node takes its objective.)

## Open questions / TODO

[Permalink to Open questions / TODO section](https://agentic-atlas.dev/nodes/context-efficiency#open-questions-todo)

- Which scheduling heuristics generalize across tasks and models, and which stay judgment calls — the four allocation heuristics above are stated as heuristics for that reason.
- A relevancy rubric two observers reproduce; a turn-indexed decay curve for a named model. Either would promote its lens from analytic to measured (*Evidence* states the revision).
- More strategy children over time (placement policy? admission policy as its own move?) — each needs a move of its own, something it tells you to *do*; a remedy borrowed from elsewhere stays a section here.

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 25

1. in-slice · occurrence 1
   [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
   how well the available context fits the task at hand
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-efficiency#model-and-claims) · occurrence 1
2. 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-efficiency#model-and-claims) · occurrence 2
3. undisclosed · occurrence 3
   Undisclosed relationship
   a named scaffold supplies the fixed shape; the model fills only its declared degrees of freedom
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-efficiency#model-and-claims) · occurrence 3
4. in-slice · occurrence 1
   [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
   how well the available context fits the task at hand
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries) · occurrence 1
5. in-slice · occurrence 2
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
   what each piece of context costs, in quality, dollars, and latency, and who pays
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries) · occurrence 2
6. in-slice · occurrence 3
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
   how context enters, stays in, and leaves a model's window, and how well it's recalled
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries) · occurrence 3
7. in-slice · occurrence 4
   [Momentum](https://agentic-atlas.dev/nodes/momentum)
   how context already in the window steers the model along its current path
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries) · occurrence 4
8. in-slice · occurrence 5
   [Verification Asymmetry](https://agentic-atlas.dev/nodes/verification-asymmetry)
   why checking an answer can be easier than producing it, and when that fails
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-efficiency#scope-and-boundaries) · occurrence 5
9. in-slice · occurrence 1
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
   keeping a short pointer loaded and fetching bulky context only when a session needs it
   Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 1
10. undisclosed · occurrence 2
    Undisclosed relationship
    the travelling declared-shape contract specialization
    Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 2
11. in-slice · occurrence 3
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 3
12. in-slice · occurrence 4
    [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
    how well the available context fits the task at hand
    Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 4
13. undisclosed · occurrence 5
    Undisclosed relationship
    the altitude above the single skill (N skills, compounding costs)
    Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 5
14. undisclosed · occurrence 6
    Undisclosed relationship
    control flow in code, judgment in dispatches
    Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 6
15. in-slice · occurrence 1
    [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
    what each piece of context costs, in quality, dollars, and latency, and who pays
    Evidence: [Evidence](https://agentic-atlas.dev/nodes/context-efficiency#evidence) · occurrence 1
16. in-slice · occurrence 1
    [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
    what each piece of context costs, in quality, dollars, and latency, and who pays
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 1
17. in-slice · occurrence 2
    [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
    how context enters, stays in, and leaves a model's window, and how well it's recalled
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 2
18. in-slice · occurrence 3
    [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
    how well the available context fits the task at hand
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 3
19. in-slice · occurrence 4
    [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
    keeping a short pointer loaded and fetching bulky context only when a session needs it
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 4
20. in-slice · occurrence 5
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 5
21. undisclosed · occurrence 6
    Undisclosed relationship
    the travelling declared-shape contract specialization
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 6
22. undisclosed · occurrence 7
    Undisclosed relationship
    the *user-forward* tool (the only minted child: substrates are a section, not nodes)
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 7
23. undisclosed · occurrence 8
    Undisclosed relationship
    a named scaffold supplies the fixed shape; the model fills only its declared degrees of freedom
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 8
24. undisclosed · occurrence 9
    Undisclosed relationship
    the altitude above the single skill (N skills, compounding costs)
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 9
25. undisclosed · occurrence 10
    Undisclosed relationship
    control flow in code, judgment in dispatches
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 10

### Inbound references 13

1. in-slice · occurrence 1
   [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment#scope-and-boundaries)
   how much task value you get for each unit of context spent
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-alignment#scope-and-boundaries) · occurrence 1
2. in-slice · occurrence 1
   [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment#relationships)
   how much task value you get for each unit of context spent
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-alignment#relationships) · occurrence 1
3. in-slice · occurrence 4
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#model-and-claims-the-price-list)
   how much task value you get for each unit of context spent
   Evidence: [Model and claims](https://agentic-atlas.dev/nodes/context-economy#model-and-claims-the-price-list) · occurrence 4
4. in-slice · occurrence 2
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#scope-and-boundaries)
   how much task value you get for each unit of context spent
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-economy#scope-and-boundaries) · occurrence 2
5. in-slice · occurrence 3
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#implications-the-consequence-map)
   how much task value you get for each unit of context spent
   Evidence: [Implications](https://agentic-atlas.dev/nodes/context-economy#implications-the-consequence-map) · occurrence 3
6. in-slice · occurrence 1
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow#scope-and-boundaries)
   how much task value you get for each unit of context spent
   Evidence: [Scope and boundaries](https://agentic-atlas.dev/nodes/context-flow#scope-and-boundaries) · occurrence 1
7. in-slice · occurrence 2
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow#relationships)
   how much task value you get for each unit of context spent
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-flow#relationships) · occurrence 2
8. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#use-when-the-mispriced-payload)
   how much task value you get for each unit of context spent
   Evidence: [Use when](https://agentic-atlas.dev/nodes/cost-relocation#use-when-the-mispriced-payload) · occurrence 1
9. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#application-the-chooser-which-not-whether)
   how much task value you get for each unit of context spent
   Evidence: [Application](https://agentic-atlas.dev/nodes/cost-relocation#application-the-chooser-which-not-whether) · occurrence 1
10. in-slice · occurrence 2
    [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#application-the-chooser-which-not-whether)
    how much task value you get for each unit of context spent
    Evidence: [Application](https://agentic-atlas.dev/nodes/cost-relocation#application-the-chooser-which-not-whether) · occurrence 2
11. in-slice · occurrence 3
    [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships)
    how much task value you get for each unit of context spent
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 3
12. in-slice · occurrence 6
    [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#relationships)
    how much task value you get for each unit of context spent
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 6
13. in-slice · occurrence 1
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#use-when)
    how much task value you get for each unit of context spent
    Evidence: [Use when](https://agentic-atlas.dev/nodes/subagent-offload#use-when) · occurrence 1

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

Node context-efficiency · corpus 78c0e17 · Catalog revision ca6ae3709a0fd6e298b5abb3766c123f5bf204e6202e067484cabf3973e39c9f