The Intent Compiler

Picture the institutional question that never fits a FAQ. Someone needs to know what is going on — not a clause lookup, a multi-hop sense-making problem across projects, people, prior decisions, and soft evidence that never made the dashboard. They open an agent. The agent does what agents are built to do. It searches.

One careful query. Ten ranked hits. A fluent summary. Something feels thin, so there is a second search. Then a third. By the end of the conversation the human has three answer-shaped packages and is still holding the real job: remembering why they asked, comparing overlaps by eye, noticing the finding that only one framing surfaced, and deciding where a careful read is still required.

That failure mode is so common it has become invisible. We call it “using retrieval.” It is not investigation. It is serial answer generation with the fusion step unpaid and unowned.

Hold the intent and answer the intent — not the individual questions.

The incumbent belief

The default mental model of better investigation is simple:

1. Write a better query.
2. Get a better ranking.
3. Let the model summarise the top hits.
4. If the answer is incomplete, search again in the same chat.

Each step is rational in isolation. Together they assume the query is the unit of work. The chat thread becomes the only place where multi-perspective structure can live — inside a model’s working memory of prior tool dumps. Provenance blurs. Overlap is noticed late or not at all. Minority lenses get treated as noise. And the parent purpose quietly mutates into whatever the last sentence happened to emphasise.

Software teams have learned a version of this lesson already. Multi-agent research systems are strong precisely when a problem is breadth-first and needs independent directions pursued at once.¹ Parallelism helps. Parallelism without fusion merely multiplies lists. You still need an object that can hold the investigation together after the probes return.

Intent, query, probe

Three words get collapsed in everyday speech. They should not be.

When the system answers the query, it can be locally correct and globally useless. When it answers the intent, individual probes are allowed to look strange. A boundary question, a contrarian framing, a stakeholder lens — none of those need to be what the user typed. They need to close the purpose.

What fragmentation costs

Fragmentation is not merely aesthetic. It taxes the scarce resource — attention — in four predictable ways.

• Lost purpose. Each subquery becomes a local task. Multi-agent systems are especially good at dying this way: every worker answers its assignment correctly; the assembly no longer answers what the human cared about.
• Wasted context. The same pages reappear under different wordings without provenance. The second model pass re-summarises instead of judging structure.
• False consensus. Agreement inside one corpus is misread as proof. Sensors that rhyme with each other get treated as independent witnesses.
• Silent minorities. The finding that only one framing surfaced is the first thing averaged away — and often the only thing that would have changed the decision.

Answering the last sentence typed is not investigation. It is how organisations manufacture confident incompleteness.

What this book is for

This book codifies an Intent Compiler. The architecture runs many AI-framed probes in parallel, retains query provenance, deterministically fuses their result graphs, detects convergence and useful divergence, and spends expensive resolution only where independent routes meet. The output is an Intent Resolution Package — not a chat collage of tool dumps.

You will leave able to architect the loop end to end, and to name which stages must be deterministic: union, provenance, route counts, bloom allocation. You will also leave with a precise caution: graph–RAG agreement justifies inspection, never belief. That boundary is load-bearing. Without it, fusion becomes a more sophisticated way to launder similarity into certainty.

Companion work owns the wider assurance estate — Elastic Assurance, institutional soft-data sensing, governance as a barbell of design and verification. This book owns the retrieval compiler: the doctrine of Deterministic Fusion of Fuzzy Priors, the shipped bloom behaviour, multi-query graph fusion, and the package that makes intent custody operational.

Strategy says multi-perspective; practice ships one ranking

Ask technical leaders what they want from agentic retrieval and you will hear grounded, multi-perspective answers. Watch what they ship and you usually see a single query string, a top-k list, and a summariser. The strategy–execution gap is the content gold: the organisation pays for investigation and receives chat-shaped retrieval. The Intent Compiler is the mechanism that closes that gap without turning every user into a search engineer.

That also clarifies who this book is not for. If you want a better chatbot prompt tip, stop here. If you want a vendor bake-off between vector databases, look elsewhere. If you need a full governance product for capital projects, the sibling assurance books are the right shelf. This book is for people who will actually own the loop: portfolio → parallel retrieval → fusion → bloom → package.

