---
title: "Context Efficiency · concept · Agentic Atlas"
description: "Context Efficiency: objective — value per unit of context spent (cost / state / outcome lenses)."
canonical: "https://agentic-atlas.dev/nodes/context-efficiency"
last-updated: "2026-09-14"
---

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 efficiency is value delivered per unit of context spent, scored in quality, dollars, and latency at once and read through three lenses: tokens per task achieved, relevancy, and prime-window completion. It is neither blind minimization, which starves the task of what it needed, nor the absence of an objective, where every skill answers the allocation questions implicitly and nobody scores the spend.
   Hook
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   Thesis
   Context efficiency is value delivered per unit of context spent, scored in quality, dollars, and latency at once and read through three lenses: tokens per task achieved, relevancy, and prime-window completion. It is neither blind minimization, which starves the task of what it needed, nor the absence of an objective, where every skill answers the allocation questions implicitly and nobody scores the spend.
   Laws & fences
   - An efficiency claim names the denomination it improves and does not hide a lost quality or diagnostic capability. The three denominations do not convert, so no design is most efficient without a stated constraint set, and the receipts that let you reconstruct a failed run are part of what the spend buys, not a cost to cut.
   - Relevancy is the lever; the other two lenses read its effect. Keep the resident window load-bearing for the task at hand and the window stays in its prime band, where completion quality peaks and tokens per task stay low. The chain is inferred, not measured end to end, and the lenses are analytic: the relevancy reading is whether the next turn's output would change if an artifact were evicted.
   - Spend the top-priced class on judgment and let nothing else be minted there. Reasoning tokens are delivered to nobody yet are efficient when they move the outcome; formatting that restates what was already produced returns nothing at any price.
   When to reach
   - Reach for it when a system keeps making window-spending decisions, which task gets window space now, which takes the degraded end-of-window slot, which goes to a cheaper actor, how much output to spend thinking, and nothing names what a good answer looks like, or when a workflow is being cut for tokens without checking outcome quality, latency, or diagnosability.
   - Do not reach for it as a benchmark: it yields no relevancy or prime-window number two observers would reproduce. Nor does it say how to schedule, price, or move context; which work shares a window, what a token costs, and how a deferral or offload is built are decided by context alignment, the economy, flow, and the mechanisms it scores.
   Provenance
   [context-efficiency/definition](https://agentic-atlas.dev/nodes/context-efficiency#definition) · v1.0.7
   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 scheduling consequence is [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)'s.
- **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. Which work shares a window is [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)'s decision; 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).
- **Strategies move relevancy by construction.** A strategy under this node is a scheduling move with a *do* of its own; the first groups work that shares a context space and separates work that shares nothing. → [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment) (affinity estimated before, relevancy harvested after).
- **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)** — the first efficiency strategy: schedule by context affinity to maximize relevancy.
- **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)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   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)
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   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)
   **statics** — the price list: denominations, the quality curve, cost classes, time value
   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)
   **dynamics** — admission, residency, and eviction; placement and recall within residency
   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)
   resident context steers, not just informs — path dependence, and eviction's second motive
   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 ≪ doing lets verification work at all; the ladder + coverage, and the three failure modes (coverage exhaustion / discrimination collapse / quantifier inversion)
   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)
   the *load-in-place* branch: defer by probability *and lateness* of need — a 50-token pointer buys ~60× on the session that never fires
   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)
    the *dispatch-elsewhere* branch
    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)
    the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
    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)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    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)
    **statics** — the price list: denominations, the quality curve, cost classes, time value
    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)
    **dynamics** — admission, residency, and eviction; placement and recall within residency
    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)
    the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
    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)
    the *load-in-place* branch: defer by probability *and lateness* of need — a 50-token pointer buys ~60× on the session that never fires
    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)
    the *dispatch-elsewhere* branch
    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#verification)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   Evidence: [Verification](https://agentic-atlas.dev/nodes/context-alignment#verification) · occurrence 1
2. in-slice · occurrence 1
   [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment#relationships)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   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)
   **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
4. in-slice · occurrence 2
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#scope-and-boundaries)
   **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
5. in-slice · occurrence 3
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#implications-the-consequence-map)
   **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
6. in-slice · occurrence 1
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow#scope-and-boundaries)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   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)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   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)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   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)
   **objective** — value per unit of context spent (cost / state / outcome lenses)
   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)
    **objective** — value per unit of context spent (cost / state / outcome lenses)
    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)
    **objective** — value per unit of context spent (cost / state / outcome lenses)
    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)
    **objective** — value per unit of context spent (cost / state / outcome lenses)
    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)
    **objective** — value per unit of context spent (cost / state / outcome lenses)
    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 533727d · Catalog revision a9f60f26fd5ef6a1e0bbb39e8d0de32bf9c464b8c7b8ee3fc8c8c9fdb3a1021a