Here is a failure mode that looks like progress on a dashboard and feels like stagnation in production.

You ship a smarter retrieval stack. You add a convergence layer, a bloom, a multi-hop expander, a “related entities” pack, an agent research dossier. The JSON gets thicker. The traces look more sophisticated. The token meter climbs. And the answers — subjectively, annoyingly — do not get better. Sometimes they get slightly worse: slower to arrive, more hedged in tone, more diffuse in structure. You did the responsible engineering thing. You fed the model more of the system’s structure. Why didn’t it pay?

Because a large share of that enrichment was not information. It was replay.

Richness is a terrible proxy

Teams judge retrieval features the way product teams judge feature lists: more fields, more hops, more “structural signal,” more completeness. The package that looks impressive in a design review is the package that names every neighbour, reprints every hotspot, and attaches a paragraph of explanation to every rank. That package is easy to demo. It is also easy to confuse with quality.

Quality, for a model-facing payload, is not thickness. It is whether the tokens that entered the window changed what the model could know or decide. A field that restates a fact already present three lines above did not buy knowledge. It bought a second printing of the same line, plus whatever attention tax the model pays to notice that the two lines agree.

That tax is not theoretical. Context is an attention budget with diminishing returns, not an infinite warehouse you fill because the warehouse got larger.¹ Frontier systems degrade as input grows, even inside advertised windows.² Material buried in the middle of a long package is systematically under-used.³ Paying to restate salience is not only wasteful; it can dilute the attention available for the rare item that was actually news.

Richer is not a synonym for better. The missing question is what the payload buys.

The sophistication theatre

Enrichment layers earn their place in architecture decks because they sound like the opposite of naive RAG. Naive RAG returns chunks. Grown-up systems return graphs, convergence maps, bloomed abstracts, multi-hop expansions. The grown-up story is often true as far as it goes: structure is information, and a flat ranked list is a poor interface to a connected corpus.

The theatre begins when “we return structure” is treated as synonymous with “we should re-serialise every structural implication at full resolution.” A neighbourhood that already lists outbound edges to a hub does not always need a second, higher-resolution reprint of that hub simply because a counter noticed the hub was popular. Sometimes the counter’s job is a short highlight. Sometimes its job is to shut up about what the edge list already said and spend its budget on the relationship the edge list could not show.

This book is about that distinction. It is not a general attack on graph retrieval, bloom stacks, or multi-query fusion. Those mechanisms can be load-bearing. The claim is narrower and more operational: context spent restating signals the model can already see in its payload buys nothing, so enrichment should be capped to a small attention convenience and its real budget reserved for information the model cannot obtain from what it has already been shown.

What this book is not

Scope walls early, before the numbers make every adjacent idea feel relevant.

This is not a RAG vendor bake-off. It does not rank embedding models or claim a universal retrieval architecture for every enterprise.

This is not an argument about whether your corpus should contain redundancy. When the same idea appears several times in a knowledge graph, that repetition is often load-bearing structure — multiple entrances, progressive development, cross-domain restatement — and aggressive deduplication is the wrong first instinct. That axis belongs to a sibling treatment of wiki redundancy as error correction. Payload replay is a different failure mode: you can have a beautifully non-redundant wiki and still ship responses that re-print the same edge three ways.

This is not primarily a book about route-invariant grounding — whether varied walks still land in equivalent load-bearing evidence. That property matters, and a sibling piece owns it. You can have route resilience and still waste payload. You can tighten payload and then re-measure route behaviour. The axes touch in A/B design; they do not substitute for each other.

Where we go next

Chapter 2 names the system that produced the figures this book will not invent around: AskUI, a shipped AWS Marketplace application, and a dated replay of its stored traffic. Chapter 3 gives the original enrichment design a fair hearing — resolution follows structure — so the later self-refutation is honest. Chapter 4 isolates the missing axis the context-engineering canon did not supply: novelty inside the same response.

Only then do we run the audit and read the scorecard. The doctrine is simple enough to fit in a sentence. The reason it needs a book is that every team thinks they already practise it, until they measure the already-visible fraction and discover they have been paying a sophistication tax.

What “not getting better” actually looks like

Flat answers are easy to dismiss as vibes. Make the vibes operational. In practice, teams report some mix of: synthesis that restates the same three claims with more hedges; longer time-to-first-useful-paragraph; more citations that do not change the decision; agents that open more pages without changing the final claim set; and human reviewers who cannot tell which package version was which in a blind skim. None of those requires a published academic metric. All of them are symptoms that enrichment is not buying decision-relevant novelty.

The dangerous variant is the lucky answer: the model still produces something that sounds right because its priors were already strong, while the package spent tokens re-narrating structure the graph already showed. Output-only evaluation celebrates that package. Payload accounting does not. This book is payload accounting with a doctrine attached.

Hold the enemy in one phrase: richness-as-proxy. Every later chapter is a tool for retiring that proxy — provenance so numbers mean something, an audit so waste is countable, a carve-out so thrift has a target other than “delete structure,” and caveats so honesty survives the retelling.

AI writing has a habit of floating percentages in mid-air. “Studies show.” “In our benchmarks.” “Enterprise deployments typically…” The grammar is confident. The warrant is often a rumour with a decimal point.

This book refuses that grammar on purpose. Every quantitative claim about enrichment waste and payload reduction in these chapters comes from a named system, a dated replay, and a harness that re-ran stored traffic against design alternatives. If you reject the generalisation to your stack, you should still be able to see exactly what was measured and how. If you accept the doctrine, you should accept it as a method you can re-run, not as a tablet of universal constants.

AskUI — which one

AskUI, in this book, is my own AWS Marketplace application. It is a shipped product I built and operate. Its retrieval and walk stack is the system whose stored traffic produced the figures later chapters will quote: the already-visible rate, the entry collapse, the byte collapse, the precision and cost-per-take movement, the fall in absolute historical takes.

Naming the system is a credibility upgrade for a piece like this specifically. The article lives or dies on whether the reader believes figures such as a 99.7% already-visible rate and a convergence-entry cut from thousands to hundreds. “Production telemetry from a shipped product I built and operate” is a stronger provenance claim than an abstract benchmark with no serial number. It is also a narrower claim, and the narrowness is a feature.

What the figures are — and are not

The figures come from a dated replay of stored traffic on 26 July 2026. Walk histories had been harvested in the ordinary course of operating and tuning the system: different search strategies, different bloom parameters, different amounts of detail returned in results. Those histories are not marketing clips. They are the raw material of how agents actually moved through the graph under prior policies.

Replay means: take that stored behaviour and the packages it saw, and re-evaluate design alternatives offline — including harsher thresholds, Top-K caps, and residual-preserving rules. It does not mean a multi-vendor industry bake-off. It does not mean a public leaderboard. It does not mean the percentages transfer unmodified into someone else’s schema.

Two cautions travel with that sentence for the rest of the book.

First, do not launder the numbers. If you quote the already-visible rate or the byte reduction out of context, attach the system name and the replay date, or you have turned a harness result into folklore.

Second, do not treat the operating point as physics. Top-five as an attention convenience is a current empirical setting in this stack, not a universal constant. The enduring claim is the carve-out principle, introduced properly in Chapter 8. Chapter 6 will place the full scorecard once; later chapters will point back rather than re-derive.

Privacy grain

Development and session identifiers are private. This book will not name specific session IDs. The right public grain is exactly: a dated replay of stored traffic (26 July 2026). That is enough for provenance and not enough for voyeurism.

The same discipline applies to internal metric definitions that are not needed for the doctrine. Where this book says “precision” or “cost per eventual take,” it means the measured quantities under the definitions in force in that replay harness. It does not invent a portable formula that pretends every team’s “take” means the same event. When you run the audit on your own stack (Chapter 11), you will define those outcomes locally and keep the definitions next to the numbers.

Why a chapter on naming

It would have been shorter to bury “AskUI” in a footnote and proceed. That would have been a mistake for two reasons.

The first is epistemic. Self-refutation is only impressive when the thing being refuted was real. The bloom stack under test was not a slide. It was production behaviour. The failure of rich bloom and of exponential thrift is interesting because it happened to a shipped design under its own traffic, not because a blog post needed a villain.

The second is methodological. The portable product of this book is not AskUI’s percentage. It is the overlap audit and the novelty-preserving carve-out. Readers who distrust single-system results should still be able to steal the method. Readers who trust the results should know exactly how far the trust is licensed to travel: to the shape of the failure mode, not to a cargo-cult copy of someone else’s Top-K.

What this chapter is not

This chapter is not the scorecard. You will not find the full joint reading of entries, bytes, precision, cost-per-take, and absolute takes here — that is Chapter 6, after the audit method in Chapter 5. This chapter is only the warrant: which system, which date, which kind of evidence, which refusals.