Close

If the unit of work is intent, you need more than a better ranker. You need a compiler that can accept fuzzy probes, refuse to lose structure, and still return one inspectable object aimed at the purpose. The next chapter names that doctrine and draws the line between judgement and machinery.

Name the doctrine before the machinery, or the machinery will get sold as “smarter RAG.”

Deterministic Fusion of Fuzzy Priors is the claim that useful investigation starts with imperfect sensors — model-chosen probes, embedding recall, advisory ranking — and becomes trustworthy only when deterministic software owns the join: provenance, union, counts, thresholds, and the attention budget. The second model pass then reasons over a package that already knows where independent routes met.

AI judgment → deterministic compilation → AI judgment.

Fuzzy is not a slur

Classical retrieval-augmented generation already admitted the basic move: combine parametric memory with non-parametric documents fetched at query time.² Embedding similarity is powerful precisely because it is approximate. For a fixed query, embedding model, corpus, index, metric, and parameters, results are ordinarily reproducible. That still does not make RAG an exact database lookup.

Aliases change. Indexes rebuild. Approximate nearest neighbour ordering jitters near the cutoff. Upstream, an LLM rewrites the search string. Call the honest engineering name:

That demotion is not an insult. Sensors are how complex systems work. The failure is treating a sensor reading as a witness statement. Elsewhere we have argued for demoting RAG from architecture to sensor, and for treating small signals as nudges rather than verdicts.

Which layers may be fuzzy; which must not

If you blur those rows, you get two opposite failure modes. Put the model in the middle and provenance dissolves into prose. Put only exact lookups in the front and you never generate the independent probes that make fusion worth doing. The pendulum is the design: variation at the ends, compilation in the middle.

Agreement is not corroboration

This is the honesty rule of the whole book. Mark it once, then refuse to re-soften it later.

When the symbolic graph and the embedding index both implicate the same region, that is valuable. The mechanisms differ. One follows declared relationships. One follows semantic neighbourhood. Mechanical diversity is real. Epistemic independence is not. Both sensors usually inspect the same underlying corpus. Their agreement means:

Two different retrieval methods believe this material deserves inspection.

It does not mean:

Two independent witnesses prove this claim.

That is why a bloomed page is an attention decision, not a citation. Source descent remains mandatory. If your fusion layer cannot say that sentence out loud, it will eventually launder similarity into “the system confirmed it.”

Industry systems keep rediscovering pieces of the same shape. Graph-structured retrieval improves comprehensiveness and diversity on sense-making questions over large corpora; knowledge-graph methods have reported multi-hop gains against pure vector baselines in published evaluations.³⁴ Those results support structure. They do not excuse skipping fusion discipline or source descent.

Attention is CapEx

Context is not a dump. It is a budget. Full-resolution everything is how you afford nothing. Ten flat summaries are how you force the model to rediscover the graph in its head. Serial multi-hop patterns that alternate retrieval and reasoning at every step burn repeated model calls and tokens; breadth-first investigation wants a different cost shape — parallel probes, one compiled package, selective depth.⁵

The compiler’s middle layers exist to spend resolution where independent routes already point. That is not thrift for its own sake. It is how you keep the second judgement pass dense enough to be honest.

Why the middle cannot be “another agent”

It is tempting to solve fusion with a supervisor model: “read these three tool outputs and merge them.” That produces fluent merges and invisible loss. Provenance becomes a story. Minority findings become tone. Budgets become whatever fitted the context window today. The Intent Compiler’s claim is harsher: fusion is infrastructure. If two runs with the same seed graphs cannot recompute the same hotspot set, you do not have a compiler — you have a chat with extra steps.

What deterministic code refuses to do

It is worth naming the refusals, because they are the product.

• Refuse to lose provenance. Every node remembers which probe brought it in.
• Refuse to spend context everywhere. Resolution budgets are explicit, not vibes.
• Refuse to delete minority labels. Divergence is typed, not silently dropped in a merge.
• Refuse to promote sensors to proof. Graph–RAG agreement never becomes a citation by itself.

