The Intent Compiler: Deterministic Fusion of Fuzzy Priors

You already know the broken ritual. Someone asks a real institutional question — not a trivia lookup, a multi-hop “what is going on here?” — and the agent does what agents are built to do: it searches. One good query. Ten ranked hits. A confident summary. Then a second search when the first feels thin. Then a third. By the end of the thread you have three answer-shaped lists and still no investigation. The human is left holding the real job: remembering why they asked, comparing overlaps, noticing what only one lens found, and deciding where to read deeper.

That is not a model failure. It is an architecture failure. The system treated the query as the unit of work. Investigations do not work that way. The unit of work is the intent.

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

This article is the field manual for that reframe: an Intent Compiler. It runs many AI-framed probes in parallel, preserves query provenance, deterministically fuses their result graphs, detects convergence and useful divergence, and spends expensive resolution only where independent routes meet. The output is not a chat reply stitched from three tool dumps. It is an Intent Resolution Package — a single inspectable object that serves the parent purpose.

The origin story: preserve the intent, move the layer

The compiler did not begin as a multi-query product. It began as a design review that refused to treat the first mechanism as sacred.

I asked for a change early in a search pipeline — an idea I thought was interesting — and asked the model to critique it, invent alternatives, and smoke-test designs against the golden walk paths of real users. The original placement only helped marginally. The model 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 the same historical walks, measured coverage moved from 13% to 83%.¹

That number is not an industry benchmark. It is a design-loop measurement on real traces before any production code changed. The lesson is architectural:

• The intent stayed fixed: improve search coverage.
• The mechanism and intervention point were variables.
• Historical behaviour was the evaluation harness.
• The valuable idea was not rejected; it was repositioned.

Call the move an Intent-Preserving Layer Shift. It is the same permission doctrine later used at project scale in the Governance Barbell — tight intent, loose method — applied to retrieval itself.² Without that permission, planning collapses into “implement the thing I just said.” With it, the system is allowed to challenge means while protecting purpose.

What shipped: bloom as an attention compiler

The layer-shifted idea became a feature inside every rich wiki search. The response stopped being “ten ranked pages, good luck walking.” It became a layered package:

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

The decisive layer is convergence. Once a seed set of pages exists, mapping over their actual graph relationships is deterministic. Fuzzy retrieval proposes candidates. Deterministic structure shows which other nodes the neighbourhood collectively points at. In one search about bloom and hotspot resolution, the direct hits included several project and concept pages — and the convergence layer identified a shared destination reached by five separate paths, then returned that node at higher resolution with the paths made explicit.¹

That is structural corroboration, not another similarity score. It does not claim “this page is true.” It claims: given these returned pages, this other node is repeatedly implicated by their edges.

This is Progressive Resolution applied to retrieval: do not polish everything; increase resolution only where the structure of the problem warrants spend.³ Bloom is not smarter ranking. It is an attention compiler — it converts weak retrieval signals into a deterministic decision about where to spend context.

The result set first reveals where attention should concentrate, then the system increases resolution only at those points.

Scale the same idea: multi-query graph fusion

Single-query bloom still leaves a hole. If the agent must discover three dimensions of a problem, serial search burns conversation turns, returns three compressed packages, and forces the model to notice overlap in its head. Parallel tool use can cut research latency dramatically for breadth-first work — multi-agent research systems are built for pursuing independent directions at once — but parallelism without fusion just multiplies lists.⁴

The fix is architectural:

AI supplies several related search questions
        ↓
Searches run in parallel (provenance retained)
        ↓
Graphs are unioned into one result graph
        ↓
Cross-query and within-query convergence computed
        ↓
RAG supplies an advisory semantic signal
        ↓
Hotspots receive extra resolution
        ↓
One augmented evidence package returns

That is not “three searches faster.” It is multi-query graph fusion. Grouping the searches changes what can be known from them. Three independent lists are three lists. A merged graph with provenance is a new epistemic object — the same move as reading a closed email bundle instead of isolated messages.⁵

External research has been pushing the same direction from different doors: classical RAG pulls non-parametric memory into a single generation pass; GraphRAG-style systems use structure to improve comprehensiveness and diversity on sense-making questions; knowledge-graph retrieval has shown multi-hop gains over pure vector baselines in published evaluations.^6,7,8 The Intent Compiler’s claim is more specific than “use a graph.” It is that many intent-serving probes must be fused before the second model pass, by deterministic code that owns provenance and attention budgets.

Four signals that earn bloom (and one that must not be discarded)