Without that warrant, the rest of the book collapses into the floating-percentage genre it is trying to replace. With it, the later self-refutation has a serial number.

Why single-system honesty beats multi-system fog

There is a temptation, especially in LinkedIn-adjacent writing, to average five anecdotes into a universal law. That move flatters the author and fails the reader. A single named system with a dated harness is narrower and stronger: narrower because it does not pretend to be your stack; stronger because every figure can be challenged at the level of method rather than at the level of vibe.

If you operate a different retrieval surface — pure vector RAG, a relational knowledge base, a tool-using research agent without a wiki — you are not asked to believe that your already-visible rate is 99.7%. You are asked to believe that the rate is the right object to measure, and that AskUI’s experience is a warning shot about what dense structure plus naive enrichment can do to a payload.

The rest of the book keeps returning to this chapter’s rules the way a compiler returns to types: when a number appears, it has a home system; when a recommendation appears, it separates principle from operating point; when a vendor name collides, it is disambiguated in the open.

If you only meet enrichment layers in post-mortems, they all look like mistakes. That is hindsight cosplay. The design under test in AskUI was not a random pile of extra JSON. It was a deliberate application of a doctrine that still holds in other places: do not polish everything; raise resolution where structure warrants spend.

This chapter is the fair opponent. Later chapters will show that most convergence nominations were already visible on outbound edge lines, and that the right response was a carve-out rather than unrestricted bloom. None of that lands unless you understand why “more convergence earns more context” felt like engineering rather than cargo cult.

The stack, named once

In the Intent Compiler treatment of retrieval, a rich search does not stop at ten ranked pages and a wish of luck. It returns a layered evidence object. The bloom stack, stated in order, looks like this:

Direct semantic results
        ↓
Halo: one-hop neighbour gists around each result
        ↓
Recall: advisory candidates the primary route may have missed
        ↓
Convergence: nodes repeatedly pointed to across the result set
        ↓
Bloom: richer abstracts, claims, edges and paths for those hotspots

That ordering is load-bearing. Direct hits are the seed. Halo gives local context without forcing the model to walk every edge by hand. Recall is advisory — needles that rhyme with the question but did not win the first sort. Convergence is the hinge: once the returned pages exist as a small subgraph, deterministic code counts how often other pages are reached through actual edges and ranks repeatedly indicated pages as hotspots. Bloom raises resolution on those hotspots: richer abstracts, claims, relationship sets, paths made explicit rather than implied.

The precise distinction matters. Original semantic ranking and embedding recall are fuzzy or model-mediated. The convergence mapping over the returned result graph is deterministic once that seed set exists. The system is not claiming “this converged page must be the answer.” It is saying: given these returned pages, this other node is repeatedly implicated by their actual relationships. That is stronger than another similarity score. It exposes structural corroboration.

Resolution follows structure

The slogan underneath the stack is clean: resolution follows structure. If several independent paths in the returned neighbourhood keep pointing at the same page, that page has earned more payload than a lonely leaf that appeared once on the fringe. Full-resolution everything is how you afford nothing; ten flat summaries are how you force the model to rediscover the graph in its head.

This is Progressive Resolution applied to retrieval: stabilise structure first, then spend detail where structure pays.

It also sits inside a wider division of labour that the Intent Compiler insists on: AI judgment at the ends, deterministic compilation in the middle. Models frame probes and synthesise the final package; software owns union, provenance, route counts, thresholds, and the attention budget. Graph–RAG agreement earns inspection, never belief — load-bearing claims still descend to source.

Halo and recall without authority creep

Two supporting layers make bloom honest when they stay in their lane. Halo returns one-hop neighbour gists so the synthesizer sees local context without paying the one-hop walk tax on every hotspot. Recall surfaces advisory candidates the primary ranking may have missed. Both propose. They do not outrank explicit graph structure, and they do not become citable evidence without source descent.

That ordering is deliberate. If recall is allowed to shout as loudly as converged structure, you recreate flat ranking with extra steps. If halo is omitted, the model re-pays neighbourhood tax constantly. The shipped package keeps advisory layers visible and typed so a second pass can use them without confusing them for proof.

Notice what this discipline already got right: it refused to let every signal be an oracle. Nudge doctrine makes the same demotion move elsewhere — pass a pointer, not a vote.

What it did not yet do was ask whether the convergence bloom itself was mostly re-announcing destinations already present on the halo and outbound edge lines. Subordination of recall is not the same as an overlap audit of bloom. The stack can be epistemically careful about authority and still economically careless about novelty-within-payload.

The silent assumption

The assumption worth naming is more specific than “structure matters.” It is: structural salience in the graph is news to the model when it arrives as bloomed text. That “this node is pointed at five times” is something the package must restate at full resolution, or the model will miss it.

That assumption is plausible. Models are not perfect set reasoners over long JSON. A highlight can help. The error is treating “a highlight can help” as licence for unrestricted high-resolution reprint of everything the counter can see. The honest form of the assumption is an attention convenience. The dishonest form is a second photocopy of the neighbourhood map.

Forward, not yet the scorecard

This chapter stays in doctrine-clean territory: mechanism and assumption, not the AskUI embarrassment rate. Chapter 4 isolates the missing axis the wider context-engineering canon did not supply. Chapter 5 turns that axis into an audit. Chapter 6 applies the audit to the convergence layer under replay and shows what unrestricted “more convergence earns more context” actually bought.

Hold one sentence for the road: the design was reasonable, the spend rule was testable, and the test — when it finally ran — did not care how good the slogan sounded.

Why fair opponents matter for doctrine

Vendor content loves a villain: “naive RAG,” “context stuffing,” “the old way.” That rhetoric is cheap because it never has to admit the villain was sometimes you. This book’s credibility comes from the opposite posture. The bloom stack was ours. The slogan was ours. The worry about bloat was already present at design time and still not enough without measurement. Self-refutation with numbers is rare precisely because most teams never instrument the layer they are proud of.

Keep the stack. Change the spend rule. That sentence is only available if Chapter 3 told the truth about why the stack existed. Progressive Resolution still applies to retrieval. Deterministic fusion still belongs in the middle of the pipeline. Halo and recall still should not outrank structure. What changes after the audit is the belief that hotspot mass is automatically news when serialised at full resolution into a package that already named the hotspot on an edge line.

The context-engineering canon is not empty. It already has a vocabulary for scarcity, focus, and thrift. Attention budget. Signal density. Context budgeting. Progressive disclosure. Teams that speak this language are usually ahead of teams that still think the only problem is “more tokens in the window.”

They can still ship a replay tax with a clean conscience. The canon reasons carefully about how much context and how relevant it is. It does not, by itself, supply the operative test this book uses: is this item obtainable by the model from elsewhere in the same payload?

What the canon already gets right

Attention budget. Model attention is finite. Context composition — not nominal window size — is the constraint. You admit the smallest high-signal set that maximises the task outcome, and you trim when cognition deteriorates, not only when the meter hits a hard cap.

Anthropic’s engineering guidance states the same economic fact in industry language: context must be treated as a finite resource with diminishing marginal returns; models draw on an attention budget when parsing large volumes of context.¹

Signal density. The proportion of an agent’s active context that directly serves the current task is a first-class quality metric. Tools, history, instructions, and retrieved material can stop earning their place long before the window is full.

Context budgeting. Deliberate allocation across a small resident working set, a compact discoverability layer, and off-window reference material. Headroom is preserved on purpose. Material moves as the task changes rather than accumulating like sediment.

Progressive disclosure. Keep the default surface compact while preserving an explicit route from summary or index to deeper tools, evidence, and full source. Depth remains available without being resident.

None of that is wrong. This book stands on it. The failure mode measured in AskUI is what happens when you obey those rules and still re-print, at enrichment time, a structural fact the base package already made visible.

Why relevance is not enough

Imagine an enrichment layer that only ever adds relevant material. Every bloomed abstract is about a page that truly sits in the result neighbourhood. Every multi-hop entity is related to the query. Every rerank paragraph cites a real ranking feature. A relevance auditor passes the package with honours.

An obtainability auditor can still fail it hard. If the outbound edge lines already named the hub, the bloomed high-resolution card of that hub is relevant and already-visible. If three tool results each summarise the same URL the agent already opened, the summaries are relevant and already-visible. Relevance asks: does this serve the task? Obtainability asks: did we need to pay again for the model to have it?

The model-side pressure against waste

Even if tokens were free, attention is not. Context-rot research found that eighteen frontier models became increasingly unreliable as input length grew, even on simple tasks and within declared windows.² Lost-in-the-middle work shows a U-curve: performance is highest when relevant material sits at the start or end of long context, and degrades when the model must use material buried in the middle.³

Those findings do not supply AskUI’s percentages. They supply the economic weather in which payload waste is expensive. A package that re-prints salience mid-window is not merely burning money; it is arranging the one novel residual into the worst seat in the house.