Those refusals are why the middle of the pendulum is software, not “another agent.” An agent can narrate a merge. Only deterministic code can make the merge auditable under load, across runs, with budgets that do not drift because the prose felt confident.

Close

Doctrine without an origin story stays abstract. The next chapter is the design review that preserved a human intent, moved the intervention to a more informed layer, measured the difference on real walks — and accidentally specified the bloom feature that now sits inside the search tool itself.

The Intent Compiler did not begin life as a multi-query product brief. It began as a design conversation that refused to treat the first mechanism as sacred.

I had an idea for improving search. I asked for it at the early step of the pipeline. Then I asked the model to do something more useful than implement my sketch: critique the design, invent alternatives, and smoke-test candidates against the golden walk paths of existing users. We were still inside the design loop. No assets had been built. No production code had moved. The evaluation harness was historical behaviour we already owned.

The original placement only helped marginally. The alternative kept the same conceptual idea, moved the intervention halfway through the search process, and used it to augment results rather than assist the initial ranking. Against those same golden walks, measured coverage moved from 13% to 83%.⁶

Treat that figure carefully. It is not an industry benchmark. It is a design-loop measurement on real traces. The architecture lesson survives the caution:

Preserve the intent. Move the intervention. Replay before you build.

Intent-Preserving Layer Shift

The move deserves a name because teams keep making the opposite mistake: they either defend the first implementation as if it were the goal, or they throw away the human insight because the first placement underperformed.

Intent-Preserving Layer Shift holds the underlying intent constant while treating mechanism, location, and timing as variables. It asks:

• Is this the right idea at the wrong layer?
• Should it operate before, during, or after the existing process?
• Should it improve the input, guide the process, or augment the output?
• Does the idea need more information than exists at the proposed intervention point?
• Is a downstream augmentation stronger than an upstream replacement?

The model did not discard the idea. It repositioned it. That is a particularly valuable form of challenge: it protects human insight while refusing to sacralise the first implementation.

Permission changes planning into discovery

None of that happens if the contract is closed. “Plan this feature” is almost always interpreted as “work out how to implement the feature I specified.” The proposed mechanism becomes the requirement. Alternatives shrink to implementation details. Success means a plausible plan, not a tested choice.

The open contract is closer to:

That is tight intent, loose method applied to planning — the same permission lineage that shows up in north-star orientation and, at project scale, in the Governance Barbell’s design end.

Without explicit permission, even a capable model optimises itself into a highly articulate order-taker. With permission, the means can move while the purpose stays held.

Counterfactual design replay

The second capability is just as important as the repositioning. The alternative was not selected because it sounded persuasive. It was replayed against historical golden paths and measured.

That sequence is the tether:

Generate → replay → measure → compare → human judge
# not
Generate → admire → approve

For software, the harness may be golden journeys, production logs, failed sessions, support incidents. For capital projects the analogues are historical decisions, variation sequences, community complaints, approval pathways, workforce patterns — institutional traces that make second-hand time travel possible. AI cannot smoke-test “everything” by intelligence alone. It needs a project test harness. Each completed episode makes the harness stronger.

Keep AI behind the glass

The governance boundary has to be explicit or the good design story gets sold as delegated authority.

AI is not authorised to select the binding design, approve milestones, commit expenditure, or sit in the hot path of live operations. The safe formulation is not “AI designs the project.” It is: the team designs; AI makes the design withstand more challenge before it reaches approval. Keep AI behind the glass — review artefacts in, authority out.

The bridge into bloom

Look back at the layer shift with retrieval eyes. The original intention was: help the system find relevant knowledge. The first placement sat near the start of retrieval. The improved placement sat after initial results existed, where structural information was available, and augmented the selected neighbourhood with higher-resolution hotspots.

That is exactly the bloom feature the next chapter describes — not as a metaphor, as shipped behaviour. The insight did not remain a design memo. It compiled into the cognitive apparatus that retrieves knowledge.

Close

Preserve the intent. Vary the implementation layer. Replay before commitment. Once that move is inside search itself, the result package stops being a flat list and starts being an attention plan. Chapter 4 is what that looks like when it ships.

