---
title: "Reference Data · pattern · Agentic Atlas"
description: "Reference Data: a reference corpus too big to load into the context window at any price."
canonical: "https://agentic-atlas.dev/nodes/reference-data"
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](https://agentic-atlas.dev/nodes/deferred-context)
5. Reference Data

Seen working in [The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf).

1. pattern
   # Reference Data
   **How can an agent query a large reference without loading all of it?**
   Reference data keeps a corpus searchable on disk, so each question pays for its answer, not the corpus.
   Hook
   a reference corpus too big to load into the context window at any price
   Laws & fences
   - Some corpora should never be loaded whole at any price, because long inputs degrade recall.
   - A corpus becomes findable by real queries when written, with the words queries will use and answer-sized units.
   - A missed search looks like success, because the model found something and proceeds confidently.
   - Even the best tested retrieval stack still misses relevant documents at a measured rate.
   - For word-matching search, vocabulary mismatch puts answers out of reach, while size, churn, and breadth only raise cost.
   When to reach
   - Reach for this when the material is a corpus that cannot fit the context window or degrades it.
   - Skip this when loading the whole corpus with prompt caching still pays, by your own cost arithmetic.
   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.11
   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. [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
7. [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context)
8. [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent)
9. field notes
   - “the travelling declared-shape contract specialization”
   - “transform a payload to strengthen task-relevant signal in a smaller or more useful representation”

Heavy Agent 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/nodes/reference-data#intent-the-corpus-the-ladder-can-t-price) [use-when](https://agentic-atlas.dev/nodes/reference-data#use-when) [avoid-when](https://agentic-atlas.dev/nodes/reference-data#avoid-when) [forces](https://agentic-atlas.dev/nodes/reference-data#forces) [structure-authoring-a-corpus-to-be-searched-into](https://agentic-atlas.dev/nodes/reference-data#structure-authoring-a-corpus-to-be-searched-into) [application-industrial-scale-where-the-rag-analogy-holds](https://agentic-atlas.dev/nodes/reference-data#application-industrial-scale-where-the-rag-analogy-holds) [consequences-and-tradeoffs-and-the-crossover](https://agentic-atlas.dev/nodes/reference-data#consequences-and-tradeoffs-and-the-crossover) [verification](https://agentic-atlas.dev/nodes/reference-data#verification) [examples](https://agentic-atlas.dev/nodes/reference-data#examples) [relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) [lineage](https://agentic-atlas.dev/nodes/reference-data#lineage) [grounding](https://agentic-atlas.dev/nodes/reference-data#grounding) [open-questions-todo](https://agentic-atlas.dev/nodes/reference-data#open-questions-todo) [relationships-ledger](https://agentic-atlas.dev/nodes/reference-data#relationships-ledger)

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

## Intent — the corpus the ladder can't price

[Permalink to Intent — the corpus the ladder can't price section](https://agentic-atlas.dev/nodes/reference-data#intent-the-corpus-the-ladder-can-t-price)

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

[Permalink to Use when section](https://agentic-atlas.dev/nodes/reference-data#use-when)

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

[Permalink to Avoid when section](https://agentic-atlas.dev/nodes/reference-data#avoid-when)

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

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

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

## Structure — authoring a corpus to be searched into

[Permalink to Structure — authoring a corpus to be searched into section](https://agentic-atlas.dev/nodes/reference-data#structure-authoring-a-corpus-to-be-searched-into)

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

## Application — industrial scale, where the RAG analogy holds

[Permalink to Application — industrial scale, where the RAG analogy holds section](https://agentic-atlas.dev/nodes/reference-data#application-industrial-scale-where-the-rag-analogy-holds)

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 tradeoffs — and the crossover

[Permalink to Consequences and tradeoffs — and the crossover section](https://agentic-atlas.dev/nodes/reference-data#consequences-and-tradeoffs-and-the-crossover)

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**, a failure of [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment). Adjudication needs source 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

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

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

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

- **[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

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

- **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** ([Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)); 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

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

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

[Permalink to Grounding section](https://agentic-atlas.dev/nodes/reference-data#grounding)

*(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

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

- **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)
   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
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: [Structure](https://agentic-atlas.dev/nodes/reference-data#structure-authoring-a-corpus-to-be-searched-into) · occurrence 1
3. in-slice · occurrence 1
   [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
   how well the available context fits the task at hand
   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)
   searching a runbook shelf too big for the context window instead of loading it whole
   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)
   an agent with large docs built in, so the orchestrator asks instead of loading them
   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)
   handing work to a subagent so its material never fills the orchestrator's context
   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)
   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
9. in-slice · occurrence 2
   [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/reference-data#relationships) · occurrence 2
10. 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: [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)
    handing work to a subagent so its material never fills the orchestrator's context
    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)
    an agent with large docs built in, so the orchestrator asks instead of loading them
    Evidence: [Relationships](https://agentic-atlas.dev/nodes/reference-data#relationships) · occurrence 5
13. in-slice · occurrence 6
    [Context Alignment](https://agentic-atlas.dev/nodes/context-alignment)
    how well the available context fits the task at hand
    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)
    searching a runbook shelf too big for the context window instead of loading it whole
    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)
   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
2. in-slice · occurrence 6
   [Cost Relocation](https://agentic-atlas.dev/nodes/cost-relocation#relationships)
   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
3. in-slice · occurrence 3
   [Deferred Context](https://agentic-atlas.dev/nodes/deferred-context#relationships)
   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
4. in-slice · occurrence 1
   [The Docs Expert](https://agentic-atlas.dev/nodes/docs-expert-agent#lessons-the-expert-not-the-librarian)
   a reference corpus too big to load into the context window at any price
   Evidence: [Lessons](https://agentic-atlas.dev/nodes/docs-expert-agent#lessons-the-expert-not-the-librarian) · occurrence 1
5. in-slice · occurrence 3
   [Heavy Agent](https://agentic-atlas.dev/nodes/heavy-agent#relationships)
   a reference corpus too big to load into the context window at any price
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/heavy-agent#relationships) · occurrence 3
6. in-slice · occurrence 1
   [The Runbook Shelf](https://agentic-atlas.dev/nodes/runbook-shelf#choice)
   a reference corpus too big to load into the context window at any price
   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)
   a reference corpus too big to load into the context window at any price
   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)
   a reference corpus too big to load into the context window at any price
   Evidence: [Relationships](https://agentic-atlas.dev/nodes/subagent-offload#relationships) · occurrence 3

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

Node reference-data · corpus 78c0e17 · Catalog revision e0cb75881244b1a82193ca738b82a0d508dd62e822524ae82873ec79d51dbb61