Five axes, one owned here

It helps to put the neighbouring questions on one table so this book cannot accidentally steal them.

Route-invariant grounding asks whether reasonable variation in question wording, routing parameters, and traversal order still leads the agent to an equivalent load-bearing evidence region — many paths, same genba.

Wiki redundancy as error correction asks when repeated ideas in the corpus are multiple entrances and progressive development rather than accidental duplication.

Neither question is the overlap question. You can pass both and still fail a within-payload novelty audit. You can fail a novelty audit and still have a healthy corpus and resilient routes. The axes compose; they do not collapse.

The obtainability test

State the test in a form a checklist can hold:

For each item an enrichment layer emits, could the model already see an equivalent identifier, title, or relationship in the non-enrichment fields of the same response?

If yes, the item is already-visible. If no, it is novel within the payload. The fraction of yeses is the embarrassment rate. The composition of the noes is the residual you may need to protect by policy.

That is the missing axis, instrumented. Chapter 5 turns it into a full audit method. Chapter 6 applies it to AskUI’s convergence layer and refuses to treat the resulting percentages as industry law. Chapter 8 turns the residual logic into the novelty-preserving carve-out — with Top-K kept empirical and the principle kept doctrinal.

One more distinction before the measurement half begins. A short attention convenience — a Top-K highlight of repeated signals — can still be justified under nudge logic: a whisper that biases glance, not a second vote that reloads the whole document. The carve-out will use that distinction. What it will not do is pretend that unrestricted high-resolution reprint is the same thing as a whisper.

How teams miss the axis in practice

A platform team ships “smarter context” as a checkbox feature. The PR description lists new fields. The demo shows a denser side panel. The evaluation measures recall against a gold document set and finds no regression. Everyone merges. Nobody asks whether the new fields were already recoverable from the old fields in the same JSON. The evaluation was about corpus coverage and relevance, not about within-payload novelty. The axis was never in the test plan.

Another team practices context hygiene weekly: they delete stale tools, compress history, and keep signal density high. Their packages are relevant and tidy — and still full of polite reprints. Hygiene removed the irrelevant. It never asked the obtainability question about the relevant remainder. That is why this book refuses the branding fight with hygiene and instead claims a stricter filter.

Put the missing axis on your design review template as a single line: What fraction of this enrichment is already visible in the same response? If nobody can answer, you are not ready to call the layer an improvement.

Doctrine without an instrument is a slogan. The instrument for within-payload novelty is almost insultingly simple. That is the point. You do not need another model call to ask whether a field is news. You need to compare the enrichment layer to the rest of its own package.

This chapter defines the overlap audit as a reusable method. Chapter 6 applies it to AskUI’s convergence nominations. Chapter 11 expands the method into a full operating procedure you can run next week. Here the job is precision: what is base, what is enrichment, what counts as already-visible, and what three numbers you report when you are done.

Split the package

Take one retrieval response as actually shipped to the model. Split it into two bags:

1. Base payload — the fields the model would have even without the enrichment layer under suspicion. Typical contents: direct hit titles and IDs, short abstracts, outbound edge lines, halo gists, tool cards already returned earlier in the same turn.
2. Enrichment output — everything the layer under test added on top. Convergence nominations and bloomed hotspot cards, multi-hop expansions, “related entities” packs, rerank explanation paragraphs, concatenated research-dossier sections — whatever you are accusing of possible replay.

If you cannot draw the field-path line between base and enrichment, you are not ready to audit. You are ready to clean the schema. An audit that depends on vibes about “the extra bits” will produce a motivated fraction, not a measurement.

The binary label

For each enrichment atom, ask:

Was an equivalent identifier, title, or relationship already visible somewhere in the base payload of the same response?

If yes, mark already-visible. If no, mark novel. Optionally keep a third bucket, ambiguous, for items you cannot score without judgment — and keep that bucket small. If ambiguous dominates, your identifiers are too free-form for automatic audit; tighten them before you argue about enrichment policy.

Strict scoring first

Decide in advance what counts as equivalent. The strict, automatable core is:

• Stable ID match (page id, document id, URL, entity key)
• Normalised title match
• Edge-destination match (the neighbour named on an outbound line is the same node the bloom card expands)

Fuzzy paraphrase matching — “this bloomed claim restates a halo gist in different words” — is real waste, but it is easier to game and harder to automate without another model call. Start strict. If the strict audit already shows double-digit waste, you do not need the fuzzy layer to justify a redesign. If the strict audit shows almost no waste and you still suspect replay, then invest in paraphrase scoring as a second pass.

Model-facing only

Audit the package that entered the context window, not the internal debug view. Engineers often look at a dashboard that already deduplicates what the model still receives twice. The only payload that counts is the one the attention mechanism had to parse.

A worked pass (shape, not a fake benchmark)

Imagine a single search package as the model receives it. The base payload already contains five direct hits with short abstracts; for each hit, a handful of outbound edge lines in the form page → relation → neighbour; and a halo of one-hop neighbour gists. That is already a lot of structure. The convergence layer then nominates additional hotspot pages for bloomed resolution — richer abstracts, claim lists, path explanations.

Walk the nominations one by one.

Nomination A is a project page. Scan the outbound lines: three different direct hits already list edges into that same project. Mark already-visible.

Nomination B is a concept page that appears in two halo gists by title. Mark already-visible.

Nomination C never appears as a destination on any outbound line in this package, and does not appear among the direct hits, but appears as an inbound source: something outside the returned neighbourhood points at a page that is in the set. Mark novel.

Nomination D is a high-mass hub that every search in this corpus seems to rediscover — and sure enough, it is already named four times on edge lines. Mark already-visible.

Do that for the whole nomination list. Sum the already-visible marks. Divide by the total. That ratio is the overlap rate for this package. Average it across a sample of packages and you have the audit result.

In the AskUI replay the average was not “somewhat high.” It was 99.7%. Chapter 6 places that figure in the full scorecard. Here the point is methodological: the fraction is computable without a research programme, and it is more informative than another latency chart when the question is whether enrichment is product or tax.

What the audit is not

Not a relevance score. An already-visible item can be highly relevant. The audit does not care. It cares whether you paid twice.

Not corpus deduplication. Whether the wiki should contain multiple entrances to the same idea is a corpus-shape question owned elsewhere. The overlap audit is strictly about redundancy inside one response.

Not path testing. Whether the walk was epistemically sound is a different instrument. You can have a good path and a wasteful package, or a tight package and a bad path.

Three numbers to report

Those three do not replace downstream quality metrics. They explain what the enrichment layer is actually selling. Chapter 6 will insist on reading them next to precision, cost per eventual take, and absolute takes. Chapter 10 will refuse to let a byte collapse pose as a quality score on its own.

One implementation honesty note: you may still keep a short Top-K convenience list in production even when those Top-K items are already-visible. The audit measures waste; it does not forbid a deliberate glance. What it forbids is pretending the glance needs full-resolution reprint of the entire mass. Chapter 8 turns that into doctrine.

This chapter is the definitive placement of the fixed numbers. Later chapters will point here. They will not re-derive the figures, and they will not invent new ones.

Provenance reminder from Chapter 2: every quantity below comes from a 26 July 2026 replay of stored traffic in AskUI — my AWS Marketplace application, unrelated to the third-party UI-automation vendor of the same name. The figures are this system’s own instrumented telemetry from its own traffic. They are not a general industry benchmark.

What was under test

The enrichment layer under test was the convergence nomination set — the nodes the bloom stack proposed for higher resolution because the returned neighbourhood kept pointing at them. The overlap audit from Chapter 5 was applied against the base payload of the same responses, with special attention to whether nominations were already present in the visible outbound edge lines.

The scorecard

Read the 99.7% figure without flinching into disbelief or marketing. Almost the entire “smart” layer was re-announcing destinations the model could already see listed on outbound edges in the same package. The convergence map was not mostly discovering structure. It was mostly printing a highlight reel of structure the halo and edge lines had already exposed.

Two further results closed off the obvious escape hatches. They get fuller treatment in Chapter 7; they belong on the scorecard now.

First, a harsher exponential threshold — only bloom when mass is really high — sounded like principled thrift. In the actual mass distribution, the higher rungs were rarely reached at all. You cannot save a bad spend policy by raising a threshold that almost never fires.

Second, convergence mass was only a weak predictor of whether a page was actually opened. The thing used as a warrant for more payload was not even a strong warrant for the next walk step. Salience-as-mass and usefulness-as-opened were only loosely coupled.

How to read the four outcome lines together

When people skim a result like this, they latch onto the megabyte line. 4.75 MB to 0.33 MB is a dramatic ratio. Dramatic ratios are dangerous. Here is the joint reading this book insists on:

• Entries 6,472 → 987 — the enrichment surface shrank; less nomination mass was offered for full resolution.
• Bytes 4.75 MB → 0.33 MB — the engineering constraint eased; transfer, cache, and attention pressure fell.
• Precision and cost per eventual take improved — the quality and efficiency scores that make the byte cut meaningful moved in the right direction under the replay definitions in force.
• Absolute historical takes fell — a real cost on the ledger; not every prior take event still occurred when the package shrank. Full caveat in Chapter 10.

If you only quote the middle two bullets, you are selling. If you only quote the fall in absolute takes, you are sandbagging. The honest posture is all four, plus the live gap: this is a replay result, not a live-traffic result, and replay cannot fully predict how future walkers adapt to a smaller payload. Chapter 10 states that caveat as load-bearing product rather than legal fine print.

Re-price, do not delete

None of this meant “delete the convergence layer.” Structure awareness remains valuable. Deterministic fusion of a returned subgraph remains valuable. What failed was the unrestricted spend rule: more convergence earns more full-resolution context, without an obtainability filter.

The economic reading is blunt. CapEx spent on reprinting the halo is CapEx not spent on the residual, on deeper source descent, or on headroom that keeps the model from diffusing. The 99.7% already-visible rate is the receipt for that misallocation.

Chapter 8 records the inversion that survived: a small attention convenience for repeated signals, and a protected residual for information the model cannot obtain elsewhere. In this stack the convenience is currently top five — an empirical setting, not a universal constant. Chapter 9 names why the residual, in this densely bidirectional graph, was dominated by uncommon inbound-only relationships.

What you may quote

If you take one paragraph from this book into a design review, take this one:

In a 26 July 2026 AskUI replay of stored traffic, 99.7% of convergence nominations were already visible in outbound edge lines. Carving to a small Top-K convenience plus a novelty residual cut entries from 6,472 to 987 and bytes from 4.75 MB to 0.33 MB, with improved measured precision and cost per take — while absolute historical takes fell, and live adaptation remains untested.

That paragraph is long on purpose. Every clause is doing work the megabyte ratio alone refuses to do.

What 99.7% does to the design conversation

Before a number like that exists, debates about bloom are aesthetic: some people like richer packages; some people like leaner ones; both sides can produce anecdotes. After the number exists, the debate changes shape. You can still argue about how large Budget A should be. You can still argue about residual composition. You cannot seriously argue that unrestricted convergence bloom was mostly buying discovery in this traffic. The discovery story lost to arithmetic.

That is also why the joint scorecard matters. Arithmetic without quality is how thrift becomes vandalism. Arithmetic without absolute takes is how thrift becomes marketing. Arithmetic without a live label is how offline hope becomes a press release. Chapter 6’s job is to put the arithmetic and its companions in one place so later chapters can build without renegotiating the facts.

If you only remember four tokens from the scorecard, remember these: already-visible, joint, replay, re-price. Already-visible is the embarrassment. Joint is the reading rule. Replay is the scope. Re-price is the design response that is not deletion.

Reading the scorecard in a design review

Bring the four outcome lines on one slide and refuse to discuss thrift until all four are visible. The conversation you want is: given already-visible waste this high, what is Budget A for, what must Budget B protect, and what live signal will tell us the offline result was not a mirage? The conversation you do not want is a free-floating argument about whether smaller context “feels better.” Feelings are allowed after the joint scorecard; they are not a substitute for it.

If a stakeholder only wants the megabyte ratio for a leadership update, give them the long paragraph from earlier in this chapter instead. Leadership can handle a compound sentence. What it cannot handle — and what will hurt you later — is a simplified story that trains the organisation to optimise bytes without quality.

The path to the novelty-preserving carve-out was not a single clever insight delivered on a whiteboard. It was a short sequence of designs that each failed in a way that clarified the next instrument. That kind of failure only compounds if you keep the walk history and the harness long enough to interrogate them.

This chapter is the productive post-mortem of the thrift variants. It is not the co-design loop book — the human-and-AI iteration pattern that made the cycle fast enough to stay inside one line of thought is a different brief. What matters here is the economic lesson the failures left behind.

Variant one: rich bloom

The original idea was conceptually tidy: more convergence should earn more context. Resolution follows structure; hotspots deserve depth. At design time there was already a worry that bloom would bloat results and put too much into context without helping. That worry was not enough to stop the ship. Reasonable designs ship with known risks when the alternative is under-serving structure.

Walk history and A/B comparison made the risk concrete. The rich bloom was not mainly buying discovery. Once the overlap lens existed, it was mainly buying reprint. The first failure established the measurement need: you cannot argue forever with “it feels richer” once you can count already-visible nominations. Chapter 6’s 99.7% is the receipt from that instrument, not a mood.

Variant two: thrift by curve

The next idea was the adult-sounding correction: keep bloom, but demand exponentially more mass for higher resolution rungs. Only the truly hot hotspots would earn full abstracts and edge expansions. Everyone who has ever tuned a threshold has written a version of this sentence. It feels like discipline.

In the actual mass distribution, the higher rungs were rarely reached at all. The curve looked principled on paper and idle in production. Proposed exponential thresholds would rarely have reached the higher rungs — not because the team lacked resolve, but because the instrument was wrong for the shape of the data.

You cannot save a bad spend policy by raising a threshold that almost never fires.

That failure established something more useful than “try a different constant.” It established that the problem was not insufficient strictness. It was the wrong spend target. If almost everything you would have bloomed is already visible on outbound lines, thrift-by-mass is thrift applied to the wrong axis. You needed a novelty filter, not a taller ladder.

Weak coupling, same lesson

Alongside the threshold failure sat a second awkward result from the scorecard: convergence mass was only a weak predictor of whether a page was actually opened. The warrant for payload was only loosely coupled to the next walk step that payload was supposed to enable.

That does not make convergence meaningless. Structural corroboration can still be a useful attention prior. It does mean you should be suspicious of any policy that converts mass into full-resolution bytes as if mass were a quality score. Mass was not even a strong behavioural score for opens. Treating it as a blank cheque for bloom was a category error.

Ameliorations and the harness as verdict

Between rich bloom and the eventual carve-out sat the familiar middle: re-tweaks, partial fixes, ideas the model liked that still failed under replay, ideas the human still believed after the first rejection. The texture of that loop matters only lightly for this book’s doctrine, but it matters for honesty: the surviving design was bred from counterexamples, not from a single brainstorm that arrived fully formed.

One operating rule from that loop travels cleanly: the model’s enthusiasm is a challenge, not a verdict. Replay decides. Failed variants are not waste if they improve the evaluator and clarify the distinction the next design must hold — here, the distinction between information the model can already obtain and information it cannot.

What finally held

What finally held was not a more elaborate threshold. It was a category split:

• a small attention convenience for repeated signals the model could in principle reconstruct from the base package;
• a protected residual for signals it could not.

Chapter 8 names that split as the novelty-preserving carve-out and insists that Top-K is empirical. Chapter 9 names why, in this graph, the residual that survived the overlap filter was dominated by uncommon inbound-only relationships. Chapter 10 refuses to let the resulting byte collapse pose as victory without the rest of the ledger.

Keep the moral of the thrift path short enough to use in a design review: when the embarrassment rate is dominated by already-visible mass, stop inventing stricter ways to spend on that mass. Invent a rule that stops spending on it.

Instrument design is part of the product

Software teams are used to thinking of product features as the thing users see and instrumentation as the thing ops sees. In agentic retrieval, the instrumentation is often the only way to discover that a user-visible feature is a tax. The rich bloom looked like a user-visible upgrade. The overlap audit made it legible as a tax. The exponential curve looked like an ops-visible thrift control. The mass distribution made it legible as cosplay.

Keep failed variants in the design history with one-line obituaries: what they tried, what they measured, what they clarified. That history is more valuable than the current constant for K. Constants move. The obituaries teach the next person why the constant is not the architecture. This is adjacent to File Back the Walk’s insistence that paths and rejections compound — without turning this chapter into that book.

From thrift theatre to target selection

Most teams under pressure reach for the same thrift theatre: raise thresholds, lower K globally, truncate abstracts, drop the long tail. Sometimes those moves help. Often they punish residual and reprint with the same blunt instrument. The failed exponential variant is the cautionary tale: a control that looks sophisticated while leaving the real waste category untouched.

Target selection is the upgrade. Once already-visible mass is the named enemy, thrift has somewhere to aim that is not “everything thick.” Once residual is the named asset, thrift has somewhere it must not aim. Chapter 8 turns that target selection into the carve-out. This chapter’s job was only to show that the road to that doctrine went through instruments that failed productively rather than through a single correct guess.