Once the layer-shifted idea shipped, you could see it in the package. A rich wiki search stopped returning “ten ranked pages, good luck walking the edges.” It returned a layered evidence object with selective high resolution where structure warranted spend.

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 stack is Progressive Resolution applied to retrieval: do not polish everything; stabilise structure, then spend detail where it pays.

What the convergence layer is doing

Convergence is the hinge between fuzzy retrieval and deterministic attention.

1. Take the returned search pages as a small subgraph.
2. Inspect what those pages point toward through actual edges.
3. Count how frequently other pages are reached across the results.
4. Rank repeatedly indicated pages as hotspots.
5. Return them at higher resolution — why they converged, the paths that reached them, richer gists, claims, useful outgoing edges.

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.

Worked example: five paths to one centre

In a search about bloom and hotspot resolution, the direct results included pages such as the dev-wiki project map, LLM-navigated wiki concepts, advisory embedding recall, and the MCP IP-wiki surface. The convergence layer identified a different node — the ebook-writer project — as the strongest shared destination, with five separate paths leading toward it. It then returned that node’s larger abstract, claims, and relationship set, with paths made explicit rather than implied.⁷

A simplified path shape looks like this:

project.dev-wiki
    → shares-pattern-with
    → project.ebook-writer

concept.llm-navigated-wiki
    → embodied-by
    → project.ebook-writer

project.mcp-ip-wiki
    → depends-on
    → project.ebook-writer

The synthesizer does not merely receive “ebook-writer may be relevant.” It receives why the result set collectively points there. That is the difference between a ranked list and an attention plan.

Bloom as attention compiler — not smarter ranking

Three questions, three layers:

That is a better use of context than either extreme: returning every page at full resolution, or returning ten flat summaries and making the model rediscover structure through aggressive edge walking. Let the result set show where attention should concentrate — then increase resolution only there.

What bloom is not

• Not a truth oracle. Structural implication is not established fact.
• Not a citation. Bloomed material still descends to source before it becomes evidence.
• Not full multi-query fusion. Single-query bloom still leaves multi-perspective portfolio construction partly to the chat — Chapter 5 closes that gap.
• Not a substitute for intent custody. A beautiful hotspot package aimed at the wrong parent purpose is still the wrong investigation.

The feature demonstrating its own thesis

There is a clean recursion here. The earlier experiment said: keep the intention, move the intervention to a more informed point, use existing results to augment what comes next. The shipped bloom does exactly that.

In practice, that changes what investigations notice. Code-review searches bloom into verification loops and correlated-checker pitfalls rather than only the nearest keyword pages. Project-lens searches bloom into multi-agent deliberation and visible rejection concepts. Design-testing searches bloom into simulation substrates and failure-shape prediction. Those are not merely closest wordings. They are structural centres of the returned neighbourhood.

Halo and recall without authority creep

Two supporting layers make bloom honest. Halo returns one-hop neighbour gists so the synthesizer sees local context without walking every edge by hand. Recall surfaces advisory candidates the primary semantic ranking may have missed — needles that rhyme with the question but did not win the first sort. Both remain subordinate. They 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 the one-hop walk tax on every hotspot. The shipped package keeps the advisory layers visible and typed so the second pass can use them without confusing them for proof.

Close

Single-query bloom already upgrades the package. It still leaves a hole: if the agent needs several genuine perspectives, serial search burns turns and forces overlap detection into model memory. The next chapter scales the same doctrine — multi-query graph fusion and the four signals that earn bloom across probes.

Single-query bloom still leaves multi-perspective work half-finished. If the agent must cover three dimensions of a problem, the old pattern is familiar: search, read, search, read, search, read. Three tool calls. Three compressed packages. No structural comparison. Repeated nodes waste context. Overlap remains something the model must notice manually. Each result is squeezed before it ever sees what the others found.

Parallel tool use can cut research latency for breadth-first work.¹ That is necessary and insufficient. Parallelism without fusion multiplies lists. The architectural upgrade is multi-query graph fusion.

AI supplies several related search questions
        ↓
Searches run in parallel
        ↓
