---
title: "Deferred Context · pattern · Agentic Atlas"
description: "Deferred Context: keeping a short pointer loaded and fetching bulky context only when a session needs it."
canonical: "https://agentic-atlas.dev/nodes/deferred-context"
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. Deferred Context

Parent of [Reference Data](https://agentic-atlas.dev/nodes/reference-data).

1. pattern
   # Deferred Context
   **When should an agent load information only as needed?**
   Load on demand whatever sessions need rarely, or need every time but only late in the session.
   Hook
   keeping a short pointer loaded and fetching bulky context only when a session needs it
   Laws & fences
   - In the measured 30-turn session, material first needed at turn 25 still bills 4.6 times less than frontloading it.
   - Material needed in every session and right away gains almost nothing from deferral.
   - Cut a deferred file if you cannot name the kind of session that would fetch it.
   - A pointer to a deferred file gets 50 tokens, an address plus one preview line, apart from skill descriptions.
   - Caching can shrink or reverse deferral's dollar savings, but never cuts the quality cost of unneeded loaded material.
   When to reach
   - Reach for this when a skill loads everything a task might need, though most sessions use little of it.
   - Reach for this when many installed skills, each fully loaded, would together overflow the context window.
   Provenance
   [deferred-context/use-when-the-law-probability-and-lateness-of-need](https://agentic-atlas.dev/nodes/deferred-context#use-when-the-law-probability-and-lateness-of-need) · v1.0.11
   Addresses
   atlas_cards deferred-context
2. [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
3. [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
4. [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)
5. [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)
6. [Reference Data](https://agentic-atlas.dev/nodes/reference-data)
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. [The Session Bill](https://agentic-atlas.dev/nodes/session-bill)
10. [Statelessness](https://agentic-atlas.dev/nodes/statelessness)
11. field notes
    - “transform a payload to strengthen task-relevant signal in a smaller or more useful representation”
    - “graded access composed from deferral and distillation”

One Guide, Three BillsThe Session Bill +1 more unfold the map fold the map

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

On this plate

[intent-the-problem-and-the-move](https://agentic-atlas.dev/nodes/deferred-context#intent-the-problem-and-the-move) [use-when-the-law-probability-and-lateness-of-need](https://agentic-atlas.dev/nodes/deferred-context#use-when-the-law-probability-and-lateness-of-need) [avoid-when-needed-now-or-not-worth-its-rent](https://agentic-atlas.dev/nodes/deferred-context#avoid-when-needed-now-or-not-worth-its-rent) [forces](https://agentic-atlas.dev/nodes/deferred-context#forces) [structure-the-fetch-seam](https://agentic-atlas.dev/nodes/deferred-context#structure-the-fetch-seam) [application-what-earns-a-rung-and-what-fronts-it](https://agentic-atlas.dev/nodes/deferred-context#application-what-earns-a-rung-and-what-fronts-it) [consequences-and-tradeoffs-one-cost-shape-for-another](https://agentic-atlas.dev/nodes/deferred-context#consequences-and-tradeoffs-one-cost-shape-for-another) [verification](https://agentic-atlas.dev/nodes/deferred-context#verification) [examples-the-worked-example-one-decision-billed-both-ways](https://agentic-atlas.dev/nodes/deferred-context#examples-the-worked-example-one-decision-billed-both-ways) [relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) [lineage](https://agentic-atlas.dev/nodes/deferred-context#lineage) [open-questions-todo](https://agentic-atlas.dev/nodes/deferred-context#open-questions-todo) [relationships-ledger](https://agentic-atlas.dev/nodes/deferred-context#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/deferred-context#intent-the-problem-and-the-move)

People traditionally frontload all context into the [skill](https://agentic-atlas.dev/glossary/skill): everything the task *might* need is authored into the always-resident instructions. The economy bills that choice every single session — [admission](https://agentic-atlas.dev/glossary/admission) paid whether or not this invocation needs the material, [residency](https://agentic-atlas.dev/glossary/residency) carried for the session's full duration — and the payload dilutes [relevancy](https://agentic-atlas.dev/glossary/relevancy) on every task that never touches it. Frontloading prices material by its **size**; most sessions only ever needed a fraction of it.

Measured, the fraction is not rhetorical *(all counts in this node: ADR 0013, measured 2026-08-02 on dated local specimens with a public Claude 2.x tokenizer; current tokenization may raise absolute counts by approximately 30%, while ratios are less sensitive but carry no measured error bound)*. Anthropic's own `claude-api` skill carries a 20,060-token body plus 112,524 tokens of reference material; frontloaded, the body alone would occupy 10% of a 200k [window](https://agentic-atlas.dev/glossary/window-context-window) from turn 1, the full stack 66% — before any conversation exists. And the portfolio closes the question: a single developer machine registers ~60 skills, and 20k × 60 fits in no window at any price. Deferral is not an optimization of the frontloaded design; it is what makes a skill portfolio possible at all.

The move: relocate the payload's **payment point**. Same bytes, same actor — the fence against *transform a payload to strengthen task-relevant signal in a smaller or more useful representation* and the split against [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload) are the [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)'s; this node moves cost down the when-axis and does nothing else.

## Use when — the law: probability and lateness of need

[Permalink to Use when — the law: probability and lateness of need section](https://agentic-atlas.dev/nodes/deferred-context#use-when-the-law-probability-and-lateness-of-need)

**The law: defer by probability *and* lateness of need.**

- Needed **rarely** → defer; the session that never fires is the whole win — the ~60× in the worked example.
- Needed **always but late** → still defer. On ADR 0013's 30-turn session shape, the same session firing at turn 25 bills 4.6× cheaper — the lateness term is real exactly when the need is actually late. And JIT admission truncates residency from the front: every turn before the fetch runs with the payload's dilution absent, a gain the dollar arithmetic never sees.

Probability decides *whether* the payload is paid; lateness decides *how long* it sits resident once it is.

## Avoid when — needed now, or not worth its rent

[Permalink to Avoid when — needed now, or not worth its rent section](https://agentic-atlas.dev/nodes/deferred-context#avoid-when-needed-now-or-not-worth-its-rent)

These close the when-axis alone; a contraindication that closes both axes is found at [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation).

- **Needed always and immediately → don't defer.** Measured teeth (ADR 0013, 30-turn session shape): fire at turn 5 and the body sits resident for 26 of 30 turns — the uncached saving collapses to **~10%**, and the caching pass puts the cached figure at **~7%**; the fetch bought almost nothing.
- **The artifact loses the rent test** (*Application*). Then it isn't deferred context — **it's clutter that bought a pointer. Cut it.** Scope discipline is this test's verdict in the losing case, not a neighboring concern.
- **The [seam](https://agentic-atlas.dev/glossary/seam) costs more than the residency it saves** — the parent's *pointer rivals payload*, and caching moves where that line falls (*Consequences and tradeoffs*).

## Forces

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

[Pointer](https://agentic-atlas.dev/glossary/pointer) economy and the model-votes-on-the-trigger disposition are the [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)'s forces; the data pointer at the fetch seam is this branch's instance of each.

1. **The bottom rung is an outcome, not a property.** "Never paid" is per-session, and it is never quite true — the pointer's standing rent is paid in every session, need or no need *(ruled 2026-08-03)*.
2. **The pointer's quality is what holds the two failure modes at bay** — a mute pointer under-triggers, a breathless one over-triggers.

## Structure — the fetch seam

[Permalink to Structure — the fetch seam section](https://agentic-atlas.dev/nodes/deferred-context#structure-the-fetch-seam)

Keep a cheap pointer resident; move the payload itself down the ladder:

**always-resident → loaded on invoke → fetched on demand → never paid.**

Each rung down defers the same bytes to a later, cheaper point in the payment schedule — until the final rung, where a session that never needs the material never pays for it at all. The ladder is deployed practice, not a diagram: `claude-api` is the whole ladder in production — a 339-token description always-on, the 20,060-token body loaded on invoke, 25 reference files (112,524 tokens, median 2,801) fetched individually on demand, and the fourth rung realized by every session that never fires it. Body to description: **59:1**. Full stack to description: **391:1** (ADR 0013).

The move leaves a seam: a fetch decision that didn't exist before. The seam needs no vocabulary of its own — it narrates entirely in inherited terms *(ruled 2026-08-03)*: the resident **pointer** (the parent's data pointer — follow it, get bytes) carries a **[taste](https://agentic-atlas.dev/glossary/taste)** of the payload, and the model votes on the trigger, with the false-confidence disposition the parent's Forces name standing against the fetch. This is where *graded access composed from deferral and distillation* plugs in: a distilled taste, designed to inform exactly this decision. Deferral creates the decision; disclosure equips it.

**Two seams, two pointer kinds** *(ruled 2026-08-03)*. The ladder's invoke seam (always-resident → loaded on invoke) is fronted by the skill's registered description — the parent's **function pointer** in form (a name + description in its trigger-contract role; the harness routes the call), even though delivery is load-in-place. The fetch seam (loaded → fetched on demand) is this node's own, and it runs on the **data pointer**: follow it, get bytes.

## Application — what earns a rung, and what fronts it

[Permalink to Application — what earns a rung, and what fronts it section](https://agentic-atlas.dev/nodes/deferred-context#application-what-earns-a-rung-and-what-fronts-it)

**The rent test.** An artifact belongs on the ladder only if its expected fetch value across the skill's serving distribution beats the pointer's standing rent. The craft form of the same test: *if you can't name the session archetype that fetches it, cut it.*

**The pointer budget** *(ruled 2026-08-02, ADR 0013; refined 08-03)*: the normative **data pointer is 50 tokens** — an address plus one line of taste. The measured always-on descriptions (95–339 tokens) are not overrun data pointers; they are function pointers, a functionally different artifact whose when-to-fire and when-to-skip logic is constitutive, not bloat. Budget the two kinds separately — and hold each to the rent test: a heavy [trigger contract](https://agentic-atlas.dev/glossary/trigger-contract) is a resident decision procedure, and it earns its weight only against measured trigger fidelity, which is still unsampled (ADR 0013 → *Open measurements*).

## Consequences and tradeoffs — one cost shape for another

[Permalink to Consequences and tradeoffs — one cost shape for another section](https://agentic-atlas.dev/nodes/deferred-context#consequences-and-tradeoffs-one-cost-shape-for-another)

Deferral is never free — it swaps one cost shape for another:

|  | Always paid | Paid when needed | Failure mode |
| --- | --- | --- | --- |
| **Frontloaded** | full payload, every session | — | payload dilutes relevancy on every task that doesn't need it |
| **Deferred** | the pointer | payload + fetch latency | **under-trigger**: actor works without context it needed · **over-trigger**: frontloading with extra steps |

Expected cost: `pointer + P(need) × (payload + fetch)` versus `payload` flat — the formula holds **uncached and within-session cached**, where caching multiplies both arms near-equally (ADR 0013); the cross-session warm-prefix case is the exception, priced below. The fetch itself is the latency term, and it is cache-immune: one extra inference pass (a tool call minted at output prices) plus first-time prefill of the payload — the one cost of deferral no cache ever discounts.

### Caching moves the dollars, not the law

Cache prices live at [The Context Economy](https://agentic-atlas.dev/nodes/context-economy); this node carries only what caching does to *this* move (ADR 0013, measured 2026-08-02, 30-turn shape):

- **Within a session, the ratio survives untouched** — caching multiplies both arms alike — but the absolute dollar prize shrinks ~7×. The seam's own costs (authoring the trigger contract, the extra pass, under-trigger risk) don't shrink with it, so the payload size below which deferral stops paying for itself rises ~7×: the parent's *pointer rivals payload* contraindication bites earlier under caching.
- **The throughput advantage disappears**: cache reads are exempt from rate limits, so a frontloaded body riding warm cache stops taxing throughput at all.
- **Cross-session, the dollar ordering can flip outright.** A frontloaded body inside a byte-identical prefix amortizes its cache write across sessions; a deferred payload pays a fresh write in every session that fetches it. On the measured shape, frontloading undercuts deferral once P(fire) ≳ 0.8 — real for genuinely static deployments, fragile everywhere else: one upstream byte of variation (a system prompt embedding cwd, date, git status) re-bills the whole prefix, and idle gaps run the arithmetic back toward deferral.
- **What caching never touches: quality.** A cached body is attended in full on every pass; the relevancy dilution frontloading buys is discounted 0% at every P(fire). The law keeps its teeth in the one denomination no cache reaches.

## Verification

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

The branch instance of the [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)'s checks — *the cost moved, outcomes held* — read on the when-axis.

**Deterministic:**

- **The bill moved down the schedule.** Residency arithmetic in the parent's denomination (tokens × turns): before, the payload on every turn; after, the pointer on every turn plus the payload from the fetch turn on. The worked example runs exactly that arithmetic on one declared decision (*Examples*) — it either moved or it didn't.
- **The resident surface is inside its budget.** Count what stays resident and type it: 50 tokens for the data pointer, function pointers budgeted separately (*Application*). Every resident token above the budget dilutes the win it exists to buy.

**Probabilistic residue:**

- **Trigger fidelity.** Under- and over-trigger rates for real pointers exist only over sampled runs, and are unsampled here (ADR 0013 → *Open measurements*). One degenerate case is cheaply visible in the transcript: a fetch that fires on essentially every session is the table's *frontloading with extra steps*.
- **The quality delta.** That the turns before a fetch run with the payload's dilution absent is definitional; its payoff on task results needs live A/B against scored outcomes (ADR 0013 → *Open measurements*), as does wall-clock fetch latency against cached prefill.

## Examples — the worked example: one decision, billed both ways

[Permalink to Examples — the worked example: one decision, billed both ways section](https://agentic-atlas.dev/nodes/deferred-context#examples-the-worked-example-one-decision-billed-both-ways)

A skill carries ~3,000 tokens of API error-code reference — a realistic unit: the measured median reference file in `claude-api` runs 2,801 tokens. The single decision is moving it to `references/error-codes.md` behind a 50-token pointer (the normative budget). Ten-turn sessions, residency in token-turns:

|  | Session that needs the codes (turn 7) | Session that doesn't |
| --- | --- | --- |
| **Frontloaded** | 3,000 × 10 = 30,000 token-turns; turns 1–6 carry dead weight | 30,000 token-turns, all dead weight |
| **Deferred** | 50 × 10 + 3,000 × 4 = 12,500 token-turns + one fetch | **500 token-turns — ~60× cheaper** |

The no-need column is the probability term; the needs-codes column is the lateness term. The cautionary contrast is account-blind: let the resident surface swell to the measured-in-the-wild 339 tokens — whatever those tokens are called, data pointer or trigger contract — and the no-need win shrinks from ~60× to ~9×. The arithmetic never asks what the tokens are *for*; every resident token above the budget dilutes the win it exists to buy.

## Relationships

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

- **Child of [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)**, which owns everything both branches share — the later/elsewhere split, the data/function pointer vocabulary, the same-bytes fence, the model-votes-on-the-trigger force, and the cross-branch rhyme mapping this node's authored-heavy child to offload's. Sibling branch: [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload) (*dispatch-elsewhere* to this node's *load-in-place*).
- **Parent of [Reference Data](https://agentic-atlas.dev/nodes/reference-data)** — the [specialization](https://agentic-atlas.dev/glossary/specialization) that breaks this node's fixed-payload assumption: the corpus lives on disk, addressable by search, and admission becomes **query-shaped** — pay for the size of the answer, not the material. The authored-heavy specialization.
- **Priced by [The Context Economy](https://agentic-atlas.dev/nodes/context-economy)** — residency arithmetic and every cache price above; **described in [Context Flow](https://agentic-atlas.dev/nodes/context-flow)'s lifecycle** (deferral is admission control); **motivated by [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency)** (relevancy is what frontloading dilutes; *whether* a relocation clears break-even is its call, per the parent's which/whether line).
- **Composes with *transform a payload to strengthen task-relevant signal in a smaller or more useful representation*** into *graded access composed from deferral and distillation*: deferral holds the payload, distillation makes the taste.

## Lineage

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

Lazy evaluation, and demand paging in virtual memory: defer a value's cost until first use and pay only for what is touched. The residency ladder is the eager/lazy tradeoff applied to a window.

## Open questions / TODO

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

- **Open measurements (ADR 0013 → *Open measurements*):** the outcome delta of clean early turns (needs live A/B against task results — the relevancy claim is definitional, its payoff is not yet sampled), wall-clock fetch latency vs. cached prefill, and under-/over-trigger rates for real pointers — the parent's probabilistic residue, unsampled 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 16

1. undisclosed · occurrence 1
   Undisclosed relationship
   transform a payload to strengthen task-relevant signal in a smaller or more useful representation
   Evidence: [Intent](https://agentic-atlas.dev/nodes/deferred-context#intent-the-problem-and-the-move) · occurrence 1
2. 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: [Intent](https://agentic-atlas.dev/nodes/deferred-context#intent-the-problem-and-the-move) · occurrence 2
3. in-slice · occurrence 3
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   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
4. 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: [Avoid when](https://agentic-atlas.dev/nodes/deferred-context#avoid-when-needed-now-or-not-worth-its-rent) · occurrence 1
5. 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: [Forces](https://agentic-atlas.dev/nodes/deferred-context#forces) · occurrence 1
6. undisclosed · occurrence 1
   Undisclosed relationship
   graded access composed from deferral and distillation
   Evidence: [Structure](https://agentic-atlas.dev/nodes/deferred-context#structure-the-fetch-seam) · occurrence 1
7. 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: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/deferred-context#consequences-and-tradeoffs-one-cost-shape-for-another) · occurrence 1
8. 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: [Verification](https://agentic-atlas.dev/nodes/deferred-context#verification) · occurrence 1
9. 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: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 1
10. 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: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 2
11. in-slice · occurrence 3
    [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/deferred-context#relationships) · occurrence 3
12. in-slice · occurrence 4
    [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/deferred-context#relationships) · occurrence 4
13. in-slice · occurrence 5
    [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/deferred-context#relationships) · occurrence 5
14. in-slice · occurrence 6
    [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/deferred-context#relationships) · occurrence 6
15. undisclosed · occurrence 7
    Undisclosed relationship
    transform a payload to strengthen task-relevant signal in a smaller or more useful representation
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 7
16. undisclosed · occurrence 8
    Undisclosed relationship
    graded access composed from deferral and distillation
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 8

### Inbound references 13

1. in-slice · occurrence 1
   [The Context Economy](https://agentic-atlas.dev/nodes/context-economy#relationships)
   keeping a short pointer loaded and fetching bulky context only when a session needs it
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-economy#relationships) · occurrence 1
2. in-slice · occurrence 1
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map)
   keeping a short pointer loaded and fetching bulky context only when a session needs it
   Evidence: [Implications](https://agentic-atlas.dev/nodes/context-efficiency#implications-the-consequence-map) · occurrence 1
3. in-slice · occurrence 4
   [Context Efficiency](https://agentic-atlas.dev/nodes/context-efficiency#relationships)
   keeping a short pointer loaded and fetching bulky context only when a session needs it
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-efficiency#relationships) · occurrence 4
4. in-slice · occurrence 3
   [Context Flow](https://agentic-atlas.dev/nodes/context-flow#relationships)
   keeping a short pointer loaded and fetching bulky context only when a session needs it
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/context-flow#relationships) · occurrence 3
5. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#avoid-when-both-axes-closed)
   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
6. in-slice · occurrence 3
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#structure-two-branches-one-per-axis)
   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
7. in-slice · occurrence 2
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#examples)
   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
8. in-slice · occurrence 4
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships)
   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
9. in-slice · occurrence 2
   [One Guide, Three Bills](https://agentic-atlas.dev/nodes/one-guide-three-bills#choice)
   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
10. in-slice · occurrence 1
    [Reference Data](https://agentic-atlas.dev/nodes/reference-data#relationships)
    keeping a short pointer loaded and fetching bulky context only when a session needs it
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 1
11. in-slice · occurrence 1
    [The Session Bill](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts)
    keeping a short pointer loaded and fetching bulky context only when a session needs it
    Evidence: [Implementation](https://agentic-atlas.dev/nodes/session-bill#implementation-the-six-shifts) · occurrence 1
12. in-slice · occurrence 8
    [Statelessness](https://agentic-atlas.dev/nodes/statelessness#relationships)
    keeping a short pointer loaded and fetching bulky context only when a session needs it
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/statelessness#relationships) · occurrence 8
13. in-slice · occurrence 2
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#intent)
    keeping a short pointer loaded and fetching bulky context only when a session needs it
    Evidence: [Intent](https://agentic-atlas.dev/nodes/subagent-offload#intent) · occurrence 2

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

Node deferred-context · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61