---
title: "Cost Relocation · pattern · Agentic Atlas"
description: "Cost Relocation: context that costs by its size on every turn but is only needed sometimes."
canonical: "https://agentic-atlas.dev/nodes/cost-relocation"
last-updated: "2026-09-23"
---

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

Parent of [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context), [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload).

Seen working in [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills).

1. pattern
   # Cost Relocation
   **How can you change when or where context costs are paid?**
   Leave a cheap pointer in the window: the same agent follows it when needed, or another agent does the work and returns a conclusion.
   Hook
   context that costs by its size on every turn but is only needed sometimes
   Laws & fences
   - Relocation passes the original text unchanged, and producing a reshaped artifact makes it distillation instead.
   - Once context-efficiency judges relocating worthwhile, pick deferral if the same agent needs the material, offload if another can return a conclusion.
   - Material loaded up front is always present, but relocated material can fail to arrive when needed.
   - Each relocation adds a trigger or handoff contract that someone must write and maintain.
   - Trigger instructions should require the lookup, because a confident model may otherwise answer without it.
   When to reach
   - A nameable payload paid for in full on every call but only partly used signals a relocation candidate.
   - Skip this when the same agent needs the material inline on nearly every call.
   Provenance
   [cost-relocation/structure-two-branches-one-per-axis](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · v1.0.11
   Addresses
   atlas_cards cost-relocation
2. [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
3. [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
4. [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
5. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
6. [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
7. [Context Flow](https://agentic-atlas.dev/nodes/context-flow)
8. [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills)
9. [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
10. [The Session Bill](https://agentic-atlas.dev/nodes/session-bill)
11. [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
12. field notes
    - “transform a payload to strengthen task-relevant signal in a smaller or more useful representation”
    - “one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung”
    - “graded access composed from deferral and distillation”

One Guide, Three BillsHeavy Agent +3 more unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links cost-relocation

On this plate

[intent-the-problem-and-the-move](https://agentic-atlas.dev/nodes/cost-relocation#intent-the-problem-and-the-move) [use-when-the-mispriced-payload](https://agentic-atlas.dev/nodes/cost-relocation#use-when-the-mispriced-payload) [avoid-when-both-axes-closed](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed) [forces](https://agentic-atlas.dev/nodes/cost-relocation#forces) [structure-two-branches-one-per-axis](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) [application-the-chooser-which-not-whether](https://agentic-atlas.dev/nodes/cost-relocation#application-the-chooser-which-not-whether) [consequences-and-tradeoffs-the-forces-ledger-settled](https://agentic-atlas.dev/nodes/cost-relocation#consequences-and-tradeoffs-the-forces-ledger-settled) [verification](https://agentic-atlas.dev/nodes/cost-relocation#verification) [examples](https://agentic-atlas.dev/nodes/cost-relocation#examples) [relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) [lineage](https://agentic-atlas.dev/nodes/cost-relocation#lineage) [open-questions-todo](https://agentic-atlas.dev/nodes/cost-relocation#open-questions-todo) [relationships-ledger](https://agentic-atlas.dev/nodes/cost-relocation#relationships-ledger)

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

## Intent — the problem and the move

[Permalink to Intent — the problem and the move section](https://agentic-atlas.dev/nodes/cost-relocation#intent-the-problem-and-the-move)

An [actor](https://agentic-atlas.dev/glossary/actor) is carrying context whose work doesn't belong in its [window](https://agentic-atlas.dev/glossary/window-context-window) right now. Frontloading prices material by its **size**; most sessions need only a fraction of it, and the rest is paid anyway — [admission](https://agentic-atlas.dev/glossary/admission), [residency](https://agentic-atlas.dev/glossary/residency), diluted [relevancy](https://agentic-atlas.dev/glossary/relevancy) — every single invocation.

The move: relocate the payload's **cost**, not the payload's content. Same bytes; what changes is the payload's position in the payment schedule the [The Context Economy](https://agentic-atlas.dev/nodes/context-economy) publishes.

## Use when — the mispriced payload

[Permalink to Use when — the mispriced payload section](https://agentic-atlas.dev/nodes/cost-relocation#use-when-the-mispriced-payload)

The family-level symptom is a **payment-schedule mismatch**: the payload's payment schedule doesn't match its consumption schedule. Frontloading pays by size; consumption happens by use. The pattern is a candidate when all three hold:

1. **The payload is identifiable as a unit** — you can name it and draw a line around it.
2. **A cheap pointer can stand in for it** — a few tokens carry enough signal to trigger recovery at the right moment.
3. **At least one axis is open** — *when* (the same actor could take the material later, or never) or *who* (a different actor could absorb the work and hand back a conclusion).

Whether the relocation clears break-even is [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)'s call, not this section's — see *Application* for the which/whether line.

## Avoid when — both axes closed

[Permalink to Avoid when — both axes closed section](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed)

These close **both** axes; a contraindication that closes only one is found in that branch — [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context) or [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload).

1. **No axis open.** The same actor needs the material inline on essentially every invocation, now. Nothing to defer, nothing to hand off — relocation just adds a fetch.
2. **Pointer rivals payload.** The payload is small enough that pointer plus [seam](https://agentic-atlas.dev/glossary/seam) costs more than residency would have. Stated here as shape; the [The Context Economy](https://agentic-atlas.dev/nodes/context-economy) prices it.
3. **The problem is the content, not the schedule.** What you actually want is a smaller or sharper artifact. That is *transform a payload to strengthen task-relevant signal in a smaller or more useful representation*'s move, not relocation's — the same-bytes fence (see *Structure*) is itself a contraindication test.

## Forces

[Permalink to Forces section](https://agentic-atlas.dev/nodes/cost-relocation#forces)

1. **Size-priced admission vs. use-priced value.** The economy charges residency by bytes × turns; value accrues only on use. The gap between those two curves is the entire prize — and it varies per payload, which is why there is a choice at all.
2. **Residency vs. reliability.** Frontloaded material is *always there* — frontloading never misses. Relocated material can fail to arrive: the fetch can go untaken, the [dispatch](https://agentic-atlas.dev/glossary/dispatch) can drop what mattered. Every relocation trades guaranteed availability for a cheaper window.
3. **Pointer economy.** The pointer must stay cheap enough to pay on every invocation, yet carry enough signal to fire at the right moment. Too lean and it under-triggers; too rich and it starts re-importing the cost it exists to relocate.
4. **The seam is never free.** Relocation mints a decision boundary that didn't exist before, and the seam needs owned discipline — the *[trigger contract](https://agentic-atlas.dev/glossary/trigger-contract)* on one branch, the dispatch/return [contract](https://agentic-atlas.dev/glossary/contract) on the other. This is the standing pressure *against* relocating, and it is what *Avoid when*'s pointer-rivals-payload case prices.
5. **Relocation moves [placement](https://agentic-atlas.dev/glossary/placement), not just cost.** Attention varies by position (*placement*, in [Context Flow](https://agentic-atlas.dev/nodes/context-flow)'s gloss: primacy/recency, "lost in the middle"). Late admission lands with recency advantage — just-in-time material is maximally salient at its moment of use, where frontloaded material decays toward the middle. But the same position-weighting cuts back: a late-arriving payload can dominate the response frame, and the response inherits recency bias toward whatever was admitted last. Relocating a payload changes its effective value at constant bytes — sometimes for you, sometimes against.
6. **The model votes on the trigger.** The recovery moment is adjudicated by an LLM holding parametric beliefs about what the payload contains. False confidence — "I already know this" — reasons the actor out of the fetch on one branch and out of the dispatch on the other, even when the pointer's signal is adequate. Under-trigger is therefore not only a pointer-design failure (force 3's territory); it is a standing model disposition the seam's discipline has to counter — trigger contracts that *mandate* the lookup rather than invite it. *([Reference Data](https://agentic-atlas.dev/nodes/reference-data)'s "under-trigger with extra confidence" is this force's branch instance.)*

## Structure — two branches, one per axis

[Permalink to Structure — two branches, one per axis section](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis)

**Same bytes** — nothing about the content changes (shrinking it to its signal is *transform a payload to strengthen task-relevant signal in a smaller or more useful representation*'s move). What changes is the payload's position in the payment schedule the [The Context Economy](https://agentic-atlas.dev/nodes/context-economy) publishes — its two axes are priced there as *The time value of context* (when) and *Whose window pays* (who):

- **Later — [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)** (the *load-in-place* branch): same actor, cost moved down the when-axis; paid on demand or never. The branch baseline and the simplest context pattern.
- **Elsewhere — [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)** (the *dispatch-elsewhere* branch): cost moved along the who-axis; a different actor's window pays, the [orchestrator](https://agentic-atlas.dev/glossary/orchestrator) never does. Applies the llm-dispatch [primitive](https://agentic-atlas.dev/glossary/primitive) for the context motive.

The split is presented as these two axes, **not claimed exhaustive** (see open questions: *pay earlier*).

Both branches keep a cheap **pointer** resident while the payload lives off-window: a **data pointer** (deferred context — follow it, get bytes) or a **function pointer** (subagent offload — call it, get a [return](https://agentic-atlas.dev/glossary/return); the agent's name + description, whose contract role is the *trigger contract*). The pointer always costs its few tokens; its job is to carry enough signal to trigger paying for the rest at the right moment.

**The same-bytes fence** *(glossed 2026-07-09 — admits vs. mints)*: both branches relocate cost without transforming content — the line that separates this whole subtree from its sibling mechanism, *transform a payload to strengthen task-relevant signal in a smaller or more useful representation*. "Same bytes" means **verbatim source content**: selection (filter, grep, slice) changes how much / when / where content arrives, never *what* it is. The fence: relocation is **consumer-side entry control** — the reader *admits* verbatim source on demand (a grep does no post-processing and mints no artifact); distillation is **producer-side exit control** — a designed step *mints an artifact with a declared shape*. The operation (filter/select) decides nothing; **artifact-minting decides** which pattern you're in.

## Application — the chooser: which, not whether

[Permalink to Application — the chooser: which, not whether section](https://agentic-atlas.dev/nodes/cost-relocation#application-the-chooser-which-not-whether)

The parent owns **which** move fits; [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency) owns **whether** any move is worth making (break-even, seam cost paid back — priced by the economy). The *which* is structural — it types the task by **who consumes the payload**:

- The **same actor** needs the material inline to do its own reasoning → **defer**: the only relocation available is down the when-axis.
- A **different actor** can absorb the work and hand back a conclusion → **offload**: the who-axis is open.

The chooser follows from the task's shape; [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency) supplies the broader objective and evaluates whether the resulting relocation is worthwhile.

## Consequences and tradeoffs — the forces ledger, settled

[Permalink to Consequences and tradeoffs — the forces ledger, settled section](https://agentic-atlas.dev/nodes/cost-relocation#consequences-and-tradeoffs-the-forces-ledger-settled)

What you hold once the move is made — each holding the settled form of a force:

1. **The window bill drops.** The intended consequence: admission and residency now track use, not size; relevancy sharpens because the window carries pointers instead of payloads. *(Force 1, banked.)*
2. **You now own a seam.** The new obligation: a decision boundary with a contract to author and maintain — trigger contract on one branch, dispatch/return contract on the other — and de-dup discipline so the seam's prose doesn't fork. *(Force 4, converted from pressure to standing duty.)*
3. **A reliability residue replaces a certainty.** Frontloading's "always there" is gone; in its place, a measurable under-/over-trigger rate and force 6's false-confidence disposition to police. *Verification*'s two probabilistic residues are exactly this consequence made measurable. *(Forces 2 and 6.)*
4. **Placement moved with the cost.** The payload now arrives at recency-weighted position, with both edges of that sword live in every response. *(Force 5, ex post.)*

## Verification

[Permalink to Verification section](https://agentic-atlas.dev/nodes/cost-relocation#verification)

The pattern's intended result is *the cost moved, outcomes held*. Verification carries exactly that — classification (is this relocation at all, or distillation?) is settled at design time by the same-bytes fence in *Structure*, not checked at run time.

**Deterministic:**

- **The bill moved.** Residency arithmetic per the economy's counting convention — tokens × turns whose inference shipped the bytes ([The Session Bill](https://agentic-atlas.dev/nodes/session-bill) is the worked instrument). Before: payload × every turn. After, per branch: deferral bills the payload only post-trigger; offload bills it to the [child](https://agentic-atlas.dev/glossary/parent-child)'s window and never the orchestrator's. Transcript arithmetic — it either moved or it didn't.

**Probabilistic residue (named, not hand-waved):**

- **Trigger fidelity.** Under-/over-trigger rates exist only over sampled runs. Force 6 predicts the failure signature: where the payload was needed, did the actor consult the pointer or answer from parametric confidence? No per-run deterministic test exists — the residue is exactly the model's vote.
- **Outcome parity.** The relocated run should reach the conclusion the frontloaded run would have. Sampled comparison, never proof. One degenerate case is cheaply visible: an over-trigger rate near 100% means the bill moved in schedule but not in size — *frontloading with extra steps* (deferred context's own table names it; the parity check is where it surfaces).

If you find yourself wanting to verify the *content* of what came back, you are standing at a distillation seam — see the *transform a payload to strengthen task-relevant signal in a smaller or more useful representation*.

## Examples

[Permalink to Examples section](https://agentic-atlas.dev/nodes/cost-relocation#examples)

- **The elsewhere-instance:** [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent) — a real, stable, in-subtree instance of the who-axis move: the payload (the docs corpus) bills to the expert's window; the orchestrator pays only the trigger contract.
- **The later-instance:** [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)'s worked billing table — the when-axis move with actual denominations, one hop down.
- **[One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills):** the same 10,000-token migration guide frontloaded, deferred, and offloaded. The controlled trace bills both the orchestrator and the whole system, exposing the difference between moving the payment point and moving the payer.
- ***one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung*** (drafting) — rung (c) of the review ladder is this node's move inside a composition: a derivation three reviewers each re-paid in-window is relocated into one deterministic pre-step, paid once.

## Relationships

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

- **Priced by [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)** — the two axes are its *Whose window pays* and *The time value of context* sections; this node restates no prices.
- **Described in [Context Flow](https://agentic-atlas.dev/nodes/context-flow)'s lifecycle** — relocation is admission control; *placement* (force 5) is its gloss.
- **Motivated and adjudicated by [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)** — *whether* to relocate lives there (the which/whether line in *Application*).
- **Children:** [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context) (pay later) and [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload) (pay elsewhere) — the two branches of *Structure*.
- **The cross-branch rhyme:** each branch has an *authored-heavy* specialization — [Reference Data](https://agentic-atlas.dev/nodes/reference-data) is to deferred context what [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent) is to subagent offload.
- **Sibling of *transform a payload to strengthen task-relevant signal in a smaller or more useful representation*** under mechanisms: relocation moves cost, distillation transforms content.
- **Composes with distillation** into *graded access composed from deferral and distillation*: deferral holds the payload, distillation makes the [taste](https://agentic-atlas.dev/glossary/taste).

## Lineage

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

Indirection — the fundamental theorem of software engineering, attributed to David Wheeler, with Henney's corollary about too many levels: a cheap reference stands in for an expensive thing, resolved later or elsewhere. Both branches are that move made over a window, and "the seam is never free" is the corollary. The delta: a machine always follows the pointer; here the model votes on whether to dereference, so it can go untaken.

## Open questions / TODO

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

- **Unminted third branch:** the when-axis has a third value, pay at authoring/build time through amortization, but no skill-authorable instance currently separates it from prompt caching or a composed transform. It therefore remains a logged boundary rather than a pattern child.

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 30

1. 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: [Intent](https://agentic-atlas.dev/nodes/cost-relocation#intent-the-problem-and-the-move) · occurrence 1
2. in-slice · occurrence 1
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
   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
3. 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: [Avoid when](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed) · occurrence 1
4. in-slice · occurrence 2
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   handing work to a subagent so its material never fills the orchestrator's context
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed) · occurrence 2
5. in-slice · occurrence 3
   [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: [Avoid when](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed) · occurrence 3
6. undisclosed · occurrence 4
   Undisclosed relationship
   transform a payload to strengthen task-relevant signal in a smaller or more useful representation
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed) · occurrence 4
7. in-slice · occurrence 1
   [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: [Forces](https://agentic-atlas.dev/nodes/cost-relocation#forces) · occurrence 1
8. in-slice · occurrence 2
   [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
   a reference corpus too big to load into the context window at any price
   Evidence: [Forces](https://agentic-atlas.dev/nodes/cost-relocation#forces) · occurrence 2
9. undisclosed · occurrence 1
   Undisclosed relationship
   transform a payload to strengthen task-relevant signal in a smaller or more useful representation
   Evidence: [Structure](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · occurrence 1
10. 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: [Structure](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · occurrence 2
11. in-slice · occurrence 3
    [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: [Structure](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · occurrence 3
12. in-slice · occurrence 4
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
    handing work to a subagent so its material never fills the orchestrator's context
    Evidence: [Structure](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · occurrence 4
13. undisclosed · occurrence 5
    Undisclosed relationship
    transform a payload to strengthen task-relevant signal in a smaller or more useful representation
    Evidence: [Structure](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis) · occurrence 5
14. in-slice · occurrence 1
    [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
    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
15. in-slice · occurrence 2
    [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
    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
16. in-slice · occurrence 1
    [The Session Bill](https://agentic-atlas.dev/nodes/session-bill)
    one agent session's token bill, recomputed six times with one decision changed each time
    Evidence: [Verification](https://agentic-atlas.dev/nodes/cost-relocation#verification) · occurrence 1
17. undisclosed · occurrence 2
    Undisclosed relationship
    transform a payload to strengthen task-relevant signal in a smaller or more useful representation
    Evidence: [Verification](https://agentic-atlas.dev/nodes/cost-relocation#verification) · occurrence 2
18. in-slice · occurrence 1
    [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
    an agent with large docs built in, so the orchestrator asks instead of loading them
    Evidence: [Examples](https://agentic-atlas.dev/nodes/cost-relocation#examples) · occurrence 1
19. in-slice · occurrence 2
    [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: [Examples](https://agentic-atlas.dev/nodes/cost-relocation#examples) · occurrence 2
20. in-slice · occurrence 3
    [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills)
    one guide loaded later or handed to a helper: one agent's cost versus the system's
    Evidence: [Examples](https://agentic-atlas.dev/nodes/cost-relocation#examples) · occurrence 3
21. undisclosed · occurrence 4
    Undisclosed relationship
    one fixture PR reviewed five ways — a respectable one-shot climbs to a composed three-reviewer architecture, one priced pattern decision per rung
    Evidence: [Examples](https://agentic-atlas.dev/nodes/cost-relocation#examples) · occurrence 4
22. 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/cost-relocation#relationships) · occurrence 1
23. 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/cost-relocation#relationships) · occurrence 2
24. in-slice · occurrence 3
    [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
    how much task value you get for each unit of context spent
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 3
25. 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/cost-relocation#relationships) · occurrence 4
26. 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/cost-relocation#relationships) · occurrence 5
27. in-slice · occurrence 6
    [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
    a reference corpus too big to load into the context window at any price
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 6
28. in-slice · occurrence 7
    [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
    subagents that carry heavy baked-in instructions the orchestrator never loads
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 7
29. undisclosed · occurrence 8
    Undisclosed relationship
    transform a payload to strengthen task-relevant signal in a smaller or more useful representation
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 8
30. undisclosed · occurrence 9
    Undisclosed relationship
    graded access composed from deferral and distillation
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 9

### Inbound references 14

1. in-slice · occurrence 3
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#intent-the-problem-and-the-move)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Intent](https://agentic-atlas.dev/nodes/deferred-context#intent-the-problem-and-the-move) · occurrence 3
2. in-slice · occurrence 1
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#avoid-when-needed-now-or-not-worth-its-rent)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/deferred-context#avoid-when-needed-now-or-not-worth-its-rent) · occurrence 1
3. in-slice · occurrence 1
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#forces)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Forces](https://agentic-atlas.dev/nodes/deferred-context#forces) · occurrence 1
4. in-slice · occurrence 1
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#verification)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Verification](https://agentic-atlas.dev/nodes/deferred-context#verification) · occurrence 1
5. in-slice · occurrence 1
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#relationships)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 1
6. in-slice · occurrence 4
   [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#relationships)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 4
7. in-slice · occurrence 1
   [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Choice](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice) · occurrence 1
8. in-slice · occurrence 1
   [Reference Data](https://agentic-atlas.dev/nodes/reference-data#avoid-when)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/reference-data#avoid-when) · occurrence 1
9. in-slice · occurrence 1
   [Reference Data](https://agentic-atlas.dev/nodes/reference-data#structure-authoring-a-corpus-to-be-searched-into)
   context that costs by its size on every turn but is only needed sometimes
   Evidence: [Structure](https://agentic-atlas.dev/nodes/reference-data#structure-authoring-a-corpus-to-be-searched-into) · occurrence 1
10. in-slice · occurrence 3
    [Reference Data](https://agentic-atlas.dev/nodes/reference-data#relationships)
    context that costs by its size on every turn but is only needed sometimes
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 3
11. in-slice · occurrence 1
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#intent)
    context that costs by its size on every turn but is only needed sometimes
    Evidence: [Intent](https://agentic-atlas.dev/nodes/subagent-offload#intent) · occurrence 1
12. in-slice · occurrence 1
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when)
    context that costs by its size on every turn but is only needed sometimes
    Evidence: [Avoid when](https://agentic-atlas.dev/nodes/subagent-offload#avoid-when) · occurrence 1
13. in-slice · occurrence 1
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#forces)
    context that costs by its size on every turn but is only needed sometimes
    Evidence: [Forces](https://agentic-atlas.dev/nodes/subagent-offload#forces) · occurrence 1
14. in-slice · occurrence 2
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#relationships)
    context that costs by its size on every turn but is only needed sometimes
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 2

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

Node cost-relocation · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61