Results retain query provenance
        ↓
Graphs are unioned into one result graph
        ↓
Cross-query and within-query convergence calculated
        ↓
RAG provides another advisory signal
        ↓
Hotspots receive extra resolution
        ↓
One augmented evidence package returns

Parallel probes. One graph. Bloom the intersections.

Permission again — or multi-query becomes theatre

Multi-query is worthless if the probes are three paraphrases engineered to confirm the original request. Without design latitude, the planner optimises for compliance. With latitude — tight intent, loose method — it can generate genuinely different dimensions: mechanism versus boundary, stakeholder versus historical analogue, direct claim versus refutation.

The first planning permission is what makes the second feature useful. You are not asking for three wordings of the same order. You are asking for independent routes worth fusing.

The four signals that earn bloom

Once you have a merged graph with provenance, “relevant” is no longer a single score. The compiler distinguishes reasons to spend resolution. This is the definitive map; later chapters use it rather than restate it.

1. Cross-query convergence

Different formulations or dimensions independently reach the same node. Example shape: “human capacity beneath green status,” “workforce effects of assurance uplift,” and “why formal project reporting hides strain” all point toward the same workforce compact. That is stronger than the same node appearing twice in one result list, because it survived different framings rather than one ranking’s redundancy.

2. Within-query graph convergence

Several returned pages point through actual graph edges to the same underlying page. The five-path structural centre from Chapter 4 is the worked example: immediate results differ, but structurally they share a dependency or conceptual centre. The package returns the centre with paths, not a vague “also relevant.”

3. Graph–RAG convergence

The symbolic graph points toward a page, and embedding recall independently ranks it as semantically relevant. That is useful mechanical diversity: relationships say “here”; language says “here.” When both agree, it is reasonable to spend more context budget there.

It is still not independent external corroboration. Remember Chapter 2: shared corpus, shared materials, inspection warrant only. RAG remains a nudge. Bloomed pages still open to source.

4. Useful divergence — minority findings

A page appears strongly for one formulation and nowhere in the others. That may indicate a genuinely distinct dimension, an over-specific artefact, an important minority route, or a framing artefact. The correct default is not discard. The correct default is label: single-lens candidate, not intersection evidence.

Investigations die when they average disagreement into a smooth story. Diversity selection has an old information-retrieval lineage — pick the best, then pick the best that is sufficiently different — because coverage is not the same as redundancy.⁸ Minority findings are findings. Type them. Keep them visible.

Grouping changes epistemology

Three independent result lists are merely three lists. Once you preserve query provenance and compile their graphs together, the result becomes a different object. Patterns across routes become visible. Missing closure becomes visible. The merge is not deduplication with better marketing.

Grouping the searches changes what can be known from them.

That is the same epistemic move as reading a closed bundle of records rather than isolated messages: the package is stronger than the parts because structure is first-class.

Preview: the assurance isomorphism

The same signals map cleanly onto multi-lens project review. Delivery, community, workforce, and regulatory probes become the multi-query list. Hard data becomes another sensor. Overlap creates a hotspot. The hotspot receives deeper review. Formal status stays human. Humans receive a selectively bloomed disagreement set rather than eight disconnected opinions. Chapter 7 develops that variant; the mechanism is already fully specified here.

Worked micro-trace: one intent, three probes

Intent: understand why progressive resolution keeps appearing when people talk about wiki search quality.

• Probe A (direct): progressive resolution in retrieval packages
• Probe B (mechanism): how hotspot bloom allocates context mid-search
• Probe C (boundary): when full-resolution retrieval is the wrong spend

Separately, each probe returns useful pages. Fused, the package can show cross-query convergence on progressive resolution and attention-budget concepts, within-query paths into the search tooling project, a RAG nudge on related resolution-ladder language, and a minority finding from the boundary probe about tasks too small to deserve the ladder. The synthesizer then answers the intent — not three mini-essays stapled together. That micro-trace is the architecture in miniature; production portfolios are simply wider.

Close

Fusion and signals are machinery. Products fail when machinery is exposed as the user’s job. The next chapter packages the loop: held intent, Question Portfolio, Intent Resolution Package, and the API ladder from search to investigate.

