Verification as Commit: Stopping Hallucination Cascades in Multi-Agent LLM Systems

When several language-model agents work together through a shared scratchpad or memory, one agent's invented fact can become another agent's premise within seconds. The second agent reasons on it, writes new claims that depend on it, and by the time anyone checks, the error has spread through much of the team's work. We propose to handle this the way databases handle uncommitted data. Each claim an agent writes starts out provisional. It becomes committed only after an independent check against retrieval or tools passes. Agents may read and build on provisional claims so the team never stalls. A small coordinator records which claims each new claim was built from, commits claims only in dependency order, and, when a claim fails its check, rolls back every claim built on top of it.

The idea comes from black-box concurrency control, the database theory of keeping many independent databases consistent when a coordinator cannot see inside any of them. Two of its techniques carry over directly. The first is commitment ordering: nothing commits before the things it depends on. The second is forced conflict injection: the coordinator plants artificial markers so that hidden dependencies become visible. Agents are exactly this kind of black box, since we cannot see which facts in a model's context actually shaped its output. The testable claim is that optimistic sharing with ordered commits and cascading rollback matches the factual accuracy of making every agent wait for verification, at substantially lower wall-clock latency. We also claim it beats verifying only the final output or filtering each memory write in isolation.

What exists and what is missing

On the database side, A Theory of Global Concurrency Control in Multidatabase Systems and A Unifying Approach to Hierarchical Transaction Management show how invisible local activity creates indirect orderings between global transactions (a hidden chain $T_1 \to L \to T_2$). They also show that consistency can be restored without looking inside each site. The ticket method in Decentralized Global Transaction Management in Multidatabase Systems does this by appending dummy operations on a shared item, so the site's own scheduler is forced to expose an order. Sonata supplies the design principle we reuse. It is a thin layer over unmodified databases that coordinates only at prepare and commit time, and reports an average 7.1% overhead over plain two-phase commit on TPC-C. These papers supply the method. None of them concerns content whose correctness is itself uncertain.

On the hallucination side, several papers motivate the proposal by showing that errors compound. They also constrain it, because each fix they offer works within a single stream. SHARS rejects and resamples uncertain sentences during one model's generation. Detect Before You Attribute traces multi-agent failure cascades after the fact. A-MAC scores each candidate memory independently, and its reported precision is only 0.417 on LoCoMo. None of these can undo downstream work that was built on a claim later found false. The closest systems work, AIOS and CONCUR, schedules agents for throughput and memory pressure without regard to what the agents write. AIOS lists dependency analysis among agent requests as future work.

A Unified Definition of Hallucination frames hallucination relative to a reference world plus a policy for resolving conflicts, and leaves that policy open when the world changes during execution. Our commit protocol is one concrete such policy for a shared, evolving store. HaluEval constrains the design in a different way. It reports that ChatGPT identifies hallucinations only 62.59% of the time in QA (HaluEval), so the commit check cannot be the same model judging itself. We use retrieval-backed atomic verification in the style of FActScore, whose automated estimator is reported to be within 2% error of human experts.

Core Claim

Let each claim $c$ in shared memory have a state: provisional, committed, or aborted. Let $D(c)$ be the set of claims that the writing agent had read when it produced $c$. The coordinator enforces two rules. The first:

$$\text{commit}(c) \text{ only if } \text{verify}(c) \text{ passes and every } c' \in D(c) \text{ is committed}.$$

The second: if a claim $c'$ aborts, every claim whose transitive dependency set contains $c'$ also aborts. The agent that wrote each such claim is then re-run from the step where it read $c'$, now with the claim marked false.

Serializability of reads and writes alone does not help here. A perfectly serializable execution will still faithfully pass on a fabricated fact. The unit that needs "commit" semantics is verification, not the write.

The hard part is estimating $D(c)$ for black-box agents, and we attack it at two levels. Reads through the memory tool are logged, which gives an exact dependency set at that boundary. Claims also leak through channels the coordinator does not control: messages between agents, files, and external tools that one agent writes into and another reads. That leakage is the agent version of the hidden local transaction. For it we borrow forced conflict injection. Every provisional claim carries a short unique marker string (a "provenance ticket") embedded in its text. The coordinator scans every input an agent receives, from any channel, for live tickets. Where paraphrase has stripped the ticket, it falls back to embedding similarity against provisional claims. This recovers indirect dependencies without instrumenting the tools themselves. How often tickets survive paraphrase is an empirical question we measure directly.

Research Program

We will build the coordinator as a Sonata-like layer between agents and an unmodified store. We will also build two multi-agent testbeds, because no benchmark in our file exercises shared agent memory.

The first testbed is multi-hop question answering on HotpotQA in the full-Wikipedia setting. A planner splits each question into sub-questions. Worker agents write intermediate "bridge" facts (the entity that links two documents) to shared memory, and an answering agent composes the final answer.

