---
title: "One Guide, Three Bills · example of Cost Relocation · Agentic Atlas"
description: "One Guide, Three Bills: one guide loaded later or handed to a helper: one agent's cost versus the system's."
canonical: "https://agentic-atlas.dev/nodes/one-guide-three-bills"
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](https://agentic-atlas.dev/nodes/cost-relocation)
4. One Guide, Three Bills
1. example of [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   # One Guide, Three Bills
   **How does loading a guide later or in another agent change its cost?**
   In this example, deferral cuts the orchestrator's relocation-related bill 59.5%; offload cuts it further but costs the system more than deferral.
   Hook
   one guide loaded later or handed to a helper: one agent's cost versus the system's
   Laws & fences
   - Deferral saves the turns before the reference is needed, and later turns still pay in full.
   - Count the child's startup context and handoff messages, or moving cost will look like removing it.
   - Before choosing to defer or offload, ask which bill the design must protect.
   - The example proves where costs land under declared inputs, not how models behave in real runs.
   When to reach
   - Reach for this when a large reference sits in context for turns that never use it.
   - Reach for this when a fixed reference, like a policy manual, could be read later or by another agent.
   Provenance
   [one-guide-three-bills/result](https://agentic-atlas.dev/nodes/one-guide-three-bills#result) · v1.0.11
   Addresses
   atlas_cards one-guide-three-bills
2. [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
3. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
4. [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
5. [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)

The card, in place · its connections drawn edges from atlas_links one-guide-three-bills

On this plate

[context](https://agentic-atlas.dev/nodes/one-guide-three-bills#context) [problem-signal](https://agentic-atlas.dev/nodes/one-guide-three-bills#problem-signal) [choice](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice) [before](https://agentic-atlas.dev/nodes/one-guide-three-bills#before) [implementation](https://agentic-atlas.dev/nodes/one-guide-three-bills#implementation) [result](https://agentic-atlas.dev/nodes/one-guide-three-bills#result) [verification](https://agentic-atlas.dev/nodes/one-guide-three-bills#verification) [lessons](https://agentic-atlas.dev/nodes/one-guide-three-bills#lessons) [relationships](https://agentic-atlas.dev/nodes/one-guide-three-bills#relationships)

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

## Context

[Permalink to Context section](https://agentic-atlas.dev/nodes/one-guide-three-bills#context)

An orchestrator is upgrading a repository to a new SDK. The review takes ten turns:

1. inventory SDK imports;
2. identify the target version;
3. inspect the current adapters;
4. map affected call sites;
5. inspect the compatibility tests;
6. isolate one unresolved retry-policy question;
7. evaluate that question against the migration guide;
8. apply the required change;
9. run the compatibility checks; and
10. report the result.

The fixed reference is a **10,000-token API migration guide**. None of its content is needed before turn 7. Every arm consumes the same guide verbatim and produces the same compatibility report:

```
verdict: incompatible
evidence:
  - guide: "Retry policy §4.2"
    code: "src/client/retry.py:41"
required_changes:
  - "Replace max_attempts with stop_after_attempt."
```

The report [contract](https://agentic-atlas.dev/glossary/contract) permits `compatible`, `incompatible`, or `needs-context`, at most three guide-and-code evidence pairs, and at most three required changes. Its serialized form is capped at 300 tokens. Every arm emits that same final report at turn 10, after the last billed input pass. The offloaded arm carries a byte-identical copy back from the child before turn 8; that extra resident copy is charged at the full cap rather than granted a flattering sample-size discount.

The bill counts only context changed by the relocation decision. The orchestrator's repository context, conversation history, and outputs are identical across all three arms, so they cancel. [Residency](https://agentic-atlas.dev/glossary/residency) follows the [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)'s convention: tokens multiplied by the inference turns that re-read them. These are input-side residency bills, not output-token or dollar totals.

## Problem signal

[Permalink to Problem signal section](https://agentic-atlas.dev/nodes/one-guide-three-bills#problem-signal)

Frontloading guarantees that the guide is present when turn 7 arrives, but it also charges all ten turns for material that has no work during the first six. The visible input is 10,000 tokens; its residency bill is **100,000 token-turns**.

That total hides two different questions. Could the same [actor](https://agentic-atlas.dev/glossary/actor) load the guide later? Could a different actor consume the guide and return only the decision? Both reduce the orchestrator's bill, but they move it along different axes and leave different costs behind.

## Choice

[Permalink to Choice section](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice)

Read the three arms as two adjacent [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation) comparisons, each with its own declared baseline:

- **When-axis — frontloaded → [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context):** retain a 50-token data [pointer](https://agentic-atlas.dev/glossary/pointer) and fetch the guide immediately before turn 7. The orchestrator remains the consumer.
- **Who-axis — deferred → [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload):** hold the turn-7 payment point fixed, retain a 100-token function pointer, and synchronously [dispatch](https://agentic-atlas.dev/glossary/dispatch) the compatibility decision. A [child](https://agentic-atlas.dev/glossary/parent-child) consumes the guide in three turns and returns the bounded report before the orchestrator begins turn 8.

The second delta is not credited with the first one's six clean turns: its baseline is the turn-7 deferred arm, so only the payer changes. Distillation is also held out of the comparison. The guide is not summarized, filtered, or rewritten before use — **the relocated payload is the same 10,000 tokens in every arm**. The 300-token report is the offload [seam](https://agentic-atlas.dev/glossary/seam)'s declared output, not a transformed replacement guide; the other arms produce the same report only as their final output.

## Before

[Permalink to Before section](https://agentic-atlas.dev/nodes/one-guide-three-bills#before)

The baseline admits the guide at session start:

```
turns 1–6     guide resident; no guide-dependent work
turn 7        orchestrator evaluates compatibility
turns 8–10    orchestrator applies, verifies, and reports
```

The orchestrator and system bills are identical because no child window exists:

| Actor | Arithmetic | Token-turns |
| --- | --- | --- |
| Orchestrator | 10,000 × 10 turns | **100,000** |
| **System** | orchestrator only | **100,000** |

## Implementation

[Permalink to Implementation section](https://agentic-atlas.dev/nodes/one-guide-three-bills#implementation)

### Shift 1 — move the payment point to turn 7

The 50-token data pointer stays resident for all ten turns. The fetch admits the guide immediately before turn 7, so the guide is re-read on turns 7–10:

| Actor | Arithmetic | Token-turns |
| --- | --- | --- |
| Orchestrator pointer | 50 × 10 turns | 500 |
| Orchestrator guide | 10,000 × 4 turns | 40,000 |
| **Orchestrator** | pointer + guide | **40,500** |
| **System** | orchestrator only | **40,500** |

One decision moved: **when** the guide enters the same actor's window. The first six turns stop paying for it; the last four remain unchanged.

### Shift 2 — move the payer to a child

The orchestrator keeps a 100-token function pointer for ten turns. At turn 7 it emits a 200-token dispatch; the child receives that dispatch, the complete guide, and a declared 4,000-token boot context. The child takes three turns:

1. locate the governing migration clauses;
2. compare the affected code with those clauses; and
3. return the compatibility report.

The dispatch and 300-token [return](https://agentic-atlas.dev/glossary/return) remain in the orchestrator's history for turns 8–10. They cross the seam; the guide does not:

| Actor | Arithmetic | Token-turns |
| --- | --- | --- |
| Orchestrator function pointer | 100 × 10 turns | 1,000 |
| Orchestrator dispatch + return | (200 + 300) × 3 turns | 1,500 |
| **Orchestrator** | pointer + seam traffic | **2,500** |
| Child | (4,000 boot + 200 dispatch + 10,000 guide) × 3 turns | **42,600** |
| **System** | orchestrator + child | **45,100** |

Against the turn-7 deferred baseline, one decision moved: **who** consumes the guide. The child boot and seam traffic are consequences of crossing that actor boundary; hiding either would make relocation look like deletion.

## Result

[Permalink to Result section](https://agentic-atlas.dev/nodes/one-guide-three-bills#result)

The three arms hold the guide, task, trigger turn, and report constant:

| Arm | Orchestrator bill | Child bill | System bill | What moved |
| --- | --- | --- | --- | --- |
| Frontloaded | **100,000** | — | **100,000** | nothing |
| Deferred | **40,500** | — | **40,500** | payment point |
| Offloaded | **2,500** | **42,600** | **45,100** | payer |

Against frontloading, deferral cuts the orchestrator's relocation-related bill by **59.5%** because six guide-free turns stay guide-free. Against that turn-7 baseline, offload moves another **38,000 token-turns** out of the orchestrator — while costing the system **4,600 token-turns more**. The protected window and the cheapest system are different objectives.

The total is not a punchline. A one-turn child would change the offload bill; a turn-2 trigger would change the deferral bill; a larger return would erode the who-axis win. The example fixes those inputs so the two relocation decisions remain legible.

## Verification

[Permalink to Verification section](https://agentic-atlas.dev/nodes/one-guide-three-bills#verification)

Every table row carries its arithmetic. Recompute the two deltas before the invariants:

- **When:** frontloaded 100,000 → deferred 40,500; the actor and outcome stay fixed.
- **Who:** deferred 40,500 → offloaded 2,500 in the orchestrator and 45,100 system-wide; the turn-7 trigger and outcome stay fixed.

Then inspect the [placement](https://agentic-atlas.dev/glossary/placement):

- **The bill moved.** Deferred guide tokens appear only on orchestrator turns 7–10. Offloaded guide tokens appear only in the child's three turns.
- **The outcome held.** All arms are stipulated to return the same capped compatibility report; the comparison grants no arm a quality or output-size advantage.

The arithmetic proves placement under the declared scenario. It does not prove that a model will trigger the fetch, pack the dispatch adequately, produce the same verdict in sampled runs, or preserve quality under real window pressure. Those are the parent's trigger-fidelity and outcome-parity residues. Nor are the declared 10,000-, 4,000-, 300-, 200-, 100-, and 50-token inputs population estimates. Change any input and the table recomputes; the later/elsewhere distinction survives.

## Lessons

[Permalink to Lessons section](https://agentic-atlas.dev/nodes/one-guide-three-bills#lessons)

**Ask which bill the design must protect.** Deferral buys clean early turns for the same actor. Offload buys a clean orchestrator window by opening and paying another one. The system ledger is what prevents that second move from masquerading as free work.

The migration guide is furniture. The comparison travels to policy manuals, schema catalogs, audit standards, and any other fixed payload whose consumer and consumption time can be separated.

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 4

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: [Context](https://agentic-atlas.dev/nodes/one-guide-three-bills#context) · occurrence 1
2. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   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
3. 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: [Choice](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice) · occurrence 2
4. 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: [Choice](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice) · occurrence 3

### Inbound references 1

1. in-slice · occurrence 3
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#examples)
   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

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

Node one-guide-three-bills · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61