Cost Relocation

An actor is carrying context whose work doesn't belong in its window right now. Frontloading prices material by its size; most sessions need only a fraction of it, and the rest is paid anyway — admission, residency, diluted 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 publishes.

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 objective — value per unit of context spent (cost / state / outcome lenses)'s call, not this section's — see Application for the which/whether line.

These close both axes; a contraindication that closes only one is found in that branch — Deferred Context or 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 costs more than residency would have. Stated here as shape; the The 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.

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 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 on one branch, the dispatch/return 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, not just cost. Attention varies by position (placement, in 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's "under-trigger with extra confidence" is this force's branch instance.)

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 publishes — its two axes are priced there as The time value of context (when) and Whose window pays (who):

• Later — 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 (the dispatch-elsewhere branch): cost moved along the who-axis; a different actor's window pays, the orchestrator never does. Applies the llm-dispatch 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; 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.

The parent owns which move fits; objective — value per unit of context spent (cost / state / outcome lenses) 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; objective — value per unit of context spent (cost / state / outcome lenses) supplies the broader objective and evaluates whether the resulting relocation is worthwhile.

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.)

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 is the worked instrument). Before: payload × every turn. After, per branch: deferral bills the payload only post-trigger; offload bills it to the 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.

• The elsewhere-instance: The Docs Expert — 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's worked billing table — the when-axis move with actual denominations, one hop down.
• 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.

• Priced by The 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's lifecycle — relocation is admission control; placement (force 5) is its gloss.
• Motivated and adjudicated by objective — value per unit of context spent (cost / state / outcome lenses) — whether to relocate lives there (the which/whether line in Application).
• Children: Deferred Context (pay later) and Subagent Offload (pay elsewhere) — the two branches of Structure.
• The cross-branch rhyme: each branch has an authored-heavy specialization — Reference Data is to deferred context what 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.

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.

• 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.