---
title: "Reference Data · Agentic Atlas"
description: "Reference Data: the authored-heavy specialization: disk-resident, grep-addressable — pay for the size of the answer."
canonical: "https://agentic-atlas.dev/nodes/reference-data"
last-updated: "2026-08-19"
---

# Reference Data · Agentic Atlas

[← the survey](https://agentic-atlas.dev/atlas)

1. pattern
   Reference Data
   Hook
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Thesis
   Hold the corpus on disk, the cheapest tier of the cost structure, and make it addressable by search, so admission becomes query-shaped: what enters the window is a high-signal slice sized to the question, priced by the size of the answer rather than the size of the material.
   Laws & fences
  - A frontloaded corpus is degraded residency, not merely expensive residency: recall over long contexts follows a U-curve, significantly degraded in the middle, and worsens as the window fills, so some payloads should never be resident whole, at any price.
  - Grep-able is an artifact property, not a hope, built at authoring time: vocabulary the queries will share, granularity sized to the answer, and a resident surface that spends only what the fetch decision requires.
  - A slice that misses the relevant row is an under-trigger with extra confidence; Anthropic's evaluation measured 5.7% missed relevant documents at top-20 for its baseline configuration, driven to 1.9% by stacking contextualization, keyword search, and reranking, so the full tested stack still missed at a measured rate.
  - The grep-able corpus stops being enough when the queries stop sharing vocabulary with the corpus; size, churn, and breadth move the price, while vocabulary mismatch moves the answer out of reach.
   When to reach
  - Reach for it when the parent's ladder has already typed the payload to deferral and the payload is a corpus rather than a unit you can name and load whole, too big to frontload: it visibly cannot fit the window, or degrades it when it does.
  - Skip it for a corpus residency can still afford; for a small, cold, high-fire-rate corpus, frontloading with caching competes, and this node carries no numeric floor, so decide by the parent's arithmetic rather than a quoted threshold.
   Provenance
   [reference-data/intent-the-corpus-the-ladder-can-t-price](https://agentic-atlas.dev/nodes/reference-data#intent-the-corpus-the-ladder-can-t-price) · v1.0.2
   Addresses
   atlas_cards reference-data
2. [
   Cost Relocation
   ](https://agentic-atlas.dev/nodes/cost-relocation)
3. [
   The Runbook Shelf
   ](https://agentic-atlas.dev/nodes/runbook-shelf)
4. [
   The Docs Expert
   ](https://agentic-atlas.dev/nodes/docs-expert-agent)
5. [
   Subagent Offload
   ](https://agentic-atlas.dev/nodes/subagent-offload)
6. [
   Deferred Context
   ](https://agentic-atlas.dev/nodes/deferred-context)
7. [
   Heavy Agent
   ](https://agentic-atlas.dev/nodes/heavy-agent)
8. field notes
  - “the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)”
  - “the travelling declared-shape contract specialization”
  - “transform a payload to strengthen task-relevant signal in a smaller or more useful representation”

+1 more unfold the map fold the map

The card, in place · its connections drawn edges from atlas_links reference-data

On this plate

[intent-the-corpus-the-ladder-can-t-price](https://agentic-atlas.dev#intent-the-corpus-the-ladder-can-t-price)[use-when](https://agentic-atlas.dev#use-when)[avoid-when](https://agentic-atlas.dev#avoid-when)[forces](https://agentic-atlas.dev#forces)[structure-authoring-a-corpus-to-be-searched-into](https://agentic-atlas.dev#structure-authoring-a-corpus-to-be-searched-into)[application-industrial-scale-where-the-rag-analogy-holds](https://agentic-atlas.dev#application-industrial-scale-where-the-rag-analogy-holds)[consequences-and-tradeoffs-and-the-crossover](https://agentic-atlas.dev#consequences-and-tradeoffs-and-the-crossover)[verification](https://agentic-atlas.dev#verification)[examples](https://agentic-atlas.dev#examples)[relationships](https://agentic-atlas.dev#relationships)[lineage](https://agentic-atlas.dev#lineage)[grounding](https://agentic-atlas.dev#grounding)[open-questions-todo](https://agentic-atlas.dev#open-questions-todo) [relationships](https://agentic-atlas.dev#relationships)

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

## Intentthe corpus the ladder can't price

[](https://agentic-atlas.dev#intent-the-corpus-the-ladder-can-t-price)

intent-the-corpus-the-ladder-can-t-price.md

The parent relocates *when* a fixed payload is paid. Treating a corpus as one fixed payload caps how much you can afford to keep: anything too big to ever load stays out of reach entirely.

The move: hold the corpus on **disk** — the cheapest tier of the cost structure — and make it **addressable by search** (grep, file structure, an index). [Admission](https://agentic-atlas.dev/glossary/admission) stops being payload-shaped and becomes **query-shaped**: what enters the [window](https://agentic-atlas.dev/glossary/window-context-window) is a high-signal slice sized to the question, not the material. Frontloading prices material by its size; the parent prices it by probability and lateness of need; reference data prices it by **the size of the answer**.

## Use when

[](https://agentic-atlas.dev#use-when)

use-when.md

The parent's ladder has already typed the payload to deferral. Two observables make it this [specialization](https://agentic-atlas.dev/glossary/specialization) rather than the branch baseline:

- **The payload is a corpus, not a unit you can name and load whole.** Authored reference material, held on disk and addressed rather than loaded.
- **It is too big to frontload.** "Too big" needs no threshold — it is the corpus that visibly cannot fit the window, or that degrades it when it does.

Reachability is the standing precondition under both: the move holds while queries share vocabulary with the corpus, and that is settled at authoring time (*Structure*), not at query time.

## Avoid when

[](https://agentic-atlas.dev#avoid-when)

avoid-when.md

The contraindications that close relocation outright are the [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)'s; what closes *this* specialization is a corpus [residency](https://agentic-atlas.dev/glossary/residency) can still afford.

**The competing posture, mentioned, not adopted.** Vendor guidance brackets RAG from below: under a quoted corpus size, frontload the whole knowledge base and let prompt caching absorb the dollars. The regime is real — for a small, cold, high-fire-rate corpus, frontloading-with-caching competes, and the parent's caching section prices exactly this — but the number is vendor-interested (the vendor bills resident tokens, and the figure predates a tokenizer change), so this node carries **no numeric floor**: decide by the parent's arithmetic, not by a quoted threshold.

## Forces

[](https://agentic-atlas.dev#forces)

forces.md

The grandparent's *[placement](https://agentic-atlas.dev/glossary/placement)* and *model votes on the trigger* are the family forces; each hardens here into the specialization's own.

1. **Degraded residency, not merely expensive residency.** The degradation is measured, and it is an argument independent of the bill: recall over long contexts follows a U-curve — highest when the relevant material sits at the edges of the input, significantly degraded in the middle (Liu et al. 2023) — and worsens as the window fills (*context rot*, Anthropic's name for it). A frontloaded corpus is not merely expensive residency; it is **degraded residency**. The family-level force carrying this is the grandparent's *placement*; here it hardens into the specialization's premise — some payloads should never be resident whole, at any price.
2. **Search quality becomes load-bearing.** A slice that misses the relevant row is an **under-trigger with extra confidence** — the branch instance of the grandparent's *model votes on the trigger* force: the [actor](https://agentic-atlas.dev/glossary/actor) searched, found something, and proceeds fully assured. Industrial retrieval puts numbers on the miss: Anthropic's evaluation measured 5.7% missed relevant documents at top-20 for its baseline configuration, driven to 1.9% by stacking contextualization, keyword search, and reranking (Grounding). Two lessons travel down to the grep-able corpus: the full tested stack still missed at a measured rate, and hybrid lexical + semantic retrieval improved it further — grep's statistical cousin (BM25) kept its seat in the winning stack, though contextual embeddings produced the largest incremental drop in this ablation *(corrected 2026-08-06, ADR 0014 → Decision)*.

## Structureauthoring a corpus to be searched into

[](https://agentic-atlas.dev#structure-authoring-a-corpus-to-be-searched-into)

structure-authoring-a-corpus-to-be-searched-into.md

The query-shaped slice stays on the *admits* side of the grandparent's same-bytes fence — search selects verbatim source and mints nothing (→ [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation), *Structure*). The corollary this node owns *(ruled 2026-07-09)*: the index or manifest kept resident **is** a minted, declared-shape artifact — a distilled product *serving* the deferral, not a breach of it. The corollary scales without modification: an embedding index is the same manifest built industrially — fixed-dimension vectors whose only job is routing queries to verbatim source — and grep is the zero-index degenerate case, where the corpus is its own index.

**The zero-index access path cannot lag its corpus.** Search reads current bytes; there is nothing between reader and disk to fall behind. Every artifact you insert on that path — a manifest, an embedding index — can. (The corpus itself can still lag the *world* — the staleness friction below, a different gap.)

Grep-able is an **artifact property, not a hope** — a pile of files is searchable; a corpus is searchable *into*. The property is built at authoring time:

- **Vocabulary the queries will share.** Distinctive names, exact identifiers, headings that state their subject in the words a task would use. The dominant crossover dimension (the crossover, below) is decided here, before any query runs.
- **Granularity sized to the answer.** The fetch unit is the file or section the search tool returns; a slice cannot arrive smaller than its unit. The parent's worked example uses the measured shape — reference files of a few thousand tokens, one question each.
- **The resident surface.** An index or manifest (the minted corollary above) where the corpus's own names don't carry enough [taste](https://agentic-atlas.dev/glossary/taste) — or nothing beyond the parent's [pointer](https://agentic-atlas.dev/glossary/pointer) where they do. Spend what the fetch decision requires, no more.

The retrieval step inherits the parent's fetch [seam](https://agentic-atlas.dev/glossary/seam) whole, and adds a precision question of its own: the query. A bad query admits a low-signal slice — which is why search quality is load-bearing (*Forces*).

## Applicationindustrial scale, where the RAG analogy holds

[](https://agentic-atlas.dev#application-industrial-scale-where-the-rag-analogy-holds)

application-industrial-scale-where-the-rag-analogy-holds.md

RAG as coined (Lewis et al. 2020) is this move at industrial scale: corpus off-window, an index resident-adjacent, a query-shaped slice admitted per question — a generator over a dense vector index of Wikipedia is the disk corpus with a built index. The same frame is first-party practice for agents: keep lightweight identifiers resident (paths, stored queries, links) and load the data at runtime (Anthropic, context-engineering post — Grounding).

**The analogy holds only for the verbatim-return portion of the pipeline.** Verbatim-chunk retrieval *admits*: the retriever selects, source bytes arrive — industrial grep, this side of the fence. The moment a pipeline rewrites, summarizes, or contextualizes chunks — contextual retrieval's preprocessing is a model writing new tokens into the corpus — it **mints**: distillation composed with deferral. Production RAG stacks are mixed; classify each portion by the fence, not the stack by its product name.

Where embedding retrieval changes the economics:

- **A pay-earlier build step appears**: embed, host, re-embed on change. Grep has no build phase. This is the clearest instance yet found of a genuine *pay-earlier* move — and it lives in infrastructure, not in the [skill](https://agentic-atlas.dev/glossary/skill) body.
- **Cost splits by shape, not just size.** Grep's entire cost is search turns billed as resident input — recurring per query, priced by the parent's arithmetic. An index adds per-corpus work — amortized — plus **standing infrastructure** whose shape depends on deployment: managed production plans may carry hosting floors, while free or self-hosted paths relocate that cost into operations. At skill scale, embedding compute can be small beside the pipeline you now operate (chunking, reindex-on-change, monitoring). Break-even is query-volume- and deployment-driven: the curves cross only after both are priced for the chosen stack.
- **The first-party case is operational, not accuracy.** Claude Code shipped with RAG and dropped it for agentic search; the stated reasons are simplicity, security/privacy, staleness, reliability (Cherny — Grounding) — the dollars were never the argument. Evidence grade, stated plainly: the outperformance claim is self-described as internal benchmarks plus vibes, and Anthropic's considered position ends *hybrid* — retrieve up front for speed, explore autonomously from there. No primary head-to-head result is carried here for the broader grep-versus-embedding comparison. Carry the product decision as testimony, not a verdict.

## Consequences and tradeoffsand the crossover

[](https://agentic-atlas.dev#consequences-and-tradeoffs-and-the-crossover)

consequences-and-tradeoffs-and-the-crossover.md

The parent's fetch arithmetic applies whole. What this node adds:

**Availability decouples from residency.** The baseline cost shifts from context to disk — so you can keep vastly more information available-but-unused than could ever be frontloaded, at near-zero resident cost. The intended consequence, banked.

**The corpus can go stale.** A disk corpus can conflict with the live system it describes — **friction**, adjudicated where *the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)* owns it, with provenance via the *the travelling declared-shape contract specialization*. Note the asymmetry from *Structure*: the access path adds no staleness of its own; an embedding index adds a second lag on top — stale from every corpus change until reindex, which is the staleness on the first-party reason list above.

**The crossover — when the grep-able corpus stops being enough.** Dimensions, not thresholds — the literature supports directions, and no vendor-neutral measured curve exists yet:

1. **Vocabulary match (dominant).** Grep holds while queries share vocabulary with the corpus — identifiers, error codes, well-headed docs. When the query is conceptual and the corpus's words don't contain the query's words, the answer is not expensive — it is **unreachable**. A reachability boundary, set at authoring time (Structure).
2. **Query breadth** *(its own dimension — ruled 2026-08-02, ADR 0014 → Decision)*. Grep is fine when you know what you're looking for; **a broad search is a flood** — exploratory queries turn each pass into a noise dump that fills the window regardless of vocabulary match. Vocabulary bounds *reachability*; breadth bounds *admissible signal per search turn*. A targeted query with the wrong vocabulary is unreachable; a broad query with the right vocabulary is a flood.
3. **Corpus size.** Raises the price, then the failure rate: each search turn returns more noise, the loop's token bill grows, and eventually the loop exhausts its budget before converging. Size never moves the answer out of reach — only what finding it costs.
4. **Update frequency.** Favors grep, asymmetrically — current bytes versus an index that lags (the staleness asymmetry above). High-churn corpora punish the index; cold corpora amortize it well.
5. **Latency shape.** One index lookup is sub-second; agentic search is a multi-turn loop. Inside an already-long agent task the loop is tolerable; for interactive lookup it is not.

The one-line boundary: **the grep-able corpus stops being enough when the queries stop sharing vocabulary with the corpus** — size, churn, and breadth move the price; vocabulary mismatch moves the answer out of reach.

## Verification

[](https://agentic-atlas.dev#verification)

verification.md

The branch instance of the inherited checks: the grandparent owns the residency arithmetic, the parent owns the fetch seam, and what this node adds is that both now run **per query** rather than per payload.

- **Deterministic — the slice arrived, not the corpus.** The transcript should carry search turns and their returns; the corpus should appear nowhere in it. Admitted tokens per query against corpus size is the reading, and the grandparent's residency arithmetic (tokens × turns) is the instrument — grep's entire bill is those search turns, billed as resident input.
- **Probabilistic — the miss and the flood.** Two residues, one per crossover dimension that bites at run time. The miss is force 2's, and no per-run test exists for it: the actor searched, found something, and proceeded — only sampled runs against known answers surface a rate, and even the best retrieval misses at one. The flood is breadth's, and it reads off the same per-query token count the deterministic check already takes: a query whose returns fill the window has admitted noise, not a slice sized to the question.

## Examples

[](https://agentic-atlas.dev#examples)

examples.md

- **[The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf)** — an 800-document corpus exceeds its declared window budget; an exact incident-code query admits one answer-sized runbook and leaves the other 799 available on disk.
- **RAG as coined** — Lewis et al.'s generator over a dense vector index of Wikipedia (*Application*): the disk corpus with a built index, this move at industrial scale.
- **The zero-index end, first-party** — Claude Code shipped with RAG and dropped it for agentic search, on operational grounds (*Application*). The corpus is its own index.
- **[The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)** — the librarian frame realized: this node composed with [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload), the searching running inside a dispatched window. A composition, so it shows the move at work rather than in isolation.

## Relationships

[](https://agentic-atlas.dev#relationships)

relationships.md

- **Child of [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)** — the specialization that breaks its fixed-payload assumption. The ladder, the law, the rent test, and the pointer budget are inherited, not restated; the cross-branch rhyme placing this node opposite [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent) is mapped at [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation).
- **The librarian frame is reserved for this node** *(ruled 2026-07-23, at the docs-expert rename)*: a routes-to-sub-docs librarian is this node composed with [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload) — the searching runs inside a dispatched window, so the [orchestrator](https://agentic-atlas.dev/glossary/orchestrator) pays neither corpus nor search turns. The baked-in contrast lives at [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent).
- **Staleness in the corpus is friction** (*the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)*); provenance via the *the travelling declared-shape contract specialization* is the adjudicator.
- **The fence with *transform a payload to strengthen task-relevant signal in a smaller or more useful representation*** lives at the grandparent; the resident-index corollary in *Structure* is this node's share of it.

## Lineage

[](https://agentic-atlas.dev#lineage)

lineage.md

Information retrieval over an inverted index (Luhn, 1957; Salton's SMART system, Cornell, 1960s): the collection stays on secondary storage, a resident index routes a query into it, and what returns is a slice sized to the question, bounded by the vocabulary problem (Furnas et al., CACM 1987). Retriever, reader, and query author are now one actor, so a missed slice is consumed as the answer instead of rejected by the human reading the list.

## Grounding

[](https://agentic-atlas.dev#grounding)

grounding.md

*(Fetched 2026-08-02; sources and evidence grades adjudicated in ADR 0014 → *Method and evidence grades*.)*

- Anthropic, *Introducing Contextual Retrieval* — https://www.anthropic.com/news/contextual-retrieval (retrieval failure rates 5.7%→1.9%; the chunk-rewriting mint caution; the vendor frontload-with-caching posture).
- Anthropic, *Effective context engineering for AI agents* — https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents (lightweight identifiers loaded at runtime; context rot; the hybrid ending).
- Boris Cherny — https://x.com/bcherny/status/2017824286489383315, with the evidence-grade caveat at https://www.latent.space/p/claude-code (first-party: Claude Code dropped RAG for agentic search; operational reasons; "mostly vibes").
- Liu et al., *Lost in the Middle* — https://arxiv.org/abs/2307.03172 (the U-curve; frontloading fails at scale independent of cost).
- Lewis et al., *Retrieval-Augmented Generation* — https://arxiv.org/abs/2005.11401 (the coinage; corpus off-window, resident index, query-shaped slice).
- Pricing anchors — https://platform.claude.com/docs/en/docs/about-claude/pricing, https://docs.voyageai.com/docs/pricing, https://www.pinecone.io/pricing/ (dated examples for the per-query vs. per-corpus cost split; managed-plan floors are plan-specific; cache reads at 0.1× base input).

## Open questions / TODO

[](https://agentic-atlas.dev#open-questions-todo)

open-questions-todo.md

- **Evidence gap — the stable gate:** document a corpus qualitatively too big to frontload in a single-decision worked example. **Resolved 2026-08-07:** [The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf) holds the corpus and question fixed, changing only corpus-shaped admission to query-shaped admission.
- **Evidence boundary:** the 2026 agentic-retrieval literature (Is-Grep-All-You-Need, CORE-Bench) is represented only by directional claims because it has been read at abstract level; no specific figures from it are asserted 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. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   change when or whose window pays; may compose with selection or distillation
   Evidence: [Avoid when](https://agentic-atlas.dev/nodes/reference-data#avoid-when) · occurrence 1
2. in-slice · occurrence 1
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
   change when or whose window pays; may compose with selection or distillation
   Evidence: [Structure](https://agentic-atlas.dev/nodes/reference-data#structure-authoring-a-corpus-to-be-searched-into) · occurrence 1
3. undisclosed · occurrence 1
   Undisclosed relationship
   the first efficiency strategy: co-schedule work that shares a context space, separate work that doesn't (moves relevancy by construction)
   Evidence: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/reference-data#consequences-and-tradeoffs-and-the-crossover) · occurrence 1
4. undisclosed · occurrence 2
   Undisclosed relationship
   the travelling declared-shape contract specialization
   Evidence: [Consequences and tradeoffs](https://agentic-atlas.dev/nodes/reference-data#consequences-and-tradeoffs-and-the-crossover) · occurrence 2
5. in-slice · occurrence 1
   [The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf)
   an 800-document shelf cannot enter a 200k-token window; one incident-code query admits one answer-sized runbook
   Evidence: [Examples](https://agentic-atlas.dev/nodes/reference-data#examples) · occurrence 1
6. in-slice · occurrence 2
   [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
   a large reference baked into the agent; narrow questions in, distilled answers out — the orchestrator never loads the docs
   Evidence: [Examples](https://agentic-atlas.dev/nodes/reference-data#examples) · occurrence 2
7. in-slice · occurrence 3
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
   the *dispatch-elsewhere* branch
   Evidence: [Examples](https://agentic-atlas.dev/nodes/reference-data#examples) · occurrence 3
8. 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: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 1
9. in-slice · occurrence 2
   [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
   the *authored-heavy* specialization
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 2
10. in-slice · occurrence 3
    [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation)
    change when or whose window pays; may compose with selection or distillation
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 3
11. in-slice · occurrence 4
    [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload)
    the *dispatch-elsewhere* branch
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 4
12. in-slice · occurrence 5
    [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent)
    a large reference baked into the agent; narrow questions in, distilled answers out — the orchestrator never loads the docs
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 5
13. undisclosed · occurrence 6
    Undisclosed relationship
    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/reference-data#relationships) · occurrence 6
14. undisclosed · occurrence 7
    Undisclosed relationship
    the travelling declared-shape contract specialization
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 7
15. 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/reference-data#relationships) · occurrence 8
16. in-slice · occurrence 1
    [The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf)
    an 800-document shelf cannot enter a 200k-token window; one incident-code query admits one answer-sized runbook
    Evidence: [Open questions / TODO](https://agentic-atlas.dev/nodes/reference-data#open-questions-todo) · occurrence 1

### Inbound references 8

1. in-slice · occurrence 2
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#forces)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Forces](https://agentic-atlas.dev/nodes/cost-relocation#forces) · occurrence 2
2. in-slice · occurrence 6
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/cost-relocation#relationships) · occurrence 6
3. in-slice · occurrence 3
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#relationships)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/deferred-context#relationships) · occurrence 3
4. in-slice · occurrence 1
   [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent#lessons-the-expert-not-the-librarian)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Lessons](https://agentic-atlas.dev/nodes/docs-expert-agent#lessons-the-expert-not-the-librarian) · occurrence 1
5. in-slice · occurrence 2
   [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#relationships)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 2
6. in-slice · occurrence 1
   [The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf#choice)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Choice](https://agentic-atlas.dev/nodes/runbook-shelf#choice) · occurrence 1
7. in-slice · occurrence 1
   [The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf#verification)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Verification](https://agentic-atlas.dev/nodes/runbook-shelf#verification) · occurrence 1
8. in-slice · occurrence 3
   [Subagent Offload](https://agentic-atlas.dev/nodes/subagent-offload#relationships)
   the *authored-heavy* specialization: disk-resident, grep-addressable — pay for the size of the answer
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 3

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

Node reference-data · corpus 31de4cb · Catalog revision 35263c4c415da742953d0462804fb14424e2244dae4c63efd27e468988de70ab