If the query is no longer the unit of work, the product should stop pretending it is. The user should not have to invent the right three searches, call them serially, remember their shared purpose, compare overlapping pages, detect graph convergence, decide where to read deeper, reconcile conflicting results, and then reformulate the original question. That is machine work now.

Hold the intent and answer the intent — not the individual questions.

The full loop

User expression
      ↓
Held parent intent
      ↓
AI-generated Question Portfolio
      ↓
Parallel retrieval (provenance retained)
      ↓
Deterministic graph fusion
      ↓
Convergence + divergence + RAG nudges
      ↓
Selective bloom
      ↓
Drive important claims to source
      ↓
One Intent Resolution Package
      ↓
Answer the parent intent

Every arrow is load-bearing. Skip fusion and you are back to lists. Skip source descent and you launder sensors into citations. Skip held intent and you get a beautiful package aimed at the wrong job.

First pass: query planner, not answerer

The first model responsibility is not to write the final prose. It is to produce a small Question Portfolio that covers the intent. A healthy portfolio mixes:

• a direct formulation of what was asked
• an alternate wording that changes angle without changing purpose
• a mechanism question (“how would this actually work?”)
• a boundary or failure question
• a stakeholder lens
• a historical analogue
• a contrarian or refutation query
• a “what are we missing?” probe

Critically, the planner has permission to generate questions the user did not explicitly ask, provided they serve the held intent. Example: a user asks whether AI should review project governance. A literal search chases “AI governance.” An intent-aware portfolio also asks where regulatory scrutiny is hottest, which projects have contested causal explanations, where formal status compresses community or workforce evidence, what evaluation harness history could support replay, and where AI would introduce unacceptable hot-path risk. Those are not seven separate answers. They are seven probes constructing one answer.

Clients and schemas lag products. A connector may still advertise a single string while the backend can fuse. The design target remains the third primitive: expose what the system actually does, rather than forcing the caller to pretend they merely wanted search results.

The package

Formalise the output as an Intent Resolution Package:

The package should be inspectable enough that a caller can say: you understood my underlying problem, searched it from these angles, found these intersections, preserved this disagreement, and used these sources. Known absences are first-class. A system that cannot admit what it failed to close will invent closure in prose.

Intent custody

This is intent custody applied inside an investigation. The user’s sentence is transient. The held intent persists across query generation, retrieval, fusion, blooming, source descent, and synthesis. Without custody, each subquery becomes a local task and the investigation fragments. With custody, the system can ask very different questions and still recognise that they are subordinate to one purpose.

That protection is practical, not poetic. Multi-agent systems routinely produce correct local work that no longer answers the human’s actual concern. The parent intent is the invariant that makes assembly meaningful.

Division of labour

Again the pendulum: AI judgment → deterministic compilation → AI judgment. Not an LLM doing everything. Not deterministic retrieval pretending it understands purpose.

Coverage map as anti-self-deception

The coverage map is easy to under-specify and expensive to omit. Without it, a package can look complete while quietly skipping a stakeholder lens or a failure question. With it, the second model pass and the human reviewer can see which aspect of the held intent each probe claimed to serve — and which aspects still show as known absences. That is how intent custody becomes inspectable rather than aspirational.

Before / after shape on the same intent

Close

The package is the product. What remains is what the compiler unlocks when it lives inside a recursive knowledge system and a multi-lens assurance estate: file improvements back into the walker, and compile parallel organisational lenses into one review object without erasing disagreement.

The Intent Compiler is not only a better search feature. Once it lives inside a living wiki-graph and a review estate, it pays twice: recursively, by improving the walker; organisationally, by compiling parallel lenses into one inspectable review object. These are not new frameworks. They are the same fusion doctrine under different parent intents.

File Back the Improvement to the Walker

File Back the Walk already said that querying is ingestion in disguise: walk telemetry should improve the map — missing edges, dead ends, co-traversals that deserve links.

