Look Before You Leap: Pre-Action Verification for LLM Agents

# Pre-Action Verification for LLM Agents
Source: [https://arxiv.org/html/2609.11957](https://arxiv.org/html/2609.11957)
## Look Before You Leap: Pre\-Action Verification for LLM Agents

###### Abstract

An LLM agent acts on the world by emitting actions: shell commands to run, edits to apply\. A wrong action does not always fail loudly; it can fail silently, producing a plausible but incorrect effect that raises no error\. We argue that a cheap deterministic check, run before an action takes effect, is an effective and underused form of agent oversight, and we study it across two action modalities in one framework\. The idea is to fix an action’s correct effect by construction, before any executor runs, so that silent failure is measured directly and the verifier may abstain rather than guess\. For shell commands, a static verifier over 9,930 commands and 482 tools catches 95\.8% of invalid commands at a 10\.0% false\-positive rate\. Its syntax and binary checks are oracle\-exact, giving zero false positives while catching half of all errors; the flag check is bounded only by help\-text coverage and accounts for every false positive\. For code edits, a benchmark of 640 edits over 224 files isolating the apply step exposes a sharp split\. Content\-anchored formats such as search/replace and diff fail cleanly, whereas location\-anchored formats fail silently: line numbers corrupt 99\.1% of files under a one\-line shift, and function\-name edits hit the wrong function 12\.7% of the time\. In both settings a refuse\-when\-unsure policy turns silent failures into recoverable ones at a tunable cost in applicability: selective grounding reaches 0\.958 recall at 7\.0% false positives, and an anchor\-and\-verify applier records one silent misapplication in 8,320 trials \(0\.01%\)\. We release both benchmarks, the verifiers, and the guards\.

Code—Will\-be\-released\.

Datasets—Will\-be\-released\.

## 1Introduction

Language\-model agents increasingly take consequential actions\. They run shell commands in a terminal and apply edits to source files\(Jimenezet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib1); Yanget al\.[2024](https://arxiv.org/html/2609.11957#bib.bib13); Wanget al\.[2025](https://arxiv.org/html/2609.11957#bib.bib14); Xieet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib3)\)\. Unlike a chat response, an action changes state, and a wrong action need not announce itself\. A command with a hallucinated flag may error out, but it may instead do something subtly different from what was intended\. An edit aimed at the wrong location may fail to apply, or it may apply cleanly to the wrong place and corrupt the file with no error at all\. We call the second case a*silent failure*: the action appears to succeed, so neither the agent nor a downstream check is alerted, and the error propagates into later steps\. When agents act over long, unattended trajectories, one silent action early on can quietly invalidate everything after it, and so the reliability of individual actions underpins the trustworthiness of the whole\.

These cases are concrete\. An agent that emitstar \-xf archive\.tgz\(omittingz\), or that passes a flag the installed version does not support, gets an error message it can read and recover from\. An agent that expresses an edit as “replace lines 40–52” against a file that has since shifted by one line overwrites the wrong twelve lines and reports success, and the corruption surfaces only much later, if at all\. The first failure is loud and recoverable; the second is silent and damaging\. The difference is not luck\. It follows from how the action is represented\.

Silent failure is an oversight problem\. A model cannot reliably catch its own mistakes by introspection, and post\-hoc repair\(Madaanet al\.[2023](https://arxiv.org/html/2609.11957#bib.bib10); Olaussonet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib20)\)triggers only once an error is observed, which a silent failure by definition is not\. We study a complementary mechanism: a cheap deterministic check placed before the action takes effect, which either admits the action or refuses it and hands back a recoverable signal\. This is oversight by construction rather than by a second, fallible model call\. It is model\-agnostic, it costs no inference, and it is the kind of safe\-by\-design, empirically evaluated guard that deployed agents need\.

One methodological move makes the problem measurable, applied to two action modalities\. For each action we fix the correct effect by construction, before any executor or applier runs\. Every trial then falls into one of three classes: asuccess, where the effect matches the target; aclean failure, where the action is refused or does not apply and the agent can recover; or asilent failure, where the action takes effect at the wrong target and no signal is raised\. Because the verifier may also abstain, we trace a safety/applicability frontier rather than a single point\. The same structure governs both modalities: a cheap check, an oracle\-exact core, and the freedom to abstain, pointing to a general recipe for action\-level oversight\. To our knowledge, this is the first work to measure silent action failure under a construction that fixes ground truth before execution, and across two distinct agent modalities under one taxonomy\.

### Contributions\.

\(1\) A common framework for*pre\-action verification*: construction\-defined ground truth, a success / clean\-failure / silent\-failure taxonomy, and abstention\-based operating points \(Sec\.[2](https://arxiv.org/html/2609.11957#S2)\)\. \(2\) For*shell commands*, a benchmark of 9,930 commands over 482 real tools with an anti\-circular construction, and a static verifier whose error decomposition cleanly separates an oracle\-exact, zero\-false\-positive core from a coverage\-bounded flag check \(Sec\.[3](https://arxiv.org/html/2609.11957#S3)\)\. \(3\) For*code edits*, a benchmark of 640 edits over 224 files isolating the apply step, revealing a sharp content\- vs\. location\-anchored safety dichotomy and a silent\-failure mode that ordinary error handling misses \(Sec\.[4](https://arxiv.org/html/2609.11957#S4)\)\. \(4\) Two deployable guards, selective grounding with a two\-tier gate and Robust\-Apply \(an anchor\-and\-verify meta\-applier\), that drive silent failure toward zero at a tunable cost, together with a cross\-domain synthesis showing that one structure underlies both \(Sec\.[5](https://arxiv.org/html/2609.11957#S5)\)\.

### Relevance to AI Alignment\.

This is an*empirical robustness evaluation*of LLM\-agent actions and a*safe\-by\-design*oversight mechanism: it quantifies a silent failure mode that ordinary error handling misses, isolates exactly where errors and false alarms originate, and supplies cheap guards that convert unrecoverable silent errors into recoverable clean failures\. Both studies release open benchmarks, reproducible code, and practical evaluation tools, which the track explicitly encourages\.

## 2Pre\-Action Verification: A Common Framework

An agent emits an actionaaintended to produce an effect on a statess\. The intended effect defines a targetTT\. A deterministic verifierVVinspectsaa\(andss\) before execution and either admits or refuses it\. If the action is admitted, an executor produces a realized effectRR\.

### Construction\-defined ground truth\.

The central design choice is thatTTis fixed*before*any executor runs\. For commands, validity is established by behavioral oracles that are independent of the verifier; for edits, the post\-edit file is synthesized directly, then rendered into a format and perturbed\. BecauseTTis known independently, every trial has a well\-defined outcome:

- •Success:RRrealizesTT\.
- •Clean failure: the action is refused or does not take effect\.*Recoverable*: the agent is told and can retry or repair\.
- •Silent failure: the action takes effect butR≠TR\\neq T\.*Dangerous*: no signal is raised, so no recovery is triggered\.

This taxonomy separates a true detection from a guess, and it makes safety and applicability independent axes\. A verifier that refuses everything is trivially safe but useless; one that admits everything maximizes applicability but prevents nothing\. What we study is the frontier between these extremes\. Because silent failure is defined against a known target rather than inferred from a downstream symptom, a single scalar, the silent rate among admitted actions, captures the safety\-relevant axis directly\. That is what lets the two modalities be compared on the same footing\.

### Abstention and operating points\.

A verifier need not rule on every action\. When the evidence is ambiguous it may abstain, admitting without a strong claim, or in a deployed gate raise a non\-blocking warning\. Sweeping the abstention rule traces a curve in \(applicability, safety\) space, and we report operating points along it\. Each thresholdθ\\thetainduces a point\(app​\(θ\),safe​\(θ\)\)\(\\mathrm\{app\}\(\\theta\),\\,\\mathrm\{safe\}\(\\theta\)\), where applicability is the fraction of actions admitted and correct and safety is one minus the silent rate among admitted actions; the deployed guard maximizes applicability subject to a safety floor\. The same structure recurs in both modalities\. The cheap checks split into an oracle\-exact part, definitively wrong when it fails and so yielding zero false positives, and a coverage\- or guess\-bounded part, a comparison against an imperfect reference that buys the remaining applicability and is where every false positive originates\. Separating the two lets a deployment dial safety against applicability deliberately rather than accept one conflated number\.

### A worked example\.

Take the commandgrep \-rn \-\-colour pat \.The verifier resolvesgrep\(binary check\), confirms that it parses \(bash \-n\), and tests each option againstgrep’s extracted flag set\. Here\-\-colouris a genuine British\-spelled alias that the parser may not have captured\. A naive flag check would reject this valid command, giving a false positive, while an abstaining check withholds judgment and lets it through\. An edit shows the same pattern\. “Insert after line 12” carries no content to validate against, so a stale line number applies silently\. The same change written as a search/replace block carries its surrounding anchor, so a stale anchor simply fails to match and yields a recoverable clean failure\. In both modalities it is the representation, not the model, that decides whether a mistake can be caught before it lands\.

### Why before, not after\.

Post\-hoc checks such as tests, a reviewing model, or a human in the loop are valuable but expensive, and they are blind to silent failure: a test passes if it does not cover the corrupted region, a reviewing model may miss a subtly wrong edit, and a human cannot audit every action of a fast agent\. A pre\-action check sidesteps this by refusing to let an unverifiable action take effect at all\. The cost is occasional over\-refusal of valid actions, which is recoverable, and in exchange the unrecoverable case is eliminated\. Trading recoverable false alarms for the prevention of silent corruption is the design stance both guards share\.

### Threat model and scope\.

The verifier sees the action text and the local environment \(installed tools, the current file\)\. It does not see the model’s intent and does not judge whether the intended change is correct, only whether the action as written can be realized validly and unambiguously\. It is an oversight layer on action execution, separate from and composable with checks on action selection\. We assume a non\-adversarial environment \(a buggy or hallucinating agent, not a malicious one\) and a faithful executor; the guard targets unintended failure, not an agent that games the check or an executor that bypasses it, which call for a sandbox\. Under these assumptions, the only way an error reaches the state is through an admitted action whose realized effect differs from its target, exactly the silent\-failure case the framework exposes\.

## 3Grounding Shell Commands

### Benchmark\.

We build 9,930 commands over 482 installed tools\. The valid commands \(n=1,986n\{=\}1\{,\}986\) are drawn from the human\-curatedtldrcorpus\(tldr\-pages contributors[2026](https://arxiv.org/html/2609.11957#bib.bib12)\)\. The invalid commands,1,9861\{,\}986in each of four categories, are produced by mutation and confirmed invalid by behavioral oracles independent of the verifier: a nonexistent binary \(resolved bywhich\), malformed syntax \(rejected bybash \-n\), an invalid long option, and an invalid short option \(both absent from a flag set extracted from\-\-help,\-h, andman\)\. This anti\-circular construction keeps the verifier from being graded against its own assumptions: a benchmark generated by the rules the verifier checks would measure self\-consistency, not detection, so our oracles act as independent witnesses of \(in\)validity\. The construction funnel is explicit\. Of 6,474tldrtool pages, 546 tools are installed; parsing yields 2,160 candidate commands, or 2,145 once every pipeline stage must resolve, capped per tool to a final 1,986\.

### Verifier\.

The verifier runs three checks: syntax \(bash \-non the command string\), binary existence \(which\), and flag validity \(membership in the extracted flag set\)\. It is subcommand\-aware, so thatgit commitflags are treated separately fromgitflags\. When a tool yields no extractable flags, the verifier abstains and admits the command, so flag recall is bounded by extraction coverage \(91\.1% of tools yield a non\-empty set\); we never guess against an empty reference\. Each check is a pure function of the command and the environment\.bash \-nis the shell’s own parser,whichconsults the livePATH, and the flag set is built once per tool by parsing\-\-help,\-h, andmaninto long and short options\. Because the verifier inherits the shell’s notion of well\-formedness rather than re\-implementing it, its structural checks are exact rather than heuristic\.

### Results\.

The full configuration detects95\.8%of invalid commands at a10\.0%false\-positive rate \(P=0\.975P\{=\}0\.975,F1=0\.966F\_\{1\}\{=\}0\.966\)\. The estimates are stable under a tool\-clustered bootstrap \(95% CIs: recall\[0\.944,0\.971\]\[0\.944,0\.971\], FPR\[0\.078,0\.122\]\[0\.078,0\.122\],B=2000B\{=\}2000over 482 tool clusters\), and the verifier is cheap: a warm median of 2\.55 ms per command \(p95 2\.78 ms, p99 3\.05 ms\), with a one\-time cold cost dominated by flag extraction \(p95 2\.85 s, cached thereafter\)\. The decomposition is the scientific point \(Table[1](https://arxiv.org/html/2609.11957#S3.T1)\)\. The syntax and binary checks are oracle\-exact:bash \-nandwhichtest exactly the property that defines a malformed or unknown\-binary command, so they cannot reject a valid command \(zerofalse positives\) yet still catch half of all errors \(recall0\.5000\.500\)\. The binary\-only check is the naive “doescommand \-vresolve?” baseline \(recall0\.2550\.255\)\. The flag check supplies the rest of the recall and accounts for every false positive: all 198 are flags the tool accepts but our parser failed to extract, falling into three token classes \(48\.5% single\-dash single\-character, 29\.8% single\-dash multi\-character, 21\.7% double\-dash\) and spread thinly over 95 tools, at most 8 for any one\. False positives are a property of help\-text quality, not of the model or of the idea of grounding\. By category, the oracle\-exact checks catch nonexistent\-binary and malformed\-syntax errors perfectly \(recall1\.0001\.000each\), while invalid long and short flags are caught at0\.9160\.916and0\.9160\.916, bounded by the91\.1%91\.1\\%flag\-extraction coverage rather than by the method \(Table[3](https://arxiv.org/html/2609.11957#S3.T3)\)\.

Table 1:Shell\-command verifier: configurations and key ablations \(N=9,930N\{=\}9\{,\}930\)\. FPR is on the 1,986 valid commands\. Syntax\+binary form an oracle\-exact, zero\-FP core; the flag check is the only source of false positives\.
### Selective grounding and a two\-tier gate\.

Every false positive is an extraction gap, and the most ambiguous token is the single\-dash multi\-character option, a BSD\-style cluster that may or may not be a real flag, so we abstain on exactly those tokens\. This is lossless by construction: none of the injected invalid errors is a single\-dash multi\-character token, so abstaining can only remove false positives\. It also Pareto\-dominates the naive policy, giving the same0\.958recall at7\.0%false positives rather than 10\.0% \(Figure[1](https://arxiv.org/html/2609.11957#S3.F1)\)\. Deployed as a gate, the oracle\-exact checks block \(recall0\.5000\.500at0%0\\%false positives\), while flag suspicions become non\-blocking warnings \(a 7\.0% warn\-rate on valid commands\)\. A wrong block is then impossible, and the agent always receives a recoverable signal it can act on\.

### Where the false alarms live\.

Table[2](https://arxiv.org/html/2609.11957#S3.T2)breaks the 198 false positives down by token class\. Selective grounding abstains on the single\-dash multi\-character class, which is 29\.8% of false positives and the BSD\-style cluster whose flag membership is genuinely ambiguous from help text\. That is why abstaining removes three points of false\-positive rate, from 10\.0% to 7\.0%, at no cost in recall\. The remaining false positives are extraction gaps that a richer help\-text parser or a per\-tool completion spec would close\. None reflects a limitation of grounding itself, and all are confined to 95 of 482 tools, at most 8 for any one\.

Table 2:False\-positive composition: all 198 are real flags missed by extraction\. Selective grounding abstains on the ambiguous single\-dash multi\-character class\.Table 3:Recall by error category\. Oracle\-exact checks \(binary, syntax\) catch structural errors perfectly; flag errors are caught at rates bounded by help\-text extraction coverage, not by the method\.![Refer to caption](https://arxiv.org/html/2609.11957v1/x1.png)Figure 1:Recall vs\. false\-positive trade\-off for the shell\-command verifier\. Syntax and binary checks anchor a zero\-false\-positive floor \(catching half of all errors\); the flag check is the only dial\. Selective grounding \(ours\) moves the operating point left, giving lower false positives at equal recall, and Pareto\-dominates the naive full configuration\.

## 4Applying Code Edits

### Benchmark\.

We isolate the apply step, which is logically distinct from generating the right change\. We take 640 edits over 224 real Python files\. Each edit’s post\-edit target is synthesized first, then rendered into one of four formats and perturbed only on its location surface\. Because the target is fixed before any applier runs, correctness does not depend on the applier and silent misapplication is directly observable\. This inverts the usual setup\. Instead of asking whether an applier reproduces an unknown intended file, we define the intended file and ask only whether the applier reaches it, so a wrong location is unambiguously a silent failure rather than a disagreement about intent\. The formats are search/replace \(exact, whitespace\-normalized, and fuzzy at thresholdτ\\tau\), unified diff \(real GNUpatch\(Free Software Foundation[2018](https://arxiv.org/html/2609.11957#bib.bib19)\)at fuzz factors 0 and 2\), line ranges, and whole\-function\-by\-name\. The perturbations include reindentation and line shifts, giving23,04023\{,\}040trials\.

### Formats and perturbations\.

The four formats span how agents address a change\. Search/replace quotes the code to be changed \(content\-anchored\); unified diff quotes context lines around it \(content\-anchored, validated independently bypatch\); line ranges name positions and whole\-function edits name the function \(both location\-anchored\)\. The perturbations model realistic drift between when an agent reads a file and when its edit lands: reindentation, which changes whitespace but leaves content intact, and line shifts, which insert or delete lines above the target\. A safe applier fails cleanly under drift it cannot resolve; a dangerous one applies anyway, to the wrong place\.

### A safety dichotomy\.

The formats split cleanly \(Table[4](https://arxiv.org/html/2609.11957#S4.T4), Figure[2](https://arxiv.org/html/2609.11957#S4.F2)\)\. Content\-anchored formats locate the edit by the surrounding code and fail cleanly when they cannot match: search/replace and unified diff never misapply silently \(0\.000\), trading applicability for safety as matching loosens \(SR\-fuzzy stress success0\.9770\.977, cluster CI\[0\.972,0\.981\]\[0\.972,0\.981\]\)\. Location\-anchored formats locate by position or name and fail silently: a one\-line shift leaves line ranges applying nothing correctly whilesilently corrupting 99\.1%of files, and whole\-function edits hit the wrong same\-named function12\.7%of the time even unperturbed, from duplicate\-name collisions\. The heatmap \(Figure[3](https://arxiv.org/html/2609.11957#S4.F3)\) shows the effect is uniform across perturbations, not an artifact of one operator\.

![Refer to caption](https://arxiv.org/html/2609.11957v1/x2.png)Figure 2:Applicability vs\. safety for edit formats\. Content\-anchored formats occupy the safe floor \(never silent\), trading applicability for safety as matching loosens; location\-anchored formats are pushed up into the dangerous region\. Whole\-function is shown at its clean operating point\.†Whole\-function silent failure occurs*unperturbed*, from duplicate\-name collisions; unified diff uses real GNUpatch\.

Table 4:Edit\-application outcomes by format\. “Clean” = no perturbation; “Stress” pools applicable perturbations\. Lower silent is safer; content\-anchored formats are silent\-free\.
### Safety is format and policy\.

A zero silent rate is a property of the applier policy as much as of the format\. Re\-running the content\-anchored conditions with a permissive first\-match policy raises silent misapplication from0\.0000\.000to0\.0200\.020\(exact\) and0\.0230\.023\(whitespace\-normalized\)\. The format still dominates: content\-anchored silent rates stay near 2% even when permissive, against 99% for line numbers\. But reaching zero requires a refuse\-ambiguous policy\. A benchmark that reports only one of format or policy conflates the two\.

### Multi\-hunk and generalization\.

Fuzzy matching is a tunable dial\. It is safe on single edits \(2\.3% silent\) but dangerous on multi\-hunk edits, where shrinking per\-hunk anchors push its silent rate to39%\. It also never abstains there \(clean\-failure rate0\.0000\.000\), so every wrong location is silent rather than recoverable\. Unified diff is unaffected, because each hunk carries its own context andpatchvalidates that context independently\. The dichotomy and the rates replicate on a third\-party codebase, 55 edits from therequestslibrary: SR\-fuzzy’s silent rate is0\.0250\.025\(against0\.0230\.023on the standard library\) and line ranges stay catastrophic \(1\.0001\.000silent\), which indicates that the effect is intrinsic to the formats rather than to one corpus\. Unified diff is the robust outlier\. At fuzz 0 it demands exact context, and at fuzz 2 it tolerates small drift, but in neither case does it commit without matching context, so it stays silent\-free even across two hunks\. The cost is the lowest applicability among content\-anchored formats under heavy reindentation\.

Table 5:Multi\-hunk edits: fuzzy matching’s silent rate compounds as per\-hunk anchors shrink, while exact, whitespace\-normalized, and diff matching stay safe and line ranges remain catastrophic\.
### Robust\-Apply\.

The remedy mirrors selective grounding: verify, and refuse when unsure \(Algorithm[1](https://arxiv.org/html/2609.11957#alg1)\)\. Robust\-Apply is a format\-agnostic meta\-applier\. It requires a minimum anchor sizeKminK\_\{\\min\}, refuses ambiguous matches, and accepts a fuzzy match only when it clears a similarity floorτh​i\\tau\_\{hi\}and beats the runner\-up by a marginδ\\delta, committing through realpatch\. With\(Kmin,τh​i,δ\)=\(2,0\.90,0\.20\)\(K\_\{\\min\},\\tau\_\{hi\},\\delta\)\{=\}\(2,0\.90,0\.20\)it recordsonesilent misapplication in8,320trials \(0\.01%0\.01\\%\), across every format, every perturbation, the multi\-hunk edits, and the third\-party codebase, against native rates as high as99\.1%99\.1\\%\. On the trials where aggressive fuzzy misapplies silently, it converts100%to recoverable clean failures while preserving 60% of the applies that fuzzy achieved, and it is lossless on clean content\-anchored edits\. The price is applicability \(0\.510\.51against0\.980\.98on perturbed single\-hunk edits\), an explicit and tunable trade\. The result is not knife\-edge\. Across the swept rangeτh​i∈\[0\.85,0\.95\]\\tau\_\{hi\}\\in\[0\.85,0\.95\]andδ∈\[0\.10,0\.30\]\\delta\\in\[0\.10,0\.30\], the silent rate stays at or below0\.05%0\.05\\%while applicability varies smoothly, so the operating point can be tuned to a deployment’s tolerance without re\-introducing silent failure\. The one silent case among the 8,320 trials occurred under unified\-diff stress, where GNUpatchcommitted a hunk at a shifted location at nonzero fuzz \(rate0\.00050\.0005\); constraining the fuzz factor removes it, so even the residual risk is a tunable knob rather than a floor\.

Algorithm 1Robust\-Apply \(anchor\-and\-verify\)Input: fileFF; edit with anchorAA, replacement; paramsKmin,τh​i,δK\_\{\\min\},\\tau\_\{hi\},\\delta Output: edited file, orClean\-Fail\(recoverable\)

1:if

\|A\|<Kmin\|A\|<K\_\{\\min\}then

2:returnClean\-Fail\{anchor too small to trust\}

3:endif

4:try exact, then whitespace\-normalized match of

AAin

FF
5:ifa*unique*such match

mmexiststhen

6:returnapply replacement at

mm
7:endif

8:

\(m1,s1\),\(m2,s2\)←\(m\_\{1\},s\_\{1\}\),\(m\_\{2\},s\_\{2\}\)\\leftarrowtop\-2 fuzzy matches by similarity

9:if

s1≥τh​is\_\{1\}\\geq\\tau\_\{hi\}and

s1−s2≥δs\_\{1\}\-s\_\{2\}\\geq\\deltathen

10:returnapply at

m1m\_\{1\}viapatch

11:endif

12:returnClean\-Fail\{ambiguous; refuse rather than guess\}

![Refer to caption](https://arxiv.org/html/2609.11957v1/x3.png)Figure 3:Silent\-misapplication rate by format \(rows\) and perturbation \(columns\)\. Content\-anchored formats stay at the safe floor across all perturbations; location\-anchored formats light up: line ranges under shifts, and whole\-function from name collisions even with no perturbation\.
### Which operating point to use\.

The choice is a deployment decision\. Aggressive fuzzy is the right pick when applicability is paramount and a downstream check \(tests, review, or self\-repair\) will catch a wrong edit; its2\.3%2\.3\\%single\-hunk silent rate is then a cost the check recovers\. Robust\-Apply is preferable when a silent wrong edit is unacceptable, or when no reliable downstream check exists\. Exact or whitespace\-normalized matching is the simplest zero\-tuning safe default\. The one combination to avoid is aggressive fuzzy with no downstream check, where silent corruption accumulates unobserved\.

## 5Cross\-Domain Synthesis

The two studies are instances of one structure \(Table[6](https://arxiv.org/html/2609.11957#S5.T6)\)\. In each, a cheap deterministic check before the action takes effect, together with the freedom to abstain, converts silent failures into recoverable clean failures at a tunable cost in applicability\. In each, the checks split into an oracle\-exact part that gives a zero\-false\-positive safety floor \(syntax and binary for commands, exact and whitespace\-normalized matching for edits\) and a coverage\- or guess\-bounded part that buys the remaining applicability and is the only source of error \(flag extraction, fuzzy matching\)\. And in each, the dangerous representations are exactly those that cannot be validated against content: a flag absent from any reference, or a line number or function name with no surrounding anchor\. Such representations cannot tell a right target from a wrong one, and so they fail silently\.

Table 6:One structure, two modalities\. A cheap check with an oracle\-exact core and the option to abstain converts silent failures into recoverable ones in both settings\.For agent oversight, this suggests a concrete and model\-agnostic principle\. Prefer action representations that can be checked against content, gate them with an oracle\-exact blocker together with an abstaining soft check, and treat applicability as a dial set by how much recoverable failure a deployment can tolerate\.

### Beyond two modalities\.

The recipe extends to other agent actions with a checkable surface\. A file operation can confirm a path exists and is writable before acting; an API call can validate its arguments against a schema and refuse on ambiguity; a staged database write can be checked against a constraint before commit\. The design question is always the same: is there an oracle\-exact property that is definitively wrong when violated, and a content anchor the action can be matched against? Where both exist, a cheap pre\-action guard applies; where neither does, the action interface itself is what to reconsider\. A small library exposing the success / clean\-failure / silent\-failure contract and anabstainprimitive, into which per\-modality verifiers plug, would turn this into reusable infrastructure\. Because the guards cost microseconds to milliseconds and no model call, they work as always\-on wrappers around frontier agents whose internals are fixed or unavailable, complementing scalable\-oversight methods that operate on the model itself\.

Two properties make this appealing as oversight\. First, the guard’s failures are recoverable by design: a refused action returns a clean signal the agent can retry or repair, so a false alarm costs a wasted step rather than a corrupted state\. Second, the guard is auditable: its decisions are deterministic functions of the action and the environment, not opaque model judgments, so a reviewer can see exactly why an action was blocked or warned\. A learned critic would add inference cost, latency, and a fresh opportunity for silent error; a deterministic pre\-action check adds none of these, and it can wrap a learned proposer as the final, verified commit step\. This is a small but concrete instance of safe\-by\-design engineering: the safety property, no silent misapplication, is established by construction and measured rather than hoped for\. The oracle\-exact core admits a small provable guarantee:bash \-n,which, and exact matching decide the property that defines \(in\)validity, so the zero\-false\-positive floor holds by construction\. This is short of a full formal safety case, since the soft checks remain empirical, but it is a verified core beneath the abstaining layer; we state the guarantees precisely as three propositions in the supplementary material\.

### Where the principle stops\.

Pre\-action verification addresses whether an action can be realized validly and unambiguously, not whether it is semantically right: a valid command with a harmful effect, or an edit applied to the right place but encoding a logic error, lies outside its reach\. The guards also presume a checkable structure; an action with no content to anchor against, such as a raw byte offset or an opaque handle, cannot be grounded and is better discouraged at the interface\. Our contribution is to make the realizability layer safe and cheap, freeing more expensive oversight \(tests, review, learned critics\) to concentrate on semantic correctness\. The clearest extension is to measure these guards in the loop: running several frontier agents over real trajectories to estimate how often the silent cases we construct actually arise and how much the guards lift end\-to\-end reliability, which our single\-model probes only begin to provide\.

### Versus other guards\.

Two common alternatives are worth comparing against: sandboxing the executor and rolling back on error, and asking a second model to review each action\. Pre\-action verification is cheaper than the sandbox, needing no snapshot or rollback machinery and catching the silent case a rollback never triggers on, and more predictable than the reviewer, adding no inference and no fresh hallucination\. It is also narrower, guarding realizability rather than semantics\. The three are complementary, and the cheapest, most auditable layer, ours, is the natural first line\. Rollback in particular cannot catch a silent failure, since it fires only on an observed error and a silent misapplication raises none; differential testing or a second\-model reviewer then supplies the semantic check verification omits\. Combining them is defense in depth, each layer covering a class of error the others miss\.

### Deployment cost\.

Both guards run inline on every action with no model call, GPU, or network\. The command verifier adds a median of 2\.55 ms once a tool’s flags are cached, apart from a one\-time cold extraction, and Robust\-Apply is dominated by a single similarity scan\. On abstention, each returns a structured signal the agent can act on, such as the suspected flag or the ambiguous match and its runner\-up, rather than a bare rejection\.

## 6Threats to Validity

Construct\.The invalid commands and perturbed edits are synthetic, confirmed by oracles or fixed by construction\. They need not match the distribution of real model errors, though the failure mechanisms, extraction gaps and location drift, are intrinsic to the representations\. The zero\-false\-positive claim for syntax and binary checks is exact on complete commands but carries deployment caveats:bash \-nrejects incomplete fragments, andwhichmisses aliases, shell functions, and a session\-updatedPATH\. A deployed gate should treat these cases as abstentions\.External\.We probe real model output only lightly \(42 commands and 9 edits from an Anthropic Claude model, specific version not recorded, all valid\), so this evidence bears on the false\-positive side and does not estimate recall against a real error distribution\. A multi\-model study over agent trajectories is the key next step\. The results come from one Linux host with Python and shell tooling, and exact rates need not transfer to other languages, larger functions, or non\-function code, even where the qualitative dichotomies should hold\.Internal\.Latency is the only non\-deterministic measurement; every detection metric is deterministic given the committed snapshots and fixed seeds\. Extended results \(per\-category recall, the fullτ\\tauand line\-shift sweeps, the multi\-hunk and format\-versus\-policy tables, cluster intervals, and the agent traces\) are in the supplementary material\.

## 7Related Work

Agent benchmarks measure end\-to\-end task success\(Jimenezet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib1); Liuet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib4); Yanget al\.[2023](https://arxiv.org/html/2609.11957#bib.bib2); Xieet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib3)\)but rarely isolate why an action fails; we target the action\-validity and apply steps directly, with construction\-defined ground truth that makes silent failure observable\. Tool\- and API\-use work studies whether models select and call the right function\(Patilet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib5); Qinet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib6); Schicket al\.[2023](https://arxiv.org/html/2609.11957#bib.bib7); Yaoet al\.[2022](https://arxiv.org/html/2609.11957#bib.bib8)\), and NL\-to\-command generation whether they produce correct flags and structure\(Linet al\.[2018](https://arxiv.org/html/2609.11957#bib.bib9)\); we reuse that difficulty as a verification signal rather than a generation target\. Self\-refinement and self\-repair correct outputs after an error is observed\(Madaanet al\.[2023](https://arxiv.org/html/2609.11957#bib.bib10); Olaussonet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib20)\); pre\-action verification is complementary, cheaper, and addresses the silent case no observation would flag\. General shell linters such as ShellCheck target script\-level correctness rather than flag validity against the installed tool, and completion frameworks such as argcomplete operate at the prompt rather than as an agent gate; neither grounds a command before execution\. Edit formats are a practical concern across coding\-agent toolchains\(Gauthier[2024](https://arxiv.org/html/2609.11957#bib.bib15); Xiaet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib16); Yanget al\.[2024](https://arxiv.org/html/2609.11957#bib.bib13); Wanget al\.[2025](https://arxiv.org/html/2609.11957#bib.bib14)\), where matching builds on standard diff and similarity methods\(Myers[1986](https://arxiv.org/html/2609.11957#bib.bib17); Ratcliff and Metzener[1988](https://arxiv.org/html/2609.11957#bib.bib18); Free Software Foundation[2018](https://arxiv.org/html/2609.11957#bib.bib19)\); we give the first controlled measurement of their silent misapplication\. Execution\-safety work sandboxes or gates agent actions to contain damage\(Yanget al\.[2023](https://arxiv.org/html/2609.11957#bib.bib2); Xieet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib3)\); our gate acts earlier, refusing an ill\-formed action before any effect rather than containing its aftermath\. Closest in spirit is work that verifies or tests generated artifacts before use\(Olaussonet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib20); Xiaet al\.[2024](https://arxiv.org/html/2609.11957#bib.bib16)\), but that line typically runs the artifact and inspects the result, whereas we verify realizability statically, which is what makes the silent case observable and preventable\. Our success / clean\-failure / silent\-failure taxonomy is deliberately operational, keyed to agent recoverability rather than a general bug taxonomy, which lets a single number, the silent rate, capture the safety\-relevant axis\. More broadly, ours is a narrow, deterministic instance of the scalable\-oversight goal of keeping agent behaviour checkable as capability grows\(Amodeiet al\.[2016](https://arxiv.org/html/2609.11957#bib.bib21); Bowmanet al\.[2022](https://arxiv.org/html/2609.11957#bib.bib23); Irvinget al\.[2018](https://arxiv.org/html/2609.11957#bib.bib22)\), and it complements formal verification of learned components such as SMT\-based neural\-network checking\(Katzet al\.[2017](https://arxiv.org/html/2609.11957#bib.bib24)\): we verify an action’s realizability against the environment, not properties of the model\. Confidence intervals use the method ofWilson \([1927](https://arxiv.org/html/2609.11957#bib.bib11)\)\.

## 8Conclusion

A wrong agent action that fails silently is an oversight failure that ordinary error handling misses\. Studying shell commands and code edits, we found that fixing an action’s correct effect by construction turns silent failure from an inferred symptom into a measured quantity\. With that in place a consistent picture emerges: the cheap checks separate into an oracle\-exact core that raises no false alarm and a softer, coverage\-bounded remainder that carries all the error, and a representation is safe exactly when the action can be checked against its content\. The resulting guards are model\-agnostic, run in microseconds to milliseconds, and ship with the benchmarks, so they can sit in front of a deployed agent as it acts\. The wider lesson is about interface design: an action checkable against content can be made safe cheaply, while one that cannot leaves a silent failure that no downstream test, review, or repair fully recovers\. That is the case for building agent interfaces around checkable actions from the start, and the reason we expect the construction\-defined method to reach well beyond the two modalities studied here\.

## Ethical Statement

This work is defensive\. The guards prevent silent corruption of files and unintended command execution, and their failure mode, a refused action, wastes a step rather than damaging state\. The benchmarks use only public tools and source code, with no human subjects or personal data\. The dual\-use surface is small: knowing that line\-number edits misapply silently helps a defender choose safe formats far more than it helps an attacker, so releasing the benchmarks, guards, and findings improves agent safety more than it aids misuse\.

## References

- D\. Amodei, C\. Olah, J\. Steinhardt, P\. F\. Christiano, J\. Schulman, and D\. Mané \(2016\)Concrete problems in ai safety\.ArXivabs/1606\.06565\.External Links:[Link](https://api.semanticscholar.org/CorpusID:10242377)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- S\. Bowman, J\. Hyun, E\. Perez, E\. Chen, C\. Pettit, S\. Heiner, K\. Lukosiute, A\. Askell, A\. Jones, A\. Chen, A\. Goldie, A\. Mirhoseini, C\. McKinnon, C\. Olah, D\. Amodei, D\. Amodei, D\. Drain, D\. Li, E\. Tran\-Johnson, J\. Kernion, J\. Kerr, J\. Mueller, J\. Ladish, J\. D\. Landau, K\. Ndousse, L\. Lovitt, N\. Elhage, N\. Schiefer, N\. Joseph, N\. Mercado, N\. Dassarma, R\. Larson, S\. McCandlish, S\. Kundu, S\. Johnston, S\. Kravec, S\. E\. Showk, S\. Fort, T\. Telleen\-Lawton, T\. B\. Brown, T\. Henighan, T\. Hume, Y\. Bai, Z\. Hatfield\-Dodds, B\. Mann, and J\. Kaplan \(2022\)Measuring progress on scalable oversight for large language models\.ArXivabs/2211\.03540\.External Links:[Link](https://api.semanticscholar.org/CorpusID:253384413)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- Free Software Foundation \(2018\)Comparing and merging files with GNU diffutils and patch\.Note:GNU patch 2\.7\.6https://www\.gnu\.org/software/diffutils/Cited by:[§4](https://arxiv.org/html/2609.11957#S4.SS0.SSS0.Px1.p1.2),[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- P\. Gauthier \(2024\)Aider: AI pair programming in your terminal — edit formats and unified diffs\.Note:https://aider\.chat/docs/more/edit\-formats\.htmlCited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- G\. Irving, P\. F\. Christiano, and D\. Amodei \(2018\)AI safety via debate\.ArXivabs/1805\.00899\.External Links:[Link](https://api.semanticscholar.org/CorpusID:22050710)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- C\. E\. Jimenez, J\. Yang, A\. Wettig, S\. Yao, K\. Pei, O\. Press, and K\. R\. Narasimhan \(2024\)SWE\-bench: can language models resolve real\-world github issues?\.InThe Twelfth International Conference on Learning Representations \(ICLR\),External Links:[Link](https://openreview.net/forum?id=VTF8yNQM66)Cited by:[§1](https://arxiv.org/html/2609.11957#S1.p1.1),[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- G\. Katz, C\. Barrett, D\. L\. Dill, K\. Julian, and M\. J\. Kochenderfer \(2017\)Reluplex: an efficient SMT solver for verifying deep neural networks\.InComputer Aided Verification,R\. Majumdar and V\. Kunčak \(Eds\.\),Cham,pp\. 97–117\.External Links:ISBN 978\-3\-319\-63387\-9Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- X\. V\. Lin, C\. Wang, L\. Zettlemoyer, and M\. D\. Ernst \(2018\)NL2Bash: a corpus and semantic parser for natural language interface to the linux operating system\.International Conference on Language Resources and Evaluation \(LREC\)abs/1802\.08979\.External Links:[Link](https://api.semanticscholar.org/CorpusID:3514435)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- X\. Liu, H\. Yu, H\. Zhang, Y\. Xu, X\. Lei, H\. Lai, Y\. Gu, H\. Ding, K\. Men, K\. Yang, S\. Zhang, X\. Deng, A\. Zeng, Z\. Du, C\. Zhang, S\. Shen, T\. Zhang, Y\. Su, H\. Sun, M\. Huang, Y\. Dong, and J\. Tang \(2024\)AgentBench: evaluating LLMs as agents\.InThe Twelfth International Conference on Learning Representations \(ICLR\),External Links:[Link](https://openreview.net/forum?id=zAdUB0aCTQ)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- A\. Madaan, N\. Tandon, P\. Gupta, S\. Hallinan, L\. Gao, S\. Wiegreffe, U\. Alon, N\. Dziri, S\. Prabhumoye, Y\. Yang, S\. Gupta, B\. P\. Majumder, K\. Hermann, S\. Welleck, A\. Yazdanbakhsh, and P\. Clark \(2023\)Self\-refine: iterative refinement with self\-feedback\.InThirty\-seventh Conference on Neural Information Processing Systems \(NeurIPS\),External Links:[Link](https://openreview.net/forum?id=S37hOerQLB)Cited by:[§1](https://arxiv.org/html/2609.11957#S1.p3.1),[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- E\. W\. Myers \(1986\)AnO\(nd\) difference algorithm and its variations\.Algorithmica1\(1–4\),pp\. 251–266\.External Links:ISSN 0178\-4617,[Link](https://doi.org/10.1007/BF01840446),[Document](https://dx.doi.org/10.1007/BF01840446)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- T\. X\. Olausson, J\. P\. Inala, C\. Wang, J\. Gao, and A\. Solar\-Lezama \(2024\)Is self\-repair a silver bullet for code generation?\.InThe Twelfth International Conference on Learning Representations \(ICLR\),External Links:[Link](https://openreview.net/forum?id=y0GJXRungR)Cited by:[§1](https://arxiv.org/html/2609.11957#S1.p3.1),[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- S\. G\. Patil, T\. Zhang, X\. Wang, and J\. E\. Gonzalez \(2024\)Gorilla: large language model connected with massive APIs\.InThe Thirty\-eighth Annual Conference on Neural Information Processing Systems \(NeurIPS\),External Links:[Link](https://openreview.net/forum?id=tBRNC6YemY)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- Y\. Qin, S\. Liang, Y\. Ye, K\. Zhu, L\. Yan, Y\. Lu, Y\. Lin, X\. Cong, X\. Tang, B\. Qian, S\. Zhao, L\. Hong, R\. Tian, R\. Xie, J\. Zhou, M\. Gerstein, dahai li, Z\. Liu, and M\. Sun \(2024\)ToolLLM: facilitating large language models to master 16000\+ real\-world APIs\.InThe Twelfth International Conference on Learning Representations \(ICLR\),External Links:[Link](https://openreview.net/forum?id=dHng2O0Jjr)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- J\. W\. Ratcliff and D\. E\. Metzener \(1988\)Pattern matching: the gestalt approach\.Technical reportDr\. Dobb’s Journal\.Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- T\. Schick, J\. Dwivedi\-Yu, R\. Dessi, R\. Raileanu, M\. Lomeli, E\. Hambro, L\. Zettlemoyer, N\. Cancedda, and T\. Scialom \(2023\)Toolformer: language models can teach themselves to use tools\.InThirty\-seventh Conference on Neural Information Processing Systems \(NeurIPS\),External Links:[Link](https://openreview.net/forum?id=Yacmpz84TH)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- tldr\-pages contributors \(2026\)Tldr\-pages: collaborative cheatsheets for console commands\.Note:https://github\.com/tldr\-pages/tldrAccessed 2026Cited by:[§3](https://arxiv.org/html/2609.11957#S3.SS0.SSS0.Px1.p1.2)\.
- X\. Wang, B\. Li, Y\. Song, F\. F\. Xu, X\. Tang, M\. Zhuge, J\. Pan, Y\. Song, B\. Li, J\. Singh, H\. H\. Tran, F\. Li, R\. Ma, M\. Zheng, B\. Qian, Y\. Shao, N\. Muennighoff, Y\. Zhang, B\. Hui, J\. Lin, R\. Brennan, H\. Peng, H\. Ji, and G\. Neubig \(2025\)OpenHands: an open platform for AI software developers as generalist agents\.InThe Thirteenth International Conference on Learning Representations \(ICLR\),External Links:[Link](https://openreview.net/forum?id=OJd3ayDDoF)Cited by:[§1](https://arxiv.org/html/2609.11957#S1.p1.1),[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- E\. B\. Wilson \(1927\)Probable inference, the law of succession, and statistical inference\.Journal of the American Statistical Association22\(158\),pp\. 209–212\.External Links:ISSN 01621459, 1537274X,[Link](http://www.jstor.org/stable/2276774)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- C\. S\. Xia, Y\. Deng, S\. Dunn, and L\. Zhang \(2024\)Agentless: demystifying llm\-based software engineering agents\.CoRRabs/2407\.01489\.External Links:[Link](https://doi.org/10.48550/arXiv.2407.01489)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- T\. Xie, D\. Zhang, J\. Chen, X\. Li, S\. Zhao, R\. Cao, T\. J\. Hua, Z\. Cheng, D\. Shin, F\. Lei, Y\. Liu, Y\. Xu, S\. Zhou, S\. Savarese, C\. Xiong, V\. Zhong, and T\. Yu \(2024\)OSWORLD: benchmarking multimodal agents for open\-ended tasks in real computer environments\.InProceedings of the 38th International Conference on Neural Information Processing Systems \(NeurIPS\),NIPS ’24,Red Hook, NY, USA\.External Links:ISBN 9798331314385Cited by:[§1](https://arxiv.org/html/2609.11957#S1.p1.1),[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- J\. Yang, C\. E\. Jimenez, A\. Wettig, K\. Lieret, S\. Yao, K\. R\. Narasimhan, and O\. Press \(2024\)SWE\-agent: agent\-computer interfaces enable automated software engineering\.InThe Thirty\-eighth Annual Conference on Neural Information Processing Systems \(NeurIPS\),External Links:[Link](https://openreview.net/forum?id=mXpq6ut8J3)Cited by:[§1](https://arxiv.org/html/2609.11957#S1.p1.1),[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- J\. Yang, A\. Prabhakar, K\. R\. Narasimhan, and S\. Yao \(2023\)InterCode: standardizing and benchmarking interactive coding with execution feedback\.InThirty\-seventh Conference on Neural Information Processing Systems Datasets and Benchmarks Track \(NeurIPS\),External Links:[Link](https://openreview.net/forum?id=fvKaLF1ns8)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.
- S\. Yao, J\. Zhao, D\. Yu, I\. Shafran, K\. R\. Narasimhan, and Y\. Cao \(2022\)ReAct: synergizing reasoning and acting in language models\.InNeurIPS 2022 Foundation Models for Decision Making Workshop,External Links:[Link](https://openreview.net/forum?id=tvI4u1ylcqs)Cited by:[§7](https://arxiv.org/html/2609.11957#S7.p1.1)\.