The second is collaborative long-form writing on FActScore biographies, weighted toward its rare entities, where FActScore reports that precision collapses. Researcher agents post atomic facts, and a writer agent composes the biography from them.

The verifier is the FActScore-style retrieval check, run asynchronously on its own workers so it stays off the agents' critical path.

The program has three phases. The first is a measurement study, done before any intervention. We run uncoordinated teams, verify every intermediate claim afterward, and trace each final error back through the read log. Each error is attributed either to a read of a claim that was false at the time it was read, or to the final agent's own knowledge stored in its weights. This decides whether cascades from shared memory are a large enough share of final errors to matter.

The second phase is the protocol comparison, reported as accuracy against latency. The third is stress testing. There we vary verifier latency, verifier error rate, and team size to map where optimistic commit wins and where it loses.

Baselines

The naive reference point is an uncoordinated shared scratchpad in which any agent reads anything immediately and nothing is checked. This measures how bad the cascade problem is at the outset.

The second baseline stores the same scratchpad in a database running at serializable isolation. This isolates the claim that read/write consistency without verification does not reduce hallucination. We expect it to match the naive baseline on accuracy.

The strongest competitor on accuracy is blocking verification. Here a claim becomes visible to other agents only after it passes the same verifier. It gives the same guarantees as our protocol and is simpler. It runs with the same verifier, model, and hardware, and it counts as beaten only if we match its final factual precision within noise while reducing median wall-clock time per task.

We run two single-stream competitors with the same total token budget. One applies SHARS-style segment rejection sampling inside each agent. The other runs final-output-only verification, in which unsupported claims are deleted from the finished answer. On FActScore, SHARS reports a factual precision gain of roughly 20–26% over greedy decoding for single-model generation. No reported result was found on Lacuna for SHARS in a multi-agent shared-memory setting, so we will measure it ourselves.

We also run an A-MAC-style admission filter on every memory write. On LoCoMo, A-MAC reports F1 0.583, precision 0.417, and 2644 ms per candidate. We re-run it inside our testbeds rather than comparing across settings.

Three ablations isolate our ingredients. The first removes provenance tickets and relies on tool-boundary read logs alone. The second replaces tracked dependency sets with the most conservative choice, "every claim in context," to show the cost of over-approximating dependencies. The third keeps verification but drops cascading rollback, so failed claims are deleted and dependents are left standing.

Beating the field means three things. Our protocol must reach higher final precision than naive, serializable-store, final-only, SHARS, and A-MAC at matched token budgets. It must stay within noise of blocking verification. And it must do so at lower latency.

Why not just…?

Why not just verify every claim before anyone can read it? This is the real threat. If verification is fast relative to generation, or if most claims fail, blocking verification is simpler and at least as good. Optimistic execution only pays when verification latency is long and the abort rate is moderate, because each abort costs a re-run of the dependent agents. The stress-testing phase is designed to map this boundary by sweeping verifier latency against abort rate. If blocking verification dominates across realistic settings, the honest conclusion is that the cascade diagnosis plus blocking verification is the contribution, and the optimistic machinery should be dropped.

Why not just put shared memory in a serializable database? Serializability orders reads and writes. It says nothing about whether the written content is true, so a fabricated bridge entity gets passed along just as consistently as a correct one. The serializable-store baseline tests this directly. If it substantially reduces errors, then races rather than unverified content were the problem, and our framing is wrong.

Why not just check the final answer, or resample within each agent? Deleting false claims from the final text cannot recover the downstream reasoning that was built on them. SHARS acts only within one stream, so another agent may already have read a sentence before it was resampled. The measurement study quantifies how many final errors originate upstream. If that share is small, these simpler methods suffice and we will say so.

Why not just filter memory writes with a learned admission policy? A-MAC judges each candidate alone, and its reported precision of 0.417 means that most admitted items are false positives. Once a bad item is admitted, nothing removes the work built on it. Our A-MAC baseline and the no-rollback ablation separate the value of better filtering from the value of rollback.

Why not let agents debate to consensus? HaluEval finds that models detect hallucinations weakly and can get worse when shown correct and incorrect candidates side by side. Debate among agents that are blind to their own fabrications therefore risks mutual reinforcement of the same error. We include a debate team at a matched token budget as a secondary baseline.

Decisive Checks

Three results decide the proposal. The first is the attribution study. If fewer than roughly a fifth of final errors trace to reads of claims that were later found false, cascades through shared memory are not the dominant failure mode and the protocol is unmotivated. The second is the accuracy–latency frontier against blocking verification, broken down by verifier latency. The third is whether provenance tickets recover dependencies that tool logs miss. We measure this by ticket survival rate after paraphrase and by the drop in uncaught cascades when tickets are enabled, compared with the ticket-free ablation. Throughout, we report informativeness (the number of committed facts in the final output) alongside precision, so that gains cannot come from simply saying less.