When a language-model agent sends a payment, deletes files, or rewrites a database row, the most dangerous mistake is often not a malicious request. It is an ordinary hallucination, meaning a confidently invented fact, that lands in a tool argument. Examples include a wrong account number, an exchange rate the model made up, or a recipient taken from the wrong customer record. Current gates for irreversible actions do not look for this. Some check whether the action was authorized. Others check whether the world changed since the user approved it. Others check whether the call matches a policy. None of them checks whether each argument value is actually grounded in something the agent saw. We propose that, before any irreversible call, the agent must attach an argument certificate: for every parameter, a statement of where the value came from. Most certificates can be checked mechanically. A small model trained for one domain checks only the semantic remainder.
The core idea fits in two sentences. Every argument to an irreversible call must come with one of three claims: "copied from this span," "computed from these spans by this expression," or "chosen by this semantic link to this span." Cheap deterministic checks handle the first two, and a compact domain-specialized verifier handles only the third. This design treats irreversibility as the setting, hallucination as the failure being caught, and domain specialization as the means of making the residual check cheap and accurate.
Core Claim
Gating irreversible actions on argument provenance catches the non-adversarial, hallucination-driven harms that existing gates provably let through. The claim covers whole trajectories, and it holds without the false-positive cost of a generic judge. A further claim is that small models fail as safety checkers for a reason other than scale. Once a certificate narrows the question to "does this span support this binding," a 7–8B domain-specialized verifier should match or beat a frontier judge that reads the whole trajectory.
The gap is documented explicitly in prior work. Causal Chain Authorization in Same Action, Different Justification verifies that an irreversible call has a legitimate causal history and reaches 100% pairwise separation on its matched-pair benchmark. Its authors state, however, that a hallucinated parameter inside an authorized path passes (their Boundary P8). ShieldAgent compiles policy documents into checkable logic and reports 90.1% violation recall, but it names hallucination risks that need knowledge outside the policy as a failure case. EffectGuard re-validates the approved effect against drifting state, but it assumes the agent's parameters were right to begin with. The Clawdbot audit supplies the motivating mechanism. Given an empty PDF or an underspecified request, the agent fabricated facts and then executed broad deletions, and it passed 0% of intent-misunderstanding cases. These papers supply the motivation. Our work fills the slot they leave open.
Research Program
The certificate. We define a small certificate format attached to each irreversible tool call. Each argument is labeled as one of three kinds:
- COPY, with a pointer to a span in a user message or a prior tool output.
- DERIVE, with a pointer to source spans plus an executable expression, for example "balance minus fee, converted at the rate returned by the rate tool."
- BIND, with a pointer to a span and a natural-language justification, for example "the account belonging to the recipient, not the sender, in this record."
An argument with no certificate counts as unsupported.
The checks. COPY is checked by exact or normalized string match against the logged trajectory. DERIVE is checked by re-executing the expression on the cited values. Both are deterministic and take milliseconds, in the spirit of the deterministic gate in Same Action, Different Justification. BIND goes to the specialized verifier. The commit rule is conservative: the call executes only if every argument passes. Otherwise it is held. The design borrows the idea of backward evidence tracing from VeriTrail. That work locates the generation step where a claim lost support in offline summarization pipelines. Our work moves the idea to live tool arguments and requires the tracing to be declared up front by the agent rather than reconstructed after the fact. The theoretical motivation comes from A Verifier Hierarchy, which shows that auxiliary certificate bits can sharply reduce verification cost.
The specialized verifier. We train a 7–8B model for the financial domain to adjudicate BIND claims. The task is to decide whether the cited span supports the specific entity, role, and value bound to the argument. This targets the role-swapping and fabricated-grounding errors catalogued in the hallucination literature. Training uses labels that come from execution rather than human annotation, because the environments are synthetic and we know the true argument values. We generate perturbed trajectories with several failure types: swapped entities, stale records, values missing from evidence, near-duplicate accounts, and empty documents. We then reward correct accept or reject decisions with Group Relative Policy Optimization (GRPO), the reinforcement-learning recipe that let an 8B model beat GPT-4o and DeepSeek-R1-0528 on Triton kernels in AutoTriton. Data filtering follows the rule-based consistency checking of InfCycle. That paper used such checking to clean tool-call training data, not to gate risky execution.
Recovery after a block. EffectGuard found that blocked agents recovered in only 8 of 50 tasks. A failed certificate names exactly which argument lacks support and why. We feed that diagnosis back to the agent as a targeted message, such as "recipient account has no source; ask the user or retrieve it," and measure whether recovery improves.
The benchmark extension. Existing benchmarks are adversarial (FinVault, AGENTBLASTBENCH) or have no side effects (ICT). We therefore build a non-adversarial "hallucination cascade" split on FinVault's state-writable financial environments and on the EffectGuard domains. The construction applies ICT-style perturbations: removing utterances, replacing tool outputs with empty or partial results, and inserting near-duplicate entities. These are applied to benign tasks that end in irreversible calls. We label each trajectory with ground-truth argument values and score realized harm with the Blast Radius Score (BRS), the damage measure from What Can One Bad Tool Call Destroy?. We also add a sixth family to the matched-pair benchmark of Same Action, Different Justification. In this family the two trials share an identical, authorized causal path and differ only in whether one argument is grounded or hallucinated.
Baselines
Naive reference points. The do-nothing baseline lets the agent commit every call it proposes. A second reference adds Causal Chain Authorization as published. By construction, CCA should score near chance on the new grounded-versus-hallucinated pair family, even though it reports 100% separation on families P1–P5 in Same Action, Different Justification. Running it confirms that the new family measures something different.
Frontier LLM judge. This is the strongest semantic competitor. A frontier model reads the full trajectory and the proposed call and decides whether to allow it. It is the obvious way to catch hallucinated content, and it has the most world knowledge. The weaknesses on record are a 0% separation score on scope and chain-verifiability pairs, an over-allow bias, and over 500 ms latency (Same Action, Different Justification). Those results concern authorization, not argument grounding, so this baseline is a genuine contender on our question. For a fair comparison it receives the same trajectories, the same model family used as our BIND fallback, and a prompt-tuning budget matched to our verifier's validation budget. We count it as beaten only if our gate achieves lower BRS-weighted unsafe commits at an equal or lower false-block rate on benign tasks.
Guardrail classifiers. We run LLaMA Guard 4 and GPT-OSS-Safeguard as configured in FinVault. They are the deployed off-the-shelf option. On FinVault's adversarial cases they reach TPR 61.10% at FPR 29.91% and TPR 22.07% at FPR 12.15% respectively (FinVault). We found no reported result on Lacuna for either classifier on non-adversarial hallucinated parameters.
Structured Verification. This is the five-step prompting checklist from Can Tool-augmented LLMs be Aware of Incomplete Conditions?, which raised Gemma-3-4B from 20.90% to 68.57% F1 on ToolBench API replacement, against a human baseline of about 81%. It is the strongest prior method aimed specifically at hallucinated arguments. We run it on the same agents, using the ddehun/ICT release unchanged. Beating it means higher F1 on ICT and lower unsafe-commit rate on our split.
Ablations. Four ablations isolate the key ingredients:
- Taint-only gate: COPY and DERIVE checks, with every BIND auto-allowed or auto-blocked.
- Certificate plus generalist judge: certificates with a generalist 7–8B model on BIND.
- Certificate plus frontier judge: certificates with a frontier judge on BIND.
- Verifier without certificates: the specialized verifier reading the whole trajectory.
All verifiers share one data budget and one compute budget.
Why not just…?
Why not just use deterministic taint tracking, requiring every irreversible argument to appear verbatim in the logs? This is the most serious threat, and we built the design around it rather than against it. For identifiers that are copied verbatim, taint tracking is probably enough, which is why COPY uses exactly this check. It fails in two ways. It cannot validate computed values such as amounts after fees and conversions, and it cannot catch a value that does appear in the logs but is bound to the wrong role, like the patient and donor swap. The taint-only ablation measures how much of the harm falls in these categories. If BIND errors turn out to be rare in realistic trajectories, the honest conclusion is that the specialized verifier is unnecessary and certificates plus taint checks suffice. That would still be a useful and simpler result.
Why not just ask a frontier model to judge each call? A frontier judge may well catch many semantic binding errors. The cited evidence of its weakness concerns authorization metadata that was missing from its input, not grounding (Same Action, Different Justification). Two experiments settle the question. The full-trajectory frontier judge is compared directly against our gate. The certificate-plus-frontier-judge ablation then tells us whether any advantage comes from the certificate or from the verifier. If the frontier judge matches us in accuracy, the remaining case for our method rests on latency and false-block rate, and we will report it that way.
Why not just prompt the agent to verify sufficiency before acting? Structured Verification is cheap and helps, but at 68.57% F1 it remains below humans (ICT). It also asks the same model that hallucinated to grade itself, and the awareness-action gap shows that models violate rules they can correctly recite (ANCHOR). Our gate is external and fails closed. We also test the combination, since certificates and checklists are compatible.
Why not just show the human an effect preview? EffectGuard-style previews catch scope drift. However, a human reviewing "transfer 4,180 to account …7731" cannot tell that the agent invented the account number. Static policies still let 420 of 574 broadened effects through (Approve the Effect). We run preview-only as a baseline on our split.
Proposed Experiments
The primary experiment runs Qwen- and Llama-class agents, plus one frontier agent, on the hallucination-cascade split built over FinVault and EffectGuard environments, under every gate described above. We report four quantities: the rate of irreversible commits with an incorrect argument, total realized harm by BRS, the false-block rate on FinVault's 107 benign cases and on our benign tasks, and median gate latency.
The decisive check for the main claim combines two conditions. On the grounded-versus-hallucinated pair family, CCA should sit near chance while our gate separates the pairs. At the same time, our gate must not raise false blocks on benign tasks above the frontier judge's rate.
The decisive check for the small-model question is a 2×2 design: verifier type (specialized versus generalist small model) crossed with input (certificate versus full trajectory). Suppose the specialized model is reliable only when given a certificate. That would support the view that the unstable self-evaluation reported in ARTIS comes from an overly broad question rather than from scale alone. If the specialized model fails even with certificates, the ARTIS reading stands.
The decisive check for recovery compares task completion after a block under three conditions: a bare "blocked" signal, an EffectGuard-style signal, and our argument-level diagnosis. The bar is the 8/50 baseline reported in Approve the Effect.
For external validity we rerun the hallucination-related cases from the Clawdbot audit with the gate in place. We also run the unchanged ICT benchmark, to make sure the verifier does not overfit to synthetic financial perturbations.
References
- Same Action, Different Justification: Path-Based Authorization for Irreversible Agent Actions
- ShieldAgent: Shielding Agents via Verifiable Safety Policy Reasoning
- Approve the Effect, Not the Tool Call: Preventing Stale Consent in Tool-Using Agents
- A Trajectory-Based Safety Audit of Clawdbot (OpenClaw)
- VeriTrail: Closed-Domain Hallucination Detection with Traceability
- A Verifier Hierarchy
- AUTOTRITON: Automatic Triton Programming with Reinforcement Learning in LLMs
- Tool learning via Inference-time Scaling and Cycle Verifier
- FinVault: Benchmarking Financial Agent Safety in Execution-Grounded Environments
- What Can One Bad Tool Call Destroy? Measuring and Minimizing Blast Radius in Agentic Tool Use
- Can Tool-augmented Large Language Models be Aware of Incomplete Conditions?
- ANCHOR: Automated Alignment Auditing for CLI Agents on Real-World Harm
- ARTIS: Agentic Risk-Aware Test-Time Scaling via Iterative Simulation