Once you have a merged graph, “relevant” is no longer a single score. The compiler distinguishes reasons to spend resolution:

Worked shapes, not mythology:

• Cross-query: “human capacity under green status,” “workforce effects of assurance uplift,” and “why formal reporting hides strain” all land on the same workforce compact page — stronger than one hit appearing twice in one list.
• Within-query: five explicit paths from a seed set to one project page — structural centre, not lexical coincidence.
• Graph–RAG: wiki edges and embedding recall both nudge the same region — mechanically diverse sensors, still one corpus.
• Divergence: a community-engagement page that only the community probe finds may be the minority finding that saves the investigation from false consensus.

This is where most “ensemble retrieval” talk goes soft. Agreement feels like proof. It is not. Graph and RAG inspect the same underlying material. Their agreement means: two different retrieval methods believe this region deserves inspection. It does not mean two independent witnesses established a claim. That is why RAG stays demoted to a sensor and a nudge, and why bloomed material must still descend to source before it becomes evidence.^9,10

Graph–RAG agreement justifies inspection, never belief.

Deterministic Fusion of Fuzzy Priors

Name the doctrine properly.

Not every layer is exact. The model’s choice of probe questions is probabilistic. Embedding similarity is approximate. Approximate-nearest-neighbour cutoffs can jitter near the margin. And yet the pipeline can still be highly deterministic where it matters:

That is the Deterministic–AI Pendulum working correctly: AI judgment → deterministic compilation → AI judgment. The middle is not “more model.” The middle is software that refuses to lose provenance, refuses to spend context everywhere, and refuses to confuse sensor agreement with truth.

Serial multi-hop patterns that interleave retrieval and reasoning at every step are notoriously expensive in repeated model calls; fusing parallel probes into one package is a different cost shape for breadth-first investigation.¹¹ You still pay for probes. You stop paying for rediscovering the graph in chat memory.

Product: the Intent Resolution Package

If the query is no longer the unit of work, the API should stop pretending it is. The ladder is:

1. search(query) — compatibility surface; one string.
2. wiki_search_many(queries[]) — explicit multi-query fusion.
3. investigate(intent, questions?) — the real product: hold the parent intent, optionally seed probes, return a package.

The first model pass is a query planner, not an answerer. It produces a Question Portfolio: direct, alternate, mechanism, boundary, stakeholder, historical, contrarian, “what are we missing?” Critically, it has permission to invent probes the user did not type — provided they serve the held intent. Without that permission, multi-query degenerates into three paraphrases of the order. With it, you get independent routes worth fusing.¹²

The package itself should be inspectable:

This is intent custody at investigation scale: the user’s sentence is transient; the held intent persists across generation, retrieval, fusion, bloom, source descent, and synthesis.^13,14 The product principle is blunt: do not expose the organisation’s internal decomposition as the user’s problem. Inventing three searches, comparing them, detecting convergence, and reconciling conflict is machine work now.

The same compiler, different probes: multi-lens assurance

Once you see the architecture, the project-assurance isomorphism is obvious. A formal project report is the parent object. Delivery, technical, regulatory, workforce, and community questions are the portfolio. Soft-data graphs and hard-data checks are sensors. Intersections bloom. Minority concerns stay visible. Humans receive one review object that refuses to collapse into a single traffic light — the same operating spirit as Elastic Assurance’s compute-broadly, disclose-narrowly plane, and the multi-lens verification end of the Governance Barbell.^15,2

Formal status: Green

Workforce query  → specialist concentration
Community query  → recurring unresolved engagement
Regulatory query → evidence depends on one contractor
RAG recall       → 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 — and it is the right bridge to a larger estate where cognition is scarce and must be spent on purpose. A companion piece in this series, the Cognition Scarcity Audit, develops that scarcity frame; this piece owns the retrieval compiler that makes multi-perspective work cheap enough to attempt.

File Back the Improvement to the Walker

There is one more twist. The usual File Back the Walk doctrine says: querying is ingestion in disguise — walk telemetry should improve the map.¹⁶ Here the recursion went further. Insights from the wiki about progressive resolution and advisory recall improved the retrieval apparatus itself. Future searches over that IP now inherit the improved cognition. The insight compiled into the cognitive apparatus that retrieves the insight.

File Back the Improvement to the Walker.

That is the recursive promise of an Intent Compiler living inside a living wiki-graph: not only better answers, but a better walker — deterministic fusion of fuzzy priors, again and again, with the parent intent held steady while the probes, the graph, and the attention plan get sharper.

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.

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 package that a human can audit — and a second model pass can judge — without reconstructing the investigation by hand.