Here the recursion went one step deeper. The wiki already contained Progressive Resolution, Nudge Doctrine, and graph-navigation IP. Those ideas informed a retrieval improvement. The improvement was implemented in the wiki search tooling. Future searches over that IP now inherit the improved cognition. Those searches produce further ideas that can improve the apparatus again.

The insight compiled into the cognitive apparatus that retrieves the insight.

Call the twist what it is: File Back the Improvement to the Walker. The prior search did not merely add knowledge pages. It improved how future agents traverse and perceive the graph. The wiki stops being only a repository describing frameworks. The retrieval system gradually becomes an executable expression of those frameworks.

That is why conversations over a mature IP wiki feel different as the tooling matures. You are not only reading the doctrine of better cognition. You are using a tool whose returned context has been shaped by that doctrine — Deterministic Fusion of Fuzzy Priors applied to its own substrate.

Variant: multi-lens assurance as the same compiler

Now change the parent object. Instead of a research question over a knowledge graph, take a formal project report — the green light, the milestone pack, the regulator-facing account. The overarching intent is not “answer my sentence.” It is closer to:

Give existing governance a fuller, evidence-backed understanding of the project than the formal traffic light can carry.

The Question Portfolio becomes a set of independent review lenses:

• delivery
• technical
• regulatory
• workforce
• community
• consumer
• assurance coverage
• historical analogue
• predicted failure shape

Those reviews run in parallel. Soft-data graphs and hard-data checks are sensors. Intersections bloom. Distinct minority concerns remain visible rather than averaged into a single colour. Humans receive one review package — not eight disconnected AI opinions. Formal project status remains owned by existing process and accountable people.

Formal status: Green

Workforce query   → specialist concentration
Community query   → repeated unresolved engagement issue
Regulatory query  → evidence depends on one contractor
RAG recall        → recurring schedule-pressure language
Graph convergence → all paths touch the same delivery package

Result: bloom that package for deeper assurance

None of the individual signals is a verdict. The intersection tells the system where more attention is economically justified. That is the Intent Compiler wearing an assurance badge — the same operating spirit as Elastic Assurance’s compute-broadly, disclose-narrowly plane, and the multi-lens verification end of the Governance Barbell.

This book does not own the full assurance product. Institutional soft-data linting, failure-radar sensing, and workforce heroics that paint status green are sibling concerns. The isomorphism is the point: if you can compile probes into an Intent Resolution Package, you can compile organisational lenses into a Soft Attestation Package without erasing disagreement.

Why this matters when cognition is scarce

Multi-perspective work is only useful if it is cheap enough to attempt. When senior attention is scarce, organisations either skip multi-lens review or collapse it into theatre. A compiler that holds intent, fuses fuzzy priors deterministically, and blooms selectively is how multi-perspective cognition becomes operational rather than aspirational. A companion piece in this series — the Cognition Scarcity Audit — develops that scarcity frame. It is not yet published as a live URL at the time of writing; treat the name as a pointer, not a link.

What to build Monday

1. Name the parent intent before the first search string. If you cannot state it in one sentence, you are about to answer the wrong unit of work.
2. Authorise a Question Portfolio — including probes the user did not type — under tight intent, loose method.
3. Run probes in parallel with query provenance retained on every node.
4. Union graphs before the second model pass. Make the merged graph the object the synthesizer reads.
5. Compute the four signals — cross-query, within-query, graph–RAG, useful divergence — as deterministic scores, not vibes.
6. Bloom selectively. Spend context on hotspots; keep minority findings typed, not deleted.
7. Drive bloomed claims to source. Sensor agreement is inspection, never belief.
8. Return an Intent Resolution Package, not a chat summary of tool dumps.
9. File improvements back into the walker when investigations reveal missing structure or better attention rules.

Close

The incumbent mental model says better investigation is a better single ranking of a better single query. Replace it. The query is a probe. The intent is the job. The compiler’s intermediate representation is a merged evidence graph. The output is one Intent Resolution Package a human can audit and a second model pass can judge — without reconstructing the investigation by hand.

That is the Intent Compiler. That is Deterministic Fusion of Fuzzy Priors. Build the pendulum correctly — AI judgment, deterministic compilation, AI judgment — and the organisation stops asking people to be the fusion layer for free.