Reference Data

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 stops being payload-shaped and becomes query-shaped: what enters the 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.

The parent's ladder has already typed the payload to deferral. Two observables make it this 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.

The contraindications that close relocation outright are the Cost Relocation's; what closes this specialization is a corpus 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.

The grandparent's 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 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).

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, 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 — or nothing beyond the parent's pointer where they do. Spend what the fetch decision requires, no more.

The retrieval step inherits the parent's fetch 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).

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

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.

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.

• The 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 — the librarian frame realized: this node composed with Subagent Offload, the searching running inside a dispatched window. A composition, so it shows the move at work rather than in isolation.

• Child of 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 is mapped at 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 — the searching runs inside a dispatched window, so the orchestrator pays neither corpus nor search turns. The baked-in contrast lives at The Docs Expert.
• 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.

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.

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

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