If 99.7% of nominations are already visible, the wrong response is “never show repeated signals.” The model’s attention is finite. A short, explicit shortlist of the most repeated destinations can still be a useful glance — a nudge, not a second photocopy of the neighbourhood.

The design that survived replay was an inversion of the original spend rule.

Two budgets, not one slider

The carve-out is not “less bloom.” Less bloom is a slider. The carve-out is a category split.

Budget A — attention convenience. A small Top-K of repeated structural signals. Purpose: help the model notice what it could in principle reconstruct, without re-paying full resolution on the whole mass. This budget is allowed to contain already-visible items. That is not a bug. The glance is the product.

Budget B — novel residual. Items not reconstructible from the rest of the payload. Purpose: carry the information that fails the obtainability test. This budget is protected by policy. It does not compete with the highlight reel for survival. If your thrift process trims residual to save the shortlist’s vanity metrics, you have inverted the doctrine again.

Unrestricted bloom collapsed A and B into one mass-ranked list and spent as if mass were news. Exponential thrift still spent on the same collapsed list; it only made the list harder to enter. The carve-out refuses the collapse.

Top-five is empirical — say it until it sticks

In the AskUI setting, the small fixed number for Budget A is currently top five. That sentence needs a warning label bolted to it.

Different graph densities will move K. Different edge-line verbosity will move K. Different model families and package layouts will move K. A stack that already prints extremely verbose neighbour lists may need a smaller convenience shortlist; a stack that prints almost no structure in the base package may need a larger one — or, more likely, a better base package.

What should not move is the principle: refuse to spend the bulk of the enrichment budget re-paying salience, and protect the residual that fails the obtainability test. Publish the principle in the design doc. Keep last month’s optimum out of the architecture religion file.

What the replay did under that policy

Point back to Chapter 6 rather than re-staging the scorecard. Under the carve-out policy, the replay reduced convergence entries from 6,472 to 987 and bytes from 4.75 MB to 0.33 MB, while measured precision and cost per eventual take improved. Absolute historical takes fell; live adaptation is untested; bytes alone are not the quality score. Those clauses travel together.

The design reading is what this chapter owns: the outcome was not “we discovered the magic constant five.” The outcome was that splitting convenience from novelty let thrift attack the reprint without automatically deleting the residual.

Why a nudge is not a photocopy

Nudge doctrine demotes fuzzy signals from oracle to prior: a pointer is a whisper; a chunk is a vote. The attention convenience is the retrieval-side cousin of that demotion. You are allowed to bias glance toward the most repeated destinations. You are not allowed to reload those destinations as if the bias required a second full document.

Three rules that keep a nudge a nudge apply with only light translation: do not let the convenience decide; do not make it so rare it becomes an event; do not fatten it until it is a second payload. A Top-K list of IDs and one-line reasons can stay a nudge. A Top-K list that re-blooms full abstracts for nodes already expanded on the edge list is a photocopy wearing a shortlist badge.

Anti-fossilisation practice

When levers change — edge-line format, graph density after a corpus migration, model family, multi-query fusion settings — re-sweep K. Plot embarrassment rate, residual survival, precision, and cost-per-take against K. Pick an operating point. Date it. Do not let it become “the architecture.”

The architecture is the carve-out. K is a dial on Budget A. Confusing the dial for the machine is how teams re-introduce the original failure with better branding.

Spend context on novelty, not on mechanically repeating salience.

Chapter 9 turns to what the residual actually was in this graph. Chapter 10 states the honesty conditions under which you are allowed to retell the result at all.

Writing the carve-out into a design doc

A doctrine that only lives in an ebook will lose to the next clever PR. Write three sentences into the retrieval design doc:

1. Enrichment spend is split into attention convenience (Top-K) and novel residual (obtainability failures).
2. K is an empirical operating point with a date and a re-sweep trigger; it is not the architecture.
3. Thrift attacks reprint of already-visible mass before it attacks residual survival.

Then attach the latest joint scorecard as an appendix, including the live/replay label. When someone proposes “just bloom a bit more for safety,” the doc has a place to point that is not a vibe and not a personality contest. Safety, if real, will show up as residual survival or quality lift — not as a vague desire for thicker JSON.

What changes in the runtime path

In runtime terms, the carve-out is usually a post-convergence filter, not a new retrieval paradigm. You still compute structural corroboration. You still know which nodes are hotspots. You then emit only Top-K hotspot summaries as convenience, and you separately emit residual items that fail obtainability — including inbound-only edges when those are the residual class. The expensive bloom body is no longer the default for every nominated id.

That means your logs should record three sets, not one: nominations considered, convenience emitted, residual emitted. If you only log final package size, you will not know whether a future regression came from residual loss or from convenience bloat. The carve-out is an accounting change as much as a compression change.

Common ways teams quietly undo the carve-out

Three regressions show up after a good carve-out ships. First, someone moves residual items into the Top-K list “so they get noticed,” which collapses Budget B into Budget A and reintroduces mass ranking as destiny. Second, someone thrifts residual to hit a bytes SLO while leaving convenience untouched, which is the doctrine inverted. Third, someone hard-codes K=5 into three services and loses the sweep, so a corpus migration quietly makes the convenience either tiny or huge relative to the new edge-line verbosity.

Guard each regression with a check: residual count must not fall solely to meet a bytes target; convenience items may be already-visible by design; K has a date. Those checks are boring. Boring is how doctrine survives contact with ticket queues.

Strip away the already-visible mass and ask what remains. In the AskUI replay, the genuinely novel entries in the convergence carve-out were uncommon inbound-only relationships — the equivalent of “cited by” rather than “references.”

That sentence is evidence for the doctrine of Chapters 5 and 8. It is not a licence to colonise a different book about the epistemics of edge direction. The boundary is deliberate and enforced in this chapter.

Two questions edges answer

Outbound edges answer: given this page, where might I go? They are the natural contents of a neighbour list and of many halo renderings. If the base package already prints outbound lines, the model has a route map for the returned neighbourhood.

Inbound edges answer a different question: what larger or more peculiar thing considers this page relevant? They are not merely more links in the opposite arrow. They are a different orientation on the same graph.

The obtainability test cares about that difference for a mechanical reason. The model can often notice that several visible outbound edges point to the same place. Repeated destinations are a pattern over text already in the window. What the model cannot infer is an invisible reverse relationship from outside the returned neighbourhood — a pointer that never appears as a destination on the outbound lines the package chose to show.

What the model cannot infer is an invisible reverse relationship from outside the returned neighbourhood.

Why density makes the residual rare — and valuable

In a densely bidirectional graph, most inbound relationships are already visible as outbound from somewhere else in the result set. Page A points to B; B points to A; both appear in the neighbourhood; the reverse is not news. That is exactly why true inbound-only survivors are rare after an overlap filter.

Rarity is not a bug in the design. It is the economic signal. When a relationship survives the already-visible test, it has failed obtainability — which is the entire warrant for spending Budget B. High information value per byte is what you should expect from a residual defined that way. If your residual is large, either your base package is hiding structure it should show, or your graph is less bidirectional than you thought, or your scoring of already-visible is too strict in the wrong places. Investigate; do not celebrate residual volume as a KPI.

What this chapter will not do

Why the wall exists: if this book steals the sibling’s argument, both pieces become the same essay with different titles, and the measurement spine of the carve-out gets buried under graph philosophy. The carve-out only needs one fact from the reverse direction: under the overlap audit, that is where novelty concentrated. The meaning of that concentration is allowed to be interesting without being developed.

A light operational intuition is still fair: adding the reverse direction can make pathing feel more stable without adding much volume, precisely because the residual is small and high-value. That is an observation about payload economics, not a theory of edge semantics.

Do not conflate Quote Satellite

Readers who already know the stack may hear “reverse” and reach for Quote Satellite — the mechanism that files selected source-exact quotes in a typed satellite with reverse lookup, without granting those quotes canonical citizenship in the main graph.

Same compass direction; different question. Quote Satellite is about evidence access without authority contamination — access without citizenship. The novelty carve-out is about within-payload economics — what the model cannot obtain from the rest of the same response. Conflating them produces a muddle where every reverse index is treated as a bloom fix and every bloom fix is treated as an authority model. Keep the tools in their lanes.

How the residual enters the carve-out policy

Policy translation is short because Chapter 8 already did the architecture:

• Budget A may include high-mass outbound-visible hotspots as a short glance list.
• Budget B must include residual items that fail obtainability — in this specimen, inbound-only relationships that never appear on the printed outbound lines.
• Thrift attacks A’s bulk reprint first. It does not “simplify” by dropping B.

If a future audit on a different system finds a different residual composition — rare cross-corpus joins, tool results never mirrored in cards, absences the base package cannot express — the doctrine still holds. Protect whatever fails obtainability. Do not fossilise inbound-only as the only novelty class in nature. Fossilise the test, not last month’s residual taxonomy.

Chapter 10 states the honesty conditions for retelling any of this. Chapter 11 turns the whole measurement half into a protocol you can run without waiting for the forthcoming edge-direction essay.

How to talk about the residual without stealing the sibling

Design conversations love to sprint from a measurement to a metaphysics. Someone hears “inbound-only” and begins a seminar on causality, citation politics, and ontology. That seminar may be excellent. It is still a different seminar.

Use this chapter’s allowed vocabulary in review: obtainability, residual, density, rarity, value-per-byte, Budget B. Avoid this chapter’s forbidden sprint: full taxonomies of reverse-edge meaning, prescriptions for how every graph should store directionality, and any URL that pretends the forthcoming edge-direction piece is already published. If the conversation needs those things, name the forthcoming piece and stop writing its first draft inside a novelty-economics review.

Residual composition as a living field

Treat residual composition as a field you recompute every audit cycle, not as a permanent ontology. In AskUI’s dated replay it was inbound-only. In your stack next quarter it might be cross-index joins, absence markers, or tool outputs that never appear in cards. The doctrine does not require the residual to stay inbound-only forever. It requires that whatever fails obtainability is protected while you thrift the reprint.

Publish residual examples in the scorecard appendix — three concrete items, redacted if needed. Abstract residual talk becomes mystical. Three examples make Budget B real for engineers who will otherwise delete it to hit a bytes target.

Self-refutation with production numbers is rare and highly credible — until the author sandpapers the uncomfortable parts. This chapter is the sandpaper ban. Everything awkward about the AskUI result lives here on purpose, including the byte-reduction vanity trap that marketing will try to peel off into its own victory-lap slide.

The mandatory caveat

That paragraph must survive in spirit into every serious retelling of the scorecard. It is not a legal footer. It is part of the claim.

Why absolute takes falling matters

Precision and cost per eventual take can improve while absolute take count falls. That pattern is coherent: you may get more signal per take, and still get fewer take events under the historical behaviour frozen in the logs. Whether that is acceptable depends on product goals. It is never ignorable. A retelling that quotes only precision improvement is a half-truth with a chart.

Why replay is not live

Historical replay is conditioned on what the old walker was shown. The packages, the opens, the stops, and the takes all happened under prior payload regimes. Behaviour under the new package is partly a new experiment. Walkers may adapt: more opens per residual, different stop rules, different willingness to trust a thinner highlight. Or they may not. The harness cannot fully know until live traffic runs under the Top-K plus residual-preserving design.

That is not a reason to ignore the overlap finding. A 99.7% already-visible rate does not need a live A/B to be embarrassing. It is a reason to keep the claim scoped: measurement of waste under old packages, plus offline evaluation of a thrift policy, plus an explicit unfinished live test.

Byte vanity lives in the caveat, not on a podium

A payload reduction from 4.75 MB to 0.33 MB looks like a win on its own. It is only a real win when read alongside precision and cost-per-take together. Byte totals and raw call counts are engineering constraints, not quality scores by themselves.

This point is absorbed into the caveat material on purpose. It does not get its own victory-lap section. The megabyte ratio is allowed to appear in the joint scorecard (Chapter 6). It is not allowed to star in a slide titled “93% less context” without the precision line, the cost-per-take line, the absolute-take decline, and the live gap.

Model-side weather, not AskUI numbers

Two external results make wasteful payload expensive even when your internal harness is green. Context-rot work found eighteen frontier models degrading as input grows within declared windows.² Lost-in-the-middle work shows mid-context material is systematically under-used.³

Those citations support the economic climate. They do not replace AskUI’s scorecard, and they are not laundered into fake precision about this replay.

How to quote without laundering

A compliant quotation of the result always carries:

• System name (AskUI, with vendor disambiguation if the audience might search the brand)
• Date and method grain (26 July 2026 replay of stored traffic)
• Already-visible rate and/or entry and byte lines as needed
• Precision and cost-per-take movement
• Absolute takes fell
• Replay, not live; live test not yet run
• Top-K as empirical setting; carve-out as doctrine

If a channel is too short for all of that, shorten the claim, not the honesty. “We cut context 93%” is not a short version of this result. “Our overlap audit found enrichment mostly re-printing already-visible structure; we re-priced it” is.

What remains robust under the caveat

Three things do not wait on live traffic:

1. The overlap audit method is portable whether or not AskUI’s residual looks like yours.
2. A high already-visible fraction is sufficient warrant to re-price enrichment, even before the perfect A/B.
3. The doctrine — spend on novelty, not salience reprint — does not require Top-five to be physics.

What does wait on live traffic: walker adaptation, absolute-take recovery or acceptance, and confirmation that the residual still carries the weight hoped for under new behaviour. Schedule that test as part of shipping the carve-out (Chapter 11), not as a sequel fantasy in a backlog that never reaches production.

Part III turns the whole measurement half into operations: a protocol, other surfaces, objections, and a Monday stance that keeps this caveat visible.

Honesty as a retention strategy for doctrine

Teams abandon frameworks that felt like hype. They keep frameworks that predicted the uncomfortable part of reality. The carve-out will spread further if every retelling includes the fall in absolute takes and the live gap. It will die as a meme if it becomes “we cut context 93%.” Meme death is not a branding problem; it is an epistemology problem. The wrong compression of the result teaches the wrong lesson: thrift by bytes, not thrift by novelty.

Put the mandatory caveat in the same slide template as the scorecard. If the slide deck tool forces you to cut, cut the decorative diagram first. Never cut the sentence that says this is replay, not live traffic.

A short compliance checklist for retellings

Before a blog post, internal memo, or conference talk ships a version of this result, run this list:

• Is AskUI named and disambiguated if the audience might web-search the brand?
• Is the date and replay grain present?
• Are absolute takes falling stated in the same breath as any win?
• Is live-not-run stated explicitly?
• Is Top-K labelled empirical?
• Is the megabyte line accompanied by precision and cost-per-take?

If any box is unchecked, the retelling is not ready. The doctrine is strong enough to survive full honesty. It is not strong enough to survive being turned into a bytes meme.

What the caveat does not license

Honesty about replay limits is not a free pass to ignore the already-visible rate. “Live test not run” does not mean “enrichment is fine until proven guilty.” It means thrift policies validated offline still need production confirmation for behavioural adaptation. The waste measurement on historical packages stands on its own: those packages really did re-print structure already in view.

Likewise, absolute takes falling does not automatically mean the carve-out failed. It means the ledger has a cost line. Product owners may accept that cost if precision and cost-per-take improve and users do not regress on grounded answers. They may not. Either decision requires the cost line to remain visible rather than edited out of the narrative.

Chapter 5 defined the overlap audit. Chapter 6 showed what it found in AskUI. This chapter is the operating manual: eight steps, done criteria, and the failure modes of the audit itself. When you finish, you should be able to put a dated scorecard on a design review without waiting for another essay.

Step 1 — Pick one enrichment mechanism

Name the layer in one line: convergence bloom, multi-hop expander, related-entities pack, rerank explanations, agent research dossier, tool-result restatement. Write down the exact field paths that count as enrichment versus base.

Illustrative declaration (your schema will differ):

base:
  results[].id
  results[].title
  results[].abstract
  results[].outbound_edges[]
  results[].halo_gists[]

enrichment_under_test:
  convergence[].id
  convergence[].bloom_abstract
  convergence[].bloom_claims[]
  convergence[].paths[]

Done when: two engineers can classify a field into base or enrichment without a meeting.

Step 2 — Log a sample of model-facing packages

Export the full payload the model saw — including system scaffolding if enrichment is mixed into it. Twenty packages is a useful start for a distribution; more if traffic is highly multimodal. Timestamp and config-hash each package so you can re-run the audit after the next code change.

Exclude internal dashboards. If your only logs are prettified debug views, instrument the model-facing serializer first. An audit of the wrong artefact is worse than no audit: it produces false virtue.

Done when: you can re-hydrate, offline, exactly what entered the window for each sample id.

Step 3 — Build the already-visible index

From base fields only, extract the set of stable IDs, normalised titles, and edge destinations. This is the obtainability surface. Keep it dumb and deterministic. Resist embedding everything “for semantic overlap” on day one. Strict first; fuzzy later if needed.

Done when: for each package, a set V exists such that membership tests are automatic.

Step 4 — Label each enrichment atom

For every ID, title, edge, or claim fragment the enrichment layer added, mark already-visible if it matches V, else novel. Use ambiguous sparingly. Be strict: if the outbound line already named the node, the bloomed abstract of that node is already-visible for this audit even if the abstract text is longer. You may still keep a short Top-K convenience list in production; the audit measures waste, it does not forbid a deliberate glance.

Done when: every enrichment atom has a label, and the ambiguous rate is low enough that arguments are about policy, not about scoring chaos.

Step 5 — Report a joint scorecard

Do not ship a single hero metric. Report at least:

• Already-visible fraction (embarrassment rate)
• Novel residual count and bytes
• Composition of the residual (taxonomy of what only appears there)
• Downstream quality: precision, cost per eventual take, absolute takes — under explicit local definitions
• Whether the data is replay or live
• System name and date

Define “eventual take” locally before you report cost-per-take. In one stack a take might mean a page open that contributed a citation; in another, a tool result that altered the plan. Write the definition next to the number. Do not invent AskUI’s internal metric math; steal the joint-reading discipline, not a fake formula.

Done when: a skeptical reviewer can see quality and thrift in the same glance, and can tell replay from live.

Step 6 — Redesign the spend rule before you redesign the model

If the embarrassment rate is high, the first fix is policy, not a larger model. Cap salience-repetition to a small attention convenience. Preserve the novel residual by policy. Re-measure the joint scorecard. Do not ship a byte-reduction victory lap without the quality pair and an explicit live-traffic plan. If absolute takes fall, write that down in the same paragraph as the byte win (Chapter 10).

Done when: Budget A (Top-K convenience) and Budget B (protected residual) are named in the design doc as separate budgets.

Step 7 — Keep K empirical; keep the carve-out doctrinal

Sweep K on your traffic. Plot embarrassment rate, residual survival, precision, and cost-per-take against K. Pick an operating point. Publish the principle. Refuse to fossilise last month’s optimum as architecture religion.

Re-sweep when edge-line verbosity, graph density, package layout, or model family changes. Those are the levers that actually move K. A constant that never moves while the stack moves is not stability; it is neglect.

Done when: K has a date, a plot, and a re-sweep trigger list; the carve-out principle has no expiry date.

Step 8 — Schedule the live test as part of the design

Replay is how AskUI found the 99.7% figure and the residual class. Live traffic is how you learn whether walkers adapt, whether absolute takes recover or stay acceptably lower, and whether the residual still carries the weight you hoped. Put a date and an owner on that test when you ship the carve-out. A doctrine that cannot survive contact with adapted behaviour is still a hypothesis.

Done when: the ship checklist includes live evaluation ownership, not a vague “phase two.”

What “done” looks like for the whole protocol

You are done with a first pass when a one-page scorecard exists with: mechanism name; sample size; embarrassment rate; residual composition; joint quality lines; replay/live label; chosen K with date; owner and date for live evaluation; and the sentence of doctrine you are willing to put in the design doc.

You are not done when you have only a graph that shows context got smaller. Chapter 12 applies the same tax lens to surfaces that are not wiki bloom. Chapter 13 answers the objections you will hear in the review where you present the scorecard.

Minimal tooling so the protocol is not theatre

You do not need a platform team to start. A day’s work looks like: a serializer flag that dumps model-facing JSON; a twenty-line script that builds set V from base paths; a join that labels enrichment atoms; a CSV of package_id, label counts, and residual examples. The second day wires cost-per-take and absolute takes from whatever event log you already have. The third day is the design review with the joint scorecard on the wall.

If your organisation requires a ticket for every measurement, file the ticket as a reliability task, not as a research project. Overlap rate is closer to an error budget than to a science fair. Treat regressions in embarrassment rate the way you treat latency regressions: noisy at first, then gated.

AskUI’s convergence layer made the failure mode legible: outbound edges printed the destinations, bloom re-printed them, the audit counted the overlap. Other stacks hide the same tax under different field names. The doctrine generalises by keeping the obtainability test and redefining the base surface — not by cargo-culting 99.7% or top-five into every repo.

Multi-hop expanders

A first hop returns entities. A second hop expands neighbours of those entities. If hop-2 is mostly a prettier reprint of hop-1’s neighbour list — same IDs, longer cards — the overlap audit will light up red even if every entity is “relevant.”

Run the audit with base = hop-1 cards and edges; enrichment = hop-2 expansions. Already-visible means the hop-2 entity or edge was already named in hop-1. Novel means hop-2 introduced a relationship or node the first hop did not make obtainable. Protect the novel multi-hop residual. Cap the reprint of hop-1’s own neighbourhood as a short convenience list if the model truly needs a glance.

If multi-hop quality collapses when you cut the reprint, you may have a layout problem in hop-1, not a proof that reprint is reasoning. Fix the base card. Do not call the paper multi-hop intelligence.

Agent research dossiers

Agentic research often concatenates tool results into a dossier: search snippets, page fetches, prior notes. Each section can be locally useful and globally redundant. Three tools each summarise the same three URLs the agent already opened. The dossier gets longer. Novelty stays flat.

Audit cumulatively. Treat each new tool-result section as enrichment relative to the cumulative base of prior sections in the same turn. Label atoms that restate URLs, titles, or claims already present earlier in the dossier. The residual worth protecting is the first time a source appears, the contradiction between sources, or a fact that only appears in one fetch. The thrift target is the third paraphrase of the same landing page.

This is also where progressive disclosure earns its keep: keep a compact index of sources resident, and fetch full text only when the residual warrants spend — rather than re-pasting full pages because the agent might need them.

Rerank explanations

Rerankers sometimes attach a paragraph of “why this document ranked” for every hit. If the features cited are already literal fields in the document card — exact title match, recency stamp, site name — the paragraph is a halo reprint in prose form.

A one-line attention convenience can still be worth it: “top feature: exact title match.” That is Budget A. A second abstract of the document, generated to justify a score the card already implies, is usually Budget A cosplaying as insight. Audit explanations against the card fields. Protect explanations only when they introduce non-obvious features the card does not expose.

Tool schemas and resident clutter

Dumping full parameter docs for every tool into the prompt when the model already has a compact tool list is closer to classic context hygiene than to graph bloom, but the novelty test still applies. Is this schema text news relative to what is already resident? Attention diffusion under tool pollution is a known failure mode: the model spends reasoning tokens negatively filtering tools it will never use.

Carve-out translation: keep a short convenience list of available tools (names + one-liners) as Budget A; load full schemas only when a tool is selected or when the schema contains constraints not implied by the name. That is progressive disclosure for tools, and it is the same economics as not blooming every already-visible hotspot.

Comparison at a glance

Generalise the test, not the percentage

Adaptation rule, one sentence: redefine already-visible against whatever base fields you ship. Edges made AskUI’s audit easy. They are not a prerequisite for the doctrine. Obtainability is.

Same category split everywhere: shortlist for attention, residual that cannot be reconstructed, thrift aimed at reprint, honesty aimed at the joint scorecard. Chapter 13 collects the objections you will hear when you propose that split in someone else’s design review.

Choosing which surface to audit first

If you have several enrichment layers, do not audit them all in parallel on day one. Pick the layer that added the most bytes in the last quarter, or the layer nobody can explain without a diagram. Those are the layers most likely to be sophistication theatre. Run Chapter 11 once end-to-end. Only then expand to multi-hop, dossiers, and schema dumps.

Order matters because the organisation learns the method on the first surface. The second surface goes faster. The third becomes a checklist item. Spreading thin across five surfaces produces five hand-wavy fractions and zero policy changes. One surface with a carve-out shipped beats five surfaces with slides.

When surfaces interact

Real systems stack enrichment: a multi-hop expander feeds a dossier builder that feeds a bloom. Auditing only the outer layer can miss that the inner layer already spent the novelty budget. Prefer an inside-out sequence: audit the earliest enrichment that fattens the package, fix its carve-out, then re-measure downstream layers. Otherwise you will “fix” a late layer that was only reprinting waste created earlier.

Shared obtainability surfaces help. If every layer writes stable IDs into a common envelope, the audit becomes compositional. If every layer invents its own free-text blobs, you will drown in ambiguous labels. Schema discipline is not bureaucracy here; it is what makes novelty measurable.

A note on multi-agent research packages

Multi-agent research systems often win latency by parallel tool calls, then lose the win by concatenating every sub-agent’s full working set into the parent context. That is halo reprint across agents. The parent needed a residual package: what each sub-agent found that the others did not already make obtainable, plus a short convenience list of shared hubs. If you are building that pattern, run the overlap audit across agent boundaries with cumulative base = union of prior agent outputs. The carve-out still applies; only the envelope changed.

Every enrichment redesign attracts the same five defences. None of them requires you to pretend 99.7% was a rounding error. They require you to separate a legitimate need for glance from an illegitimate demand for photocopy.

Objection 1 — “The model might need the repetition to notice.”

That is exactly what the attention-convenience budget is for. A short Top-K list is the honest form of the argument. Full-resolution bloom of everything already on the edge list is the dishonest form.

If your claim is “the model is thick and needs a highlight,” ship a highlight — not a second copy of the book. Measure whether the highlight moves opens or answer quality. If it does, you have justified Budget A. You have not justified unrestricted Budget-A-for-everything.

Objection 2 — “Our enrichment is semantic, not structural.”

Then redefine already-visible against whatever base fields you do ship — prior tool results, document cards, citation lists, earlier dossier sections. The axis is obtainability within the payload, not “edges” as such. Edges made the AskUI audit easy. They are not a prerequisite for the doctrine (Chapter 12).

Semantic enrichment can still be pure replay: three paraphrases of the same passage are three semantic objects and one novelty atom. Strict ID matching may undercount that waste; that is a reason to add a careful second-pass paraphrase audit, not a reason to skip the first pass.

Objection 3 — “Cutting payload will hurt multi-hop reasoning.”

It might, if you cut the novel residual. The carve-out is specifically designed not to. What it cuts is the reprint.

If your multi-hop quality depended on the reprint, you have a different problem: the base package was unreadable and the bloom was papering over layout failure. Fix the base. Do not call the paper reasoning. A system that only works when it says everything twice is not deep; it is poorly laid out.

Objection 4 — “99.7% is so high it cannot be right.”

Run your own audit. This book is not asking you to believe AskUI’s percentage as a constant of nature. It is asking you to believe the percentage is measurable, and that until you measure it you are guessing whether your enrichment is a product or a tax.

In a densely bidirectional graph with verbose edge lines, high already-visible rates are exactly what you should expect. The surprise was not that the rate was high. The surprise was that the tax had been shipping as a feature. If your rate is low, congratulations — publish the method and keep it as a regression check so a future “smarter” layer does not reintroduce the tax.

Objection 5 — “This is just context hygiene with new branding.”

Context hygiene says: remove what does not serve the task. This doctrine says: even among things that serve the task, remove what the model can already obtain from the same response. That is a stricter filter.

Plenty of “hygienic” packages still fail it. They contain only relevant tools, relevant docs, and relevant graph structure — twice. Hygiene without obtainability is incomplete thrift.

Anti-patterns with names

Use the anti-pattern names in review. “This PR is halo reprint” is a faster conversation than rediscovering Chapter 6 from scratch every time someone adds a related-entities field. Chapter 14 compresses the operating stance into what should change on Monday.

Running the objection gauntlet in a real review

Expect the five objections in roughly this order: model needs repetition; our case is different because semantic; multi-hop will break; your number is unbelievable; this is just hygiene. Answer them in that order using this chapter’s language, then put the anti-pattern names on the whiteboard. The goal is not to win a debate club. The goal is to leave the meeting with an agreed embarrassment-rate target and a named owner for the live test.

If someone wants to argue metaphysics of reverse edges, park it under the forthcoming edge-direction piece. If someone wants to argue corpus dedupe, park it under article 183. If someone wants to argue route stability, park it under article 182. Keep the review on obtainability and spend policy. That is how doctrine stays operational instead of becoming a salon.

Anti-patterns as PR review comments

Pasteable review comments save time:

• “Halo reprint risk: are these fields already in the base package? Attach overlap sample.”
• “Threshold cosplay: show mass histogram before adding another rung.”
• “Byte vanity: joint scorecard required (precision, cost/take, absolute takes).”
• “K fossilisation: where is the sweep plot and re-sweep trigger?”
• “Benchmark laundering: this number is single-system; say so.”
• “Caveat sanding: replay vs live missing from the summary.”

Named failure modes turn a philosophical disagreement into a checklist. Checklists ship. Salons do not.

When to stop arguing and run the sample

If a review exceeds fifteen minutes without agreement, stop the ontology fight and pull twenty packages. Compute the embarrassment rate live if you can; offline within a day if you must. Most objections dissolve or transform when the fraction is on the table. The remaining objections become product decisions about Budget A size and live success criteria — which is the correct level of argument once measurement exists.

Objections that are really product choices

Some pushback is not confusion; it is preference. “We accept higher absolute takes even if many are low quality” is a product choice. “We will keep a larger Top-K because our models are weak set reasoners” is a product choice. The carve-out can host those choices inside Budget A and the live success criteria. What it will not host is the claim that those choices make the embarrassment rate irrelevant. Preference does not erase arithmetic.

Fourteen chapters is a long route to a short operating stance. That is fine: the route had to earn the stance with measurement, not with slogans. Here is what should be true on Monday if the book did its job.

Monday checklist

That checklist is the takeaway made operational. After this book, you can audit any context-enrichment mechanism by asking what proportion of its output was already visible elsewhere in the same response, and you can rebuild it around novelty instead of salience.

What this book is not

Scope walls again at the exit, so enthusiasm does not smuggle in the kill list.

Not route-invariant grounding. Whether varied walks still reach equivalent load-bearing evidence is a sibling property. It matters; it is not the novelty axis.

Not corpus redundancy policy. Whether the wiki should contain multiple entrances and progressive restatements is a corpus-shape question treated as error correction elsewhere.

Not the full epistemics of edge direction. Inbound-only relationships appeared here as the novel residual the measurement found. What reverse edges mean in a deeper sense, and what graph design should do about that, belongs to a forthcoming piece on the epistemics of edge direction. Named in prose. No URL guessed for unpublished work.

Not the human–AI co-design loop as main product. The harness that bred the carve-out from failed thrift is real and interesting. It is not this brief’s owned doctrine.

Unfinished business (leave it unfinished honestly)

Live traffic under Top-K plus residual-preserving design. Walker adaptation to thinner packages. Whether absolute takes recover, stay lower acceptably, or reveal a product problem. Re-sweep of K as edge-line verbosity, graph density, and model family move. Those are not footnotes; they are the next measurements. They do not license silence about the 99.7% already-visible rate already in hand.

Close

The industry is in a phase where every stack grows an enrichment layer. Larger windows made the habit feel cheap. Attention never got cheaper. Models still diffuse under clutter; the middle of a long package is still a bad seat for the one fact that was actually new.²³

The overlap audit is almost insultingly simple. Compare the enrichment layer to the rest of its own response. When we did that in AskUI — shipped product, own traffic, dated replay — the answer was humiliating in a useful way: 99.7% of convergence nominations already visible in outbound edge lines; exponential thrift that never reached its own rungs; mass only a weak predictor of opens; entries 6,472 to 987; bytes 4.75 MB to 0.33 MB; precision and cost-per-take improved under the replay; absolute historical takes fell; live adaptation still untested; and a tiny residual of inbound-only relationships doing the real novel work.

The surviving rule was not “Top-K equals five forever.” It was:

Spend context on novelty, not on mechanically repeating salience.

Cap the highlight reel. Protect the residual the model cannot reconstruct. Measure precision and cost-per-take next to the bytes. Admit when the evidence is still replay. Then go run the live traffic.

That is what the payload was supposed to buy all along: not a second printing of the neighbourhood map, but the few lines the map could not have told you.

A thirty-day sketch without fake precision

Week one: instrument model-facing dumps and run the overlap audit on one surface. Week two: propose Budget A / Budget B and pick a provisional K from a small sweep. Week three: ship behind a flag; watch joint scorecard daily; do not celebrate bytes alone. Week four: decide live evaluation success criteria, including what you will do if absolute takes stay down. Those weeks are a sketch, not a Gantt claim about your organisation. The point is sequencing: measure before thrift theatre, thrift before model swaps, live criteria before victory laps.

When the thirty days end, you should have something more durable than a temporary constant: a culture that asks what the payload buys, and a written rule that spends context on novelty rather than on mechanically repeating salience.

The sentence to put on the wall

If your team keeps one sentence from this book where everyone can see it while editing retrieval code, make it this:

Spend context on novelty, not on mechanically repeating salience.

Under it, in smaller type, keep the companions that stop the sentence becoming a lie: Top-K is empirical; residual is protected; joint scorecard; replay is not live; AskUI is one system’s telemetry. Doctrine without companions becomes a poster. Doctrine with companions becomes an operating system for context spend.

Hand-off to the next owner

If you leave the team, leave three artefacts: the field-path declaration for base vs enrichment, the latest joint scorecard with residual examples, and the design-doc paragraph that states the carve-out with K empirical. Without those, the next owner will re-discover bloom bloat the hard way and call it a new insight. With those, they inherit a control loop. Inheritance is the point of doctrine.

Closing the loop with the reader question

Chapter 1 asked what the payload is supposed to buy. The answer, after the measurement half, is specific enough to operate: the payload should buy information the model cannot obtain from what it has already been shown, plus a small deliberate glance at repeated signals if that glance earns its keep. Everything else is a candidate for thrift. That is the reader question answered as a spending rule rather than as a mood about “better context.”

Monday is not for re-reading the whole book. Monday is for one surface, twenty packages, and a fraction on a whiteboard. The doctrine only becomes real when that fraction exists in your system’s handwriting, not only in AskUI’s.