WorksComputer Science
Invariant-Aware Harness Enforcement to Protect LLM Agents from Silent API Failures
Abstract
LLM agents answer questions by calling APIs and trusting the results. An API can fail silently. It ignores part of a request, such as a misnamed filter, yet returns HTTP 200 and a plausible but wrong result. Current fixes, such as checklists, reviewer models and LLM judges, ask the model to catch it. But models often see the problem and answer anyway. We present SilentGuard, which moves the decision from the model to the harness running tool calls. It tests each result against invariants that any correct API must satisfy and withholds values that break one. We find silent failures in 11 of 15 public research APIs, with counts inflated up to 691 times. Current fixes leave over 70% of answers wrong, and agents report 77.4% of counts a judge flags. Across 7 open models, SilentGuard cuts wrong answers on its target faults from 74.0% to 1.7%, with no loss on fault-free tasks. On three frontier models they fall from 70.2% to 0.5%. A warning from the same check leaves 70.1% wrong, so enforcement is the key. On new fault types, the harness alone cuts wrong answers from 61.1% to 24.5%. It avoids wrong answers by abstaining rather than recovering.
Introduction
LLM agents now do much of their work through tools. They search literature databases, look up genes and proteins, query sample catalogs and book travel by calling APIs, and they build their answers from what those APIs return. The agent’s answer can only be as good as the tool results it reads.
Most of the time, a broken tool call is easy to see, because the API returns an error, times out or sends malformed data. Some failures leave no such trace. Consider an agent that asks a catalog API how many samples match two conditions. The API’s documentation names one filter slightly wrong, so the API ignores that filter and counts the samples that match the other condition alone. The response is well formed, the status is 200, and the number is wrong. We call such a response a silent API failure. It looks successful but does not answer the request that was sent. We call its cause a silent fault. Neither is rare. Among 15 public research APIs, 11 answer at least one plausible mistake this way, by ignoring a misnamed filter, dropping a filter value with a typo or quietly cutting a page short (§5.1). Earlier work shows that agents miss silent tool errors (Sun et al., 2024; Zhu et al., 2026) and that production APIs fail silently when a constraint is stated only in prose (Li et al., 2026). In our faults the response is well formed and consistent with itself, so no check on the response alone can show the fault. It takes extra queries to the same API.
The fixes in use today put the model in charge. A checklist prompt asks it to inspect each result (Sun et al., 2024). A reviewer model checks each call (Ta et al., 2026). Outcome Monitors attach a warning to suspect results (Panthi and Abdelfattah, 2026), and an LLM judge rates them. In our tests, each of these leaves wrong answers close to the 74.0% of an unguarded agent. The surprising part is why. The problem does not go unseen. A judge that is shown the results of a consistency check flags 82.4% of faulted runs (and 13.9% of clean runs), and a plain warning from the check tells the agent that the result failed. The agent then reports the flagged count anyway, in 77.4% of the runs the judge flagged and in 64.4% of the runs that got a warning. Agents are not blind to the flag, since their stated confidence drops and many mention the warning. They answer anyway.
Controlled comparisons on 7 open models separate three ingredients (Table 2). The first is evidence, a test whose result shows that the response cannot be right. Without it, a judge leaves about 70% of answers wrong, whether its verdict is advice (71.7%) or is enforced by blocking (70.8%). The second is permission. Agents default to giving a number, and a short prompt that allows the answer “cannot be determined” cuts wrong answers after a warning from 70.1% to 18.2%. The cut is uneven (0–59% wrong by model), and the same prompt without evidence does nothing. The third is enforcement. When the harness (the code that runs the agent’s tool calls) decides what happens to a failed result, the outcome depends far less on the model. A harness that withholds the value leaves 1.7% wrong, at most 4% on any model.
| (a) One LLM judge | Advises | Blocks |
| Without the check’s results | 71.7 | 70.8 |
| With the check’s results | 71.2 | 6.1 |
| (b) Acting on the check | Wrong↓ | Clean↑ |
| No guard (no check) | 74.0 (32–87) | 84.9 |
| Warning | 70.1 (19–87) | 86.3 |
| Warning + may abstain | 18.2 (0–59) | 83.5 |
| SilentGuard (withholds) | 1.7 (0.0–3.7) | 84.9 |
Table 2. Evidence is necessary, and enforcement makes it reliable. % wrong answers under silent faults on AgentOrchBench. The same 7 open models and 2 seeds in every cell. (a) One judge (gpt-oss-120b) in four settings. It does or does not see the results of the count check’s extra queries, and its verdict is advice to the agent (advises) or is enforced by the harness (blocks). (b) Three ways to act on the full count check. May abstain: the prompt allows the answer that the count cannot be determined. In brackets: lowest and highest model. Clean: % correct with no fault. All methods: Table 3.
SilentGuard (Figure 1) applies these findings as invariant-aware harness enforcement. It produces evidence with invariants, properties that must hold on a correct API. For a filtered count, the count with a condition plus the count with its negation must equal the count without it. For a list, every returned record must meet the filter. Every request must use parameters the API documents. Where no exact invariant exists it uses contracts learned from clean responses. A result that fails is re-checked once. What the harness does next depends on how certain the failed check is. A broken exact invariant proves that the API did not answer the request, so the harness withholds the value and accepts only checked answers. A learned check can itself be wrong, so the harness only warns. No extra model call is needed. Across 7 open models SilentGuard cuts wrong answers from 74.0% to 1.7% with no loss on fault-free (clean) tasks, and on three frontier models from 70.2% to 0.5% (§ 5.3). On nine real APIs, given documentation in which we changed one filter name, wrong answers fall from 89.8% to 21.3%. A check against the API’s published parameters does as well alone (21.0%).

Figure 1. SilentGuard in the harness. Every tool result is checked, and a result that fails is re-checked once. If it fails again, the harness withholds it when the failed check is exact and warns when the check is learned and may itself be wrong (Eq. (2)). The model never decides alone whether a result can be trusted.
SilentGuard prevents wrong answers by abstaining, not by recovering. Under faults it mostly says the count cannot be determined, and it cannot see a fault that keeps its checks true. So we report risk against coverage (Figure 2). At a 25% fault rate SilentGuard answers 67% of tasks with 3.3% of its answers wrong, while methods without evidence, or with advice alone, stay near the 24.6% risk of no guard. SilentGuard also has limits. Blind retry does better on faults that clear within one or two calls. The parameter check cannot see a filter written inside a query string.
Figure 2. Risk against coverage on AgentOrchBench with clean and faulted calls mixed. Lower is safer and further right answers more. Each line runs from a 10% fault rate (right end) to 50% (left end, higher risk), with a large marker at 25%. Mean over 7 open models. Gray lines are methods without evidence of the fault, or with advice alone.
Contributions. (1) A measurement of silent failures in 15 real APIs, covering three kinds of fault. (2) Controlled comparisons showing that evidence is necessary, that most agents do not act on it unless told they may abstain, and that only enforcement by the harness is reliable across models. (3) Silent-
Guard, a set of invariant checks enforced by the harness, which withholds results that fail an exact check and only warns on results that fail a learned check. (4) AgentOrchBench, our benchmark with exact answers, and an evaluation with predictions written down in advance. The evaluation covers four benchmarks, count and list answers, published methods and controls, 7 open models, and 3 frontier models added later. Code and tasks are at https://github.com/Sajib-006/silentguard.
Related Work
Tool failures and agent robustness.
Recent benchmarks inject failures into tool responses. They find that observation handling is where agents break ((Zheng et al., 2026)), that implicit failures hurt more than explicit errors ((Zhu et al., 2026)), and that reliability drops under production-like stress ((Gupta, 2026; Tian et al., 2026; Wang et al., 2026)). Agents also claim success they did not achieve ([3]), stronger models can trust tool outputs more ((Wang and Vemuri, 2026)), and agents adopt corrupted tool returns even when they question them ((Yang et al., 2026)). Production APIs often accept queries they do not understand and still return HTTP 200 ((Li et al., 2026)). We study what agents do with such results and how the harness can catch them.
Fixes for unreliable tools. Warning the model that tools may fail and giving it a checklist helps on simple tool errors (Sun et al., 2024). A second model can review each tool call before it runs (Ta et al., 2026). Outcome Monitors learn contracts from clean traces and attach a non-binding warning to results that break them (Panthi and Abdelfattah, 2026). Skeptical prompting and re-querying give mixed gains (Zhang et al., 2026a), and run-time layers check or wrap tool use (Zhao et al., 2026; Yan et al., 2026; Mansoor et al., 2026). Code outside the model can also decide. Guardrail frameworks (Rebedea et al., 2023), secure agent designs [6] and rule-based enforcement (Wang et al., 2025; Shi et al., 2025) control which actions an agent may take. ToolGate commits a tool result only when a hand-written postcondition holds (Liu et al., 2026), deterministic gates block writes that break a policy (Reddy et al., 2026), and a final verifier can withhold a whole episode (Zhang et al., 2026b). These check actions, hand-written conditions or whole episodes. We check each read result with exact identities that the harness tests by sending extra queries to the same API, and we show in controlled tests why the decision must leave the model.
Checks without ground truth. Our count check is a metamorphic relation [5] (Segura et al. 2016), a two-way form of the query partition used to find bugs in database engines (Rigger and Su, 2020). Metamorphic relations have been used to test REST APIs offline (Segura et al., 2018; Khan et al., 2026), and fuzzers such as RESTler [4] look for crashes, not wrong answers. We run the check online, per call. Learned contracts follow specification and invariant mining (Ernst et al., 2007; Panthi and Abdelfattah, 2026).
How models use evidence. LLMs often fail to correct their own answers without outside feedback (Huang et al., 2024). When the context contradicts what they believe, they may follow it or ignore it (Xie et al., 2024). We study the reverse case, in which the outside feedback is right and most models do not act on it unless told they may abstain. Models guess rather than abstain, because training and scoring reward a guess (Kalai et al., 2025; Kirichenko et al., 2025). Agents invent values mainly when a tool failure is not signalled (Sethi et al., 2026). Our faults are never signalled, and a prompt that allows abstaining does nothing without evidence. Saying “cannot be determined” is a form of abstention (Wen et al., 2025) and of selective prediction (Geifman and El-Yaniv, 2017; Kamath et al., 2020). Here the harness, not the model, decides when to abstain.
Methods
Silent API failures. A tool call is a request and a response . A silent failure is a response with a success status whose content does not answer . For example, a filter is ignored, a condition is misread, or a total is capped. Nothing in marks it.
Checks. SilentGuard uses two kinds of check, depending on what the tool allows (App. B). Exact checks hold on any API that applies its filters correctly, so a failure shows that the request was not answered as sent. For count queries we test, after every filter query, the count identity
where is the count the API returns for filter and drops the last condition. The harness issues the two extra queries itself. For every position of the condition list we repeat the test, so an ignored filter anywhere is caught. When the answer is a list of records, the harness also checks that every returned record meets the filter, that no record repeats, and that the list size matches the reported total. When an API publishes its parameter list, a request with a parameter outside it is rejected before it runs (the parameter check, or spec check). Learned checks come from clean traces and cover field presence and type, echoed arguments, positive values, categorical values, linear relations between fields and date order, mined as in Panthi and Abdelfattah (2026). Table 1 lists the checks by kind of tool operation, including ones we did not test.
| Operation | Silent failure | Check that must hold | Tested |
| Exact checks | |||
| Count, filtered | filter ignored, joined with OR, capped | count identity at every position (Eq. (1)) | ✓ |
| List, filtered | records outside the filter, repeats | each record meets the filter, no repeats, size = total | ✓ |
| Documented API | unknown parameter accepted | parameter is in the published spec | ✓ |
| One filter | filter ignored | value swap (a different value changes the result) | ✓ |
| Pages, ranges, sorting, writes | records skipped, or bound, order or update ignored | pages do not overlap, results in bound and in order, a read returns the write | |
| Learned checks | |||
| Any tool | wrong type, echo, range, relation | contracts mined from clean responses | ✓ |
Table 1. Checks by kind of tool operation. Exact checks are invariants that hold on every correct API. Learned checks are mined from clean responses and can raise false alarms. Of 84 documented operations in 13 public APIs, 61 allow an exact check and all allow the spec check (Table 14).
Detection and action. SilentGuard separates finding a problem from acting on it. Each check maps a tool result to pass or fail and has an estimated false-alarm rate , where is the number of clean examples it held on (rule of succession). Exact checks have , so . After one re-check, the harness action is
with cutoff . New checks plug into without changing it.
SilentGuard. For every tool result the harness runs the checks. (1) A result that passes is released unchanged. (2) A result that fails is re-checked once. The harness sends the same call again and releases the new result only if it passes. (3) If the result fails again, the action depends on the failed check (Eq. (2)). If a failed check is exact (), the failed values are withheld and the agent is told which values could not be verified and which other tool could redo the step. On count answers this becomes an answer rule. The harness accepts only a count that passed a check, rejects any other count twice, and then answers that the count cannot be determined. If a failed check is learned from few examples, the data stays visible with a warning naming the failed property and the recovery tools, as in Panthi and Abdelfattah (2026). (4) Results that already carry an error pass through unchanged. A result checklist (Sun et al., 2024) is added to the system prompt. SilentGuard never repairs a value on its own. Recovery is always the agent’s own call with a listed tool (§ 5.4 shows why).
Experimental Setup
AgentOrchBench (ours). We built AgentOrchBench to measure silent failures where the right answer is known exactly. The agent works from a shell and calls eight local REST services with curl, and all services are reset before each task. Each task asks how many of the 400 catalog records match two or three conditions, and the answer is a single number computed from the seed data, so grading is exact and needs no judge. The catalog returns only the count, so the agent cannot check a filter by reading the records. Faults are injected inside the server. The reply is HTTP 200, and the fault repeats on every call, so asking again returns the same wrong number. Each fault type is modeled on a kind of API bug (Table 7, App. § 10.§ 1). One of them, an ignored parameter, is the failure we measure in real public APIs (§ 5.1). We ran the six fault types in the top part of Table 7. The two below them keep the count identity true by design and are used in the list tasks and the harness-only tests (App. § 16 and I). A retail orders API with four fault types tests whether results carry over to a different schema. We ran 36 tasks with 2 seeds under each fault type and with no fault, for every model and method variant (arm).
| Fault | API behavior | Modeled on | Check |
| Drop last | drops last filter | wrong filter name | ✓ |
| Cap total | reports at most 5 | page size as total | ✓ |
| AND→OR | uses OR | query builder | ✓ |
| Ignore field | ignores any filter | unindexed field | ✓ |
| Ignore NOT | drops negation | unsupported NOT | FA |
| Off by one | count +1 | range bug | ✓ |
| Prefix match | prefix, not equal | loose matching | – |
| Consistent lie | lies everywhere | adversarial API | – |
Table 7. Silent fault types in AgentOrchBench and the kind of API bug each is modeled on. The first is the failure we measure in real APIs (§ 5.1). The Check column says whether the exact count check (Eq. (1)) fires (✓), fires although the count may be right (FA, false alarm), or cannot see the fault (–), because the fault keeps the identity true.
Other benchmarks. The real public APIs are 9 APIs (NCBI, UniProt, Europe PMC, GBIF, Zendo, ChEMBL, arXiv, DataCite, iNaturalist) with 5 count tasks each and correct or slightly wrong documentation. That gives 45 runs per model, arm and documentation. Zhu et al., 2026 has 400 multi-step tool workflows with silent faults that hit the first call (P3) or every call (P4), explicit errors (P1, P2) and clean runs (P0), scored by its own judge (App. § 10.§ 3). We used 180 workflows never used in method design.
Methods compared. The published methods are a checklist prompt (Sun et al., 2024), a reviewer (Ta et al., 2026) and Outcome Monitors (OM) (Panthi and Abdelfattah, 2026). The reviewer is the agent’s own model, which checks each call before it runs for up to five loops. OM uses its contract miner and warning text, with rules learned from clean responses of other tasks. On ToolMaze we also run the checklist plus OM. The baselines and controls are no guard, a caution prompt, an LLM judge in the sense of Zheng et al. (2023), self-verification, blind retry (every call sent twice, the second response released) and re-query (both responses shown). The judge is a fixed model (gpt-oss-120b) that also sees the check results, meaning the harness’s consistency queries. The ablations of the harness action are warning, warning with a recovery tip, answer gate, Enforce (checked counts only, failed count left visible) and auto-repair (the harness recounts by another route). Prompts are in App. § 12.
Models. The main runs use 7 open-weight (open) models (Phi-4, gpt-oss-120b, Gemma-3-27B, Llama-3.3-70B, Llama-4-Scout, Llama-4-Maverick and Nemotron-3-Ultra). Three frontier models (GPT-5.6 Sol, Terra and Luna) ran six arms of AgentOrchBench and two arms of the real-API study (§ 5.3). The frontier AgentOrchBench runs and the Nemotron-3-Ultra control arms ran on Genentech’s internal platform with the same code, tasks, seeds and grader. Company policy bars releasing their logs, so we report their answer counts. All models use at most 2,000 output tokens per turn, at most 16 turns (25 on ToolMaze) and the same prompts. The open models run at temperature 0, and the frontier models use the provider default (App. § 13).
Protocol. Every planned experiment was written down with its predictions before it ran. The code was frozen by hash, and runs refuse to start if the code changed. The method went through three versions on ToolMaze. Each version was tested only on unseen workflows, and the final SilentGuard was frozen before all planned runs (App. § 15).
Grading and statistics. We grade each answer as correct (it equals the ground truth), unknown (it gives no count) or wrong (any other count). Confidence values and identifiers are not read as counts. ToolMaze uses its own judge. We report the mean over models with its standard error (SE, ±) and 95% task-cluster bootstrap intervals for the key differences. We also report how many of the 7 models show the difference, with an exact sign-flip test (smallest 0.016, App. § 13).
Results
Silent Failures Are Common in Real APIs
For each API we sent an unfiltered query, the documented filtered query, and two or three plausible wrong filter names (for example organism=human on NCBI instead of human[orgn] in the search term). Of 15 APIs, 10 return HTTP 200 with exactly the unfiltered count and no warning for at least one wrong name, up to 691× too large (all probes in Table 8 and Figure 3, App. § 10.§ 2). The other APIs reject unknown parameters with an error. The value-swap check, which flags a filter whose count does not change with its value, caught 26 of the 28 ignored filter names. Misnamed filters are not the only silent fault. When asked for more records per page than they allow, 6 of the 14 APIs we could test return HTTP 200 with fewer records and no error. Three APIs silently drop a filter whose value has a typo, such as a bad year or date. The spec check cannot see such a typo, because the parameter name is valid. The count identity and the value-swap check flagged it in 15 of 15 probes, with no false alarm (Table 12). In all, 11 of 15 APIs show at least one silent fault (Table 11).
Figure 3. How many times too large the returned count is when a real API silently ignores a misnamed filter (log scale). The overcount spans more than two orders of magnitude.
| API | Misnamed filter | Bad filter value | Page over limit |
| NCBI gene | ignored | applied | honored |
| UniProtKB | ignored | rejected | rejected |
| ClinicalTrials.gov | rejected | rejected | capped |
| Europe PMC | ignored | ignored | rejected |
| OpenAlex | rejected | rejected | rejected |
| Crossref | rejected | rejected | rejected |
| openFDA | rejected | rejected | rejected |
| DataCite | ignored | applied | capped |
| Zenodo | ignored | applied | rejected |
| GitHub search | ignored | ignored | capped |
| ChEMBL | ignored | rejected | capped |
| arXiv | ignored | applied | honored |
| GBIF | ignored | applied | capped |
| iNaturalist | ignored | ignored | capped |
| Semantic Scholar | rejected | – | – |
Table 11. Three kinds of silent fault in real public APIs (read-only probes). Misnamed filter: a plausibly misnamed filter parameter. Rejected means the API returned an error. Bad filter value: a typo in the value of a valid filter (for example a bad year or date). Ignored means the count equals the unfiltered one, applied means the value was used as given (usually zero results), which is correct. Page over limit: a request for more records per page than the API allows. Capped means HTTP 200 with fewer records than asked and no error. Honored means the API returned the larger page. Bold red: silent. –: rate-limited, not measured.
| API | Typo in | Ignored | Over | Fired | FA |
| Europe PMC | query string | 5/5 | 19–40× | 5/5 | 0/5 |
| GitHub search | query string | 5/5 | 3.2–4.4× | 5/5 | 0/5 |
| iNaturalist | parameter | 5/5 | 1.1–1.5× | 5/5 | 0/5 |
Table 12. A typo in the value of a valid filter, on the three APIs that silently ignore it (five probes each, read-only, no model). The parameter name is valid, so the spec check passes. Ignored: the API returned the unfiltered count. Over: returned / correct. Fired: the count identity (Europe PMC, GitHub, where the value sits inside the query string) or the value-swap check (iNaturalist) flagged the result. FA: the same check fired on the correctly spelled query.
Evidence Is Necessary and Enforcement Makes It Reliable
Table 2 separates the ingredients on all 7 open models. With no guard, agents report a wrong count in 74.0% of faulted runs. Methods that rely on the model’s own reading of the result change little (checklist 72.3%, reviewer 73.8%, Outcome Monitors 72.2%, Table 3).
| Method | Wrong↓ | Corr.↑ | Unk. | Clean↑ |
| Baselines and controls | ||||
| No guard | 74.0 ±7.1 | 16.4 | 9.6 | 84.9 ±10.6 |
| Caution prompt | 73.3 ±7.3 | 16.4 | 10.3 | 86.1 ±9.1 |
| Self-verification | 56.2 ±9.2 | 14.2 | 29.6 | 76.6 ±12.8 |
| Re-query | 74.9 ±5.0 | 17.0 | 8.1 | 84.7 ±8.6 |
| Blind retry | 74.4 ±5.1 | 17.3 | 8.3 | 88.3 ±7.4 |
| LLM judge | 71.2 ±7.8 | 17.4 | 11.4 | 86.5 ±8.5 |
| Published methods | ||||
| Checklist | 72.3 ±8.1 | 16.2 | 11.5 | 84.1 ±10.6 |
| Reviewer | 73.8 ±5.7 | 15.8 | 10.4 | 80.4 ±10.0 |
| Outcome Monitors | 72.2 ±8.1 | 16.6 | 11.2 | 86.1 ±8.8 |
| Evidence, permission, enforcement | ||||
| Judge, no evidence | 71.7 ±8.7 | 16.3 | 11.9 | 80.7 ±12.3 |
| + blocking | 70.8 ±8.2 | 16.7 | 12.5 | 83.7 ±10.6 |
| Judge + blocking | 6.1 ±2.2 | 3.5 | 90.4 | 81.7 ±9.3 |
| OM + blocking | 70.9 ±8.5 | 16.6 | 12.5 | 86.5 ±9.4 |
| Warning + may abstain | 18.2 ±9.3 | 5.0 | 76.8 | 83.5 ±11.2 |
| SilentGuard (ours) | 1.7 ±0.5 | 2.4 | 95.8 | 84.9 ±11.3 |
Table 3. SilentGuard gives the fewest wrong answers on AgentOrchBench. Mean over 7 open models (± standard error), % of runs with a silent fault (Wrong, Corr., Unk.) or with no fault (Clean). Unk.: the answer says the count cannot be determined. Bold is best and underlined is second. The LLM judge sees the check results and advises. Published: checklist (Sun et al., 2024), reviewer (Ta et al., 2026), Outcome Monitors (OM) (Panthi and Abdelfattah, 2026). Blocking: a flagged result is withheld and only accepted counts may be reported. No evidence: the judge does not see the check results.
Evidence is necessary. Part (a) tests one judge in four settings, with or without the check’s results and advising or blocking. Without the count check’s extra queries, the judge’s verdict leaves 71.7% wrong as advice and 70.8% when the harness blocks on it. Outcome Monitors with blocking leave 70.9%, because their contracts rarely fire on a wrong count (3.5% of faulted runs, 6.2% of clean ones). A silently wrong count gives a detector nothing to see.
Evidence is not enough. With the check’s queries, the judge flags a result as suspect in 82.4% of faulted runs (and 13.9% of clean runs), yet as advice it still leaves 71.2% wrong. In 77.4% of flagged runs the agent reports the flagged count anyway. After a warning from an earlier version of the check, it does so in 64.4% of warned runs. The agents do notice the flag. After a warning their stated confidence falls from 1.00 on clean runs to 0.43, and 40% of the wrong answers mention the warning. Still, agents default to giving a number. A short prompt that permits the answer “cannot be determined” cuts wrong answers after a warning from 70.1% to 18.2% (part b), so agents can act on evidence. But wrong answers still range from 0% to 59% across models, and the same permission without evidence changes nothing (caution prompt, 73.3%).
Enforcement makes it reliable. When the harness acts on the evidence, the result depends far less on the model and the prompt. The judge with evidence and blocking leaves 6.1% wrong. SilentGuard withholds the failed value and accepts only checked counts. It leaves 1.7% wrong (at most 4% on any model), needs no extra model call and keeps clean accuracy (84.9%, against 84.9% with no guard). SilentGuard has fewer wrong answers than no guard, each published method and blind retry on 7 of 7 models (Table 3, Table 19 and Table 20, with against no guard, the smallest possible with 7 models). How the harness acts matters. Enforce, which accepts only checked counts but leaves the failed count visible, gives 0.5% to 24.8% wrong by model, because agents re-query until some other query passes the check (App. § 14).
| Model | None | Check. | Rev. | OM | Judge | Retry | Self-v. | Enf. | Ours |
| Llama-4-Scout | 86.6 | 79.2 | 79.6 | 81.2 | 83.6 | 78.0 | 79.6 | 7.2 | 2.1 |
| Llama-4-Maverick | 80.8 | 80.3 | 79.9 | 79.6 | 80.1 | 80.1 | 36.3 | 0.5 | 0.5 |
| Llama-3.3-70B | 80.6 | 80.8 | 80.6 | 80.6 | 78.7 | 80.3 | 69.2 | 1.2 | 0.0 |
| gpt-oss-120b | 80.8 | 80.6 | 79.8 | 80.8 | 74.1 | 80.8 | 53.5 | 24.8 | 1.2 |
| Nemotron-3-Ultra | 80.6 | 80.6 | 80.6 | 80.6 | 79.9 | 80.6 | 78.5 | 12.0 | 3.7 |
| Gemma-3-27B | 76.9 | 81.0 | 76.2 | 78.9 | 77.3 | 77.3 | 63.9 | 6.5 | 3.5 |
| Phi-4 | 32.2 | 23.4 | 40.0 | 23.4 | 24.8 | 44.0 | 12.5 | 9.5 | 1.2 |
| GPT-4.1 | 100.0 (14%) | – | – | – | 66.7 (57%) | – | 47.2 (29%) | – | – |
| GPT-4o | 83.3 (14%) | – | – | – | – | – | 2.8 (14%) | – | – |
| GPT-4o-mini | 98.6 (14%) | – | – | – | 98.6 (43%) | – | – | 5.6 (14%) | – |
Table 19. AgentOrchBench, wrong answers per model and method (%). None: no guard. Check.: checklist. Rev.: reviewer. OM: Outcome Monitors. Judge: LLM judge. Retry: blind retry. Self-v.: self-verification. Enf.: Enforce. Ours: SilentGuard. Bold: best in the row. Underlined: second. The three older GPT models below the line finished only part of their runs (finished share in brackets) and are not ranked. The GPT-5.6 models are in Table 5.
| Model | AgentOrchBench (wrong ) None | AgentOrchBench (wrong ) Ours | ToolMaze (success ) C+OM | ToolMaze (success ) Ours | ||
| Llama-4-Scout | 86.6 | 2.1 | −84.5 | 31.7 | 38.6 | +6.9 |
| Llama-4-Maverick | 80.8 | 0.5 | −80.3 | 38.9 | 45.6 | +6.7 |
| Llama-3.3-70B | 80.6 | 0.0 | −80.6 | 36.9 | 38.6 | +1.7 |
| gpt-oss-120b | 80.8 | 1.2 | −79.6 | 38.6 | 35.6 | −3.1 |
| Nemotron-3-Ultra | 80.6 | 3.7 | −76.9 | 31.9 | 37.5 | +5.6 |
| Gemma-3-27B | 76.9 | 3.5 | −73.4 | 23.6 | 32.2 | +8.6 |
| Phi-4 | 32.2 | 1.2 | −31.0 | 27.5 | 24.2 | −3.3 |
| Ours better | 7/7, | 5/7, |
Table 20. The gain holds for every model on AgentOrchBench and for 5 of 7 on ToolMaze. AgentOrchBench: % wrong answers under silent faults, no guard against SilentGuard. ToolMaze: % task success under silent faults, the strongest published mix (Checklist + Outcome Monitors, C+OM) against SilentGuard. : ours minus the other, computed before rounding (green: ours better, red: ours worse, bold: the better of the pair). : exact sign-flip test over the 7 models.
Abstaining, not recovering. Under faults SilentGuard mostly answers that the count cannot be determined, and its correct answers fall from 16.4% to 2.4%. The 1.7% applies to the six fault types the count check can see. On six other fault types, written after the method was frozen, wrong answers fall only from 61.1% to 24.5%, and correct answers fall from 38.9% to 19.0% (harness alone, Table 6). So we also compare methods as selective prediction does (Geifman and El-Yaniv, 2017), by risk (the
| Unseen fault | Fired | No guard | SilentGuard | Auto-repair |
| Word-stem match | 0/36 | 32/4/0 | 32/4/0 | 32/4/0 |
| NOT drops empty | 0/36 | 0/36/0 | 0/36/0 | 0/36/0 |
| Partial shard | 36/36 | 20/16/0 | 0/0/36 | 34/2/0 |
| Tag-join double | 15/36 | 36/0/0 | 21/0/15 | 36/0/0 |
| Cursor skips ties | 36/36 | 9/27/0 | 0/0/36 | 0/36/0 |
| Lossy index | 35/36 | 35/1/0 | 0/1/35 | 0/1/35 |
| Total | 132/84/0 | 53/41/122 | 102/79/35 |
Table 6. Auto-repair returns wrong answers marked as verified. Six fault types written after the method was frozen, run through the harness alone (36 count tasks each, cells: wrong / correct / unknown). Fired: tasks where the count check fired. When its check fires, SilentGuard (bold) never releases a wrong answer.
share of answers that are wrong) against coverage (the share of runs that get an answer). Figure 2 mixes each method’s measured clean and faulted outcomes at fault rates from 10% to 50%. Methods without evidence, or with advice alone, sit with no guard. At a 25% fault rate the LLM judge answers 91% of tasks at 24.0% risk, and no guard answers 90% at 24.6%. The harness arms sit far below. SilentGuard has the lowest risk at fault rates up to 25% (3.3% at 25%). At 50% auto-repair is slightly lower (4.2% against 4.5%). SilentGuard is also among the lowest in coverage (67%, against 66% for judge + blocking). Auto-repair is the other choice. On the fault types it was built for it answers 80% at 3.9% risk, but on new fault types it releases wrong answers marked as verified (§ 5.4, with the cost trade-off in Table 16).
| Against | Other | SilentGuard | |
| AgentOrchBench, seen faults (7 models) | |||
| No guard | 16.4 / 74.0 | 2.4 / 1.7 | 0.2 |
| Auto-repair | 57.3 / 3.0 | 2.4 / 1.7 | 43.6 |
| Lists, seen faults (7 models) | |||
| No guard | 43.7 / 49.3 | 21.1 / 9.1 | 0.6 |
| Auto-repair | 47.9 / 14.6 | 21.1 / 9.1 | 4.9 |
| Lists, unseen faults (7 models) | |||
| No guard | 56.7 / 37.8 | 7.1 / 11.5 | 1.9 |
| Auto-repair | 37.5 / 16.9 | 7.1 / 11.5 | 5.7 |
| Unseen count faults, harness only | |||
| No guard | 38.9 / 61.1 | 19.0 / 24.5 | 0.5 |
| Auto-repair | 36.6 / 47.2 | 19.0 / 24.5 | 0.8 |
Table 16. Where withholding pays. Cells: % correct / % wrong of faulted runs. With score = correct − wrong, is the cost of a wrong answer, relative to a correct one, above which SilentGuard scores higher than the other method (computed from unrounded values). Against no guard is small everywhere. Against auto-repair on count tasks it is large on the fault types repair was built for and small on fault types no method was built for.
Retail and real APIs. Wrong answers also fall on the retail domain (Table 4), from 78.6% with no guard to 11.0% with SilentGuard. On real public APIs, agents given slightly wrong documentation report a wrong count 89.8% of the time with no guard and 21.3% with SilentGuard, and correct answers rise from 3.5% to 69.5%. With the right documentation an unguarded agent is correct 92.1% of the time. On these tasks the gain comes from the spec check, not from the count check. The spec check alone does as well (21.0% wrong), because it rejects the misnamed filter. Typed tool calls with a strict schema, as in function calling, do worse (28.6%). The gain is uneven (38.6% wrong on the four APIs chosen before freezing, 7.4% on the five added later). Most of the errors left are on APIs whose filters live inside a query string (NCBI, UniProt, Europe PMC, arXiv), which neither a schema nor the value-swap check can see. When the documentation instead gives a wrong value format for a valid parameter (iNaturalist dates), the spec check cannot help (100.0% wrong, against 97.1% with no guard). The value-swap check cuts wrong answers to 20.0%, mostly by abstaining (Table 13).
| Retail domain | Wrong↓ | Correct↑ | Clean↑ |
| No guard | |||
| Auto-repair | |||
| Enforce | |||
| SilentGuard (ours) | |||
| Real APIs (9) | Wrong↓ | Correct↑ | Right docs↑ |
| No guard | |||
| Blind retry | |||
| Spec check alone | |||
| Typed calls | |||
| Typed calls + ours | |||
| SilentGuard (ours) | |||
| ToolMaze | Silent↑ | Loud↑ | Clean↑ |
| Checklist | |||
| Outcome Monitors | |||
| Checklist + OM | |||
| Blind retry | — | ||
| SilentGuard (ours) |
Table 4. The other benchmarks, each with the methods run on it (mean over 7 open models, standard error, %). Retail: our count benchmark on a second schema. Real APIs: agents given slightly wrong documentation. Right docs: % correct with the right documentation. Typed: tool calls with a strict parameter schema, as in function calling. ToolMaze (Zhu et al., 2026): % task success under silent faults, loud (explicit) errors and no fault. OM: Outcome Monitors. Blind retry was not run on loud errors. Bold: best. Underlined: second.
A benchmark built by others. On ToolMaze, scored by its own judge, only learned checks exist, so SilentGuard warns and never withholds. So this benchmark tests the re-check, not enforcement. Under silent faults SilentGuard’s task success is slightly above the published methods (36.0%, against 32.7% for checklist + OM, on 5 of 7 models, 95% interval [1.8, 4.9] points). The lead comes from one-time faults (not lasting ones), and clean success is 4.6 points below OM.
List answers. When the answer is a list of record IDs, the same rule gives the fewest wrong lists (from 37.8% to 11.5% on unseen faults), and correct lists fall too (56.7% to 7.1%, App. § 16).
Frontier Models Fall for Silent Faults Too
Table 5 adds three frontier models on six arms. With no guard they report a wrong count in 59.0–89.4% of faulted runs, and GPT-5.6 Sol is the highest. Told to run the check themselves, they almost stop giving wrong answers (4.5%), but their clean accuracy falls from 92.1% to 20.4%, which suggests that they mostly refuse. A warning from the harness is enough for Sol (11.3% wrong, and 2.3% with permission to abstain) and not for Terra or Luna (35.9% and 45.1% even with permission). Both cost clean accuracy (71.8% with the warning and 78.7% with permission, against 92.1% with no guard). Enforce does worse here than on the open models (33.9% against 8.8%). Without logs we cannot test why. On the open models, about half of Enforce’s wrong answers come from re-querying (App. § 14). SilentGuard leaves 0.0–1.4% wrong, with clean accuracy at 98.1%. On the real APIs it cuts the frontier models’ wrong answers from 57.8%
| Model | None | Self-v. | Warn | W+A | Enf. | Ours |
| Wrong answers under silent faults (%, ↓) | ||||||
| Open models | 74.0 | 56.2 | 70.1 | 18.2 | 8.8 | 1.7 |
| GPT-5.6 Sol | 89.4 | 2.5 | 11.3 | 2.3 | 31.5 | 0.0 |
| GPT-5.6 Terra | 62.3 | 3.9 | 53.9 | 35.9 | 34.0 | 0.2 |
| GPT-5.6 Luna | 59.0 | 6.9 | 63.2 | 45.1 | 36.1 | 1.4 |
| Correct on clean tasks (%, ↑) | ||||||
| Open models | 84.9 | 76.6 | 86.3 | 83.5 | 86.3 | 84.9 |
| GPT-5.6 Sol | 98.6 | 29.2 | 77.8 | 86.1 | 100.0 | 100.0 |
| GPT-5.6 Terra | 93.1 | 15.3 | 68.1 | 76.4 | 90.3 | 98.6 |
| GPT-5.6 Luna | 84.7 | 16.7 | 69.4 | 73.6 | 87.5 | 95.8 |
caption: Frontier models fall for silent faults too. SilentGuard cuts wrong answers the most and keeps clean accuracy. AgentOrchBench, six methods on three frontier models (2 seeds) and the mean of the 7 open models. Self-v.: self-verification, the model runs the count check itself. Warn: the harness warns. W+A: warning plus permission to abstain. Enf.: Enforce. None: no guard. Ours: SilentGuard. Bold: best in the row. Means are computed before rounding.
:::
to 8.9% (Table 10). Silent faults are not only a small-model problem.
Blind retry. Sending every call twice helps only when the fault clears. On ToolMaze’s one-time faults blind retry reaches 60.4% task success against 47.6% for SilentGuard, against our prediction (Table 22). On AgentOrchBench it leaves 74.4% wrong and on real APIs 89.5%, and it repeats a booking, payment or message 2.36 times per run (0.24 for SilentGuard).
| Harness | ToolMaze success 1-call fault | ToolMaze success 2-call fault | ToolMaze success Lasting | Real APIs wrong | Repeated actions |
| No re-check | 39.9 | 32.5 | 25.6 | – | – |
| Blind retry | 60.4 | 56.0 | 27.0 | 89.5 | 2.36 |
| SilentGuard | 47.6 | 46.4 | 24.4 | 21.3 | 0.24 |
Table 22. Blind retry helps only when the fault clears. Blind retry (the no re-check harness plus every call sent twice, second result kept) clears a short fault that lasts one or two calls. On a fault that lasts (ToolMaze P4) it adds little over the same harness without retry, and on real APIs, which ignore a misnamed filter every time, it does not reduce wrong answers. It also repeats bookings, payments and messages. No re-check: the checklist with Outcome Monitors, without retry. Mean over 7 open models. Values are % except repeated actions (repeated action calls per ToolMaze run). Bold: best. Underlined: second.
Learned checks. Learned contracts raise false alarms that repeat on re-check, so we warn on them. On 80 fresh ToolMaze workflows, withholding on learned checks gave 32.1% task success against 33.5% for warning, a small difference. No learned check reaches the cutoff , so in our runs the rule comes down to withholding on exact checks and warning on learned ones (Table 25 and Table 29).
| AgentOrchBench | Retail | |||||
| Harness action | Wrong | Correct | Unknown | Clean | Wrong | Clean |
| Warning (last condition) | 63.1 | 11.4 | 25.4 | <u>85.5</u> | 71.5 | 35.7 |
| Warning | 70.1 | 14.1 | 15.9 | 86.3 | – | – |
| Warning + tip | 37.2 | <u>9.8</u> | 52.9 | 82.5 | 59.6 | <u>36.9</u> |
| Auto-repair | <u>3.0</u> | 57.3 | 39.7 | 83.3 | 15.0 | 35.7 |
| Answer gate (last condition) | 32.9 | 5.2 | 61.9 | 84.9 | – | – |
| Enforce | 8.8 | 3.0 | 88.2 | 86.3 | <u>12.3</u> | 33.8 |
| SilentGuard | 1.7 | 2.4 | 95.8 | 84.9 | 11.0 | 38.5 |
Table 25. Ablation of the harness action after a failed check (mean over 7 open models, %). Warnings keep wrong answers high. Auto-repair gives the most correct answers but releases wrong ones marked as verified (Table 6). SilentGuard withholds only what an exact check proves wrong. Last condition: these two earlier arms check the last condition only. All other rows use the full check. Warning + tip: the warning also names the recovery tools. Enforce: only checked counts are accepted. Unknown: the answer says the value cannot be determined. –: not run on retail. Bold: best. Underlined: second.
| Cutoff | Min. support | Withheld (%) | Changed |
| 0.1% | 0.0 | 0 | |
| 0.5% | 0.0 | 0 | |
| 1% | 0.0 | 0 | |
| 2% | 4.4 | 108 | |
| 5% | 34.6 | 847 | |
| 10% | 73.0 | 1,788 | |
| 20% | 87.7 | 2,148 |
Table 29. Sensitivity to the cutoff on ToolMaze. A learned check is treated as exact when , that is, when it held on at least the listed number of clean examples. Over all 2,448 withhold-or-warn decisions logged in our ToolMaze runs, the largest support is 52, so every cutoff below 1.85% (1/54) gives the same decisions as 1% (Changed: decisions that differ from 1%). On AgentOrchBench and real APIs every check is exact and the cutoff has no effect.
Auto-Repair Returns Wrong Answers Marked as Verified
On the fault types it was designed for, auto-repair recovers many true counts (57.3% correct, Table 25). To test it on faults it was not designed for, we wrote six new fault types after the method was frozen and ran the harness alone, with no model (Table 6). Where its check fired, the SilentGuard answer rule never released a wrong count. Its 53 wrong answers all come from faults the check cannot see, which every method misses. Auto-repair returned more correct counts (79 against 41) but
also 102 wrong ones, and 49 of its repairs were wrong while marked as verified. A user has no way to tell them apart from correct answers.
Cost and fine-tuning. SilentGuard makes no extra model call. Per faulted run it takes less time than the LLM judge (18.9 s against 47.2 s) but more tokens. A small model fine-tuned to refuse also refuses on unseen fault types, but only when it is shown the harness check (App. § 17).
Conclusion
Silent API failures are common in real services and fool every agent we tested. The fixes in use today leave the decision to the model, which by default reports the number it was given, even when it is told the number is suspect. Evidence of the fault is necessary, and permission to abstain lets some models act on it. Only enforcement by the harness works for every model. Harness builders should give the harness the final say over results that fail an exact check, and repair only fault types the check can confirm. API builders should reject unknown parameters and say when a page was cut. Benchmarks should include faults that repeat.
Limitations
Checks have blind spots. A fault that is consistent with itself (prefix matching) and an API that knows the check (the consistent lie) both pass count checks, and a filter the agent never sends cannot be checked. SilentGuard leaves these wrong.
What “exact” assumes. The count identity assumes two-valued filters. Fields with missing values need the three-way partition of Rigger and Su (2020), which we do not use, and totals that are estimated or change between queries can break the identity. The identity held on all 25 live queries we tried, which is a small sample. The value-swap check compares live counts too. In the value-format study, four wrong answers passed because the total changed slightly between the request and the check. An exact check can also fire when the reported value is right (the ignore-NOT fault breaks the check’s own queries), and those runs are scored as faulted, not clean.
Saying unknown. Under faults, SilentGuard mostly answers that the count cannot be determined. This is the safe answer when the API cannot give a correct one, but it gives the user no number.
Models. Seven open-weight models ran every agent experiment. Three frontier models from one vendor ran six arms of the main benchmark and two of the real-API study. These frontier runs and the control arms of Nemotron-3-Ultra ran on Genentech’s internal platform, so we have their answer counts but cannot release or recount their logs, and we have no hash records for them. Those runs were added after the planned experiments, with no predictions. Seven models limit the power of model-level tests.
Short faults and false alarms. Blind retry beats SilentGuard on faults that clear within one or two calls (§ 5.3), and learned checks cost some clean success on ToolMaze.
Method design. The method went through three versions, and each was tested on fresh data. The 1% cutoff was chosen after seeing earlier results, but any cutoff below 1.85% gives the same decisions.
Benchmarks. Our fault injectors run on our own APIs. The real-API probes show that ignored filters, silently capped pages and ignored filter values occur in practice. The other fault types are not measured in real APIs. On a further benchmark (-bench) SilentGuard tied the published methods (App. J).
Ethics Statement
The real-API study sent read-only GET requests, about one per second, with no credentials and no personal data. Our fault injectors run only on local test services. All benchmark records are synthetic, and no company or patient data was used in this work.
Code and Data Availability
Code, fault injectors, the AgentOrchBench and retail services with their synthetic data, all tasks, the prediction log and the code hashes are at https://github.com/Sajib-006/silentguard (Apache-2.0). The AgentOrchBench tasks are also at https://huggingface.co/datasets/Sajib-006/AgentOrchBench (CC-BY-4.0). The logs of all runs outside Genentech’s internal platform are available from the authors on request. ToolMaze and -bench are public benchmarks from their authors. The real-API study used only public, read-only endpoints.
Acknowledgments
We thank the Genentech CS CoE DDC team for their support and feedback, and the 2026 Genentech summer internship program, where this work began. We also thank Nick Pierce, formerly of Genentech, for MCP server development and integration with enterprise data and processing systems. His MCP servers were the starting point that this project adopted.
Benchmark Details
This section gives the tasks, faults and grading of each benchmark.
AgentOrchBench
Agent protocol. The agent solves one task per run. In each turn it writes exactly one of RUN: <one curl command> or ANSWER: <answer>, and after each RUN it receives the HTTP status and the response body. Pipes, other shell commands and file access are not allowed. All eight local services (among them a sample registry, a metadata catalog and a task tracker, on ports 8001 to 8008) are reset before every task, so runs do not affect each other.
Tasks. The 36 count tasks each ask how many of the 400 catalog records match two (15 tasks) or three (21 tasks) conditions, for example “How many catalog assets have QC_Status=qc-pass AND Sample_Type=tumor? Return: count=<n>”. The ground truth is computed from the seed data. The records are synthetic, so no model can know a count from its training data.
Fault injection. Faults are switched on inside the catalog server for a whole run. The server echoes the fault mode back, and the runner refuses to start if the echo does not match, so a run can never use the wrong fault. Every fault returns HTTP 200 and a well-formed body, and repeats on every call. The catalog returns only the count (total_count), as a real aggregation endpoint does. With full records returned, a model could check the filter by reading them. Table 7 lists the fault types and the kind of bug each is modeled on.
Grading. We read the number after count= or in the ANSWER line. An answer is correct if it equals the ground truth, unknown if it states that the count cannot be determined or gives no count, and wrong otherwise. Confidence values, task identifiers and numbers quoted from the question are not read as counts. The grader is the same for every method and was frozen before the planned runs.
List tasks. The 30 list tasks ask for the item_id of every matching record (“List the item_id of every catalog asset that has Batch_ID=batch_1 AND File_Format=fastq. Return: ids=<comma-separated item_ids>”), graded as a set. The faults are six types used in design (drop last, ignore field, AND→OR, prefix, consistent lie, cap total) and five written after the method was frozen (word-stem text match, tag-join double counting, partial shard timeout, lossy index, cursor ties). An empty list counts as no answer, not as a wrong one.
Retail domain. The retail domain is a second schema, an orders API with four services (ports 8001 to 8004), 30 count tasks and four fault types (drop last, cap total, AND→OR, ignore field), with the same protocol, grading and clean runs.
Real Public APIs
Probes. For each of 15 public research APIs we sent an unfiltered query, the documented filtered query, and two or three plausible wrong filter names, all as read-only GET requests at about one request per second (Table 8). Figure 3 shows the overcounts.
Agent study. On nine of these APIs agents answer five count tasks each, given either the right documentation or documentation with one filter name slightly wrong. Every wrong name was measured to be silently ignored. The ground truth
| API | Returned | Correct | Over | Caught |
| Misnamed filter ignored (HTTP 200) | ||||
| ChEMBL | 2,921,148 | 4,225 | 691× | 3/3 |
| UniProtKB | 55,460 | 666 | 83× | 3/3 |
| arXiv | 186,698 | 2,799 | 67× | 2/2 |
| NCBI gene | 37,885 | 1,567 | 24× | 3/3 |
| Europe PMC | 291,095 | 15,436 | 19× | 3/3 |
| Zenodo | 110,913 | 25,549 | 4× | 2/3 |
| GitHub search | 55,661 | 17,225 | 3× | 2/2 |
| DataCite | 609,191 | 216,660 | 3× | 2/3 |
| GBIF | 31,660 | 11,681 | 3× | 3/3 |
| iNaturalist | 18,185 | 11,212 | 2× | 3/3 |
| Misnamed filter rejected (error) | ||||
| ClinicalTrials.gov | 24,424 | 1,963 | – | – |
| OpenAlex | 611,853 | 37,622 | – | – |
| Crossref | 89,634 | 4,268 | – | – |
| openFDA | 617,937 | 435,397 | – | – |
| Semantic Scholar | 214,821 | – | – | – |
caption: tbl:8: Real-API probes. Of 15 public APIs, 10 answer a request with a plausibly misnamed filter with HTTP 200 and the unfiltered count (ignored). The others reject the unknown parameter with an error (rejected). Returned: the count with the misnamed filter, or the unfiltered count when the API rejected it. Correct: the count with the documented filter. Over: returned / correct. Caught: misnamed filters flagged by the value-swap check (swap the filter’s value, an ignored filter returns the same count). –: not applicable, or not measured (rate limit).
:::
is the documented query’s count, taken right before and right after each run. The first four APIs (NCBI, UniProt, Europe PMC, GBIF) were chosen before the method was frozen. The other five (Zenodo, ChEMBL, arXiv, DataCite, iNaturalist) were added later, with the method unchanged. Zenodo, ChEMBL and DataCite place the total after the record list, and the agent sees the first 1,500 characters of a response, so for these three the JSON is shown with the object that holds the total first (nothing removed or changed). Table 9 gives each API and Table 10 each model, with the three frontier models.
Other silent faults. We also probed every API for two more fault kinds, a typo in the value of a valid filter and a request for more records per page than allowed (Table 11). On the three APIs that silently ignore a bad value we then tested, with no model, whether a check fires on the query an agent would send (Table 12).
Wrong value format. To test a real fault that the spec check cannot see, we gave agents iNaturalist documentation with a valid parameter (d2, observed on or before a date) but the wrong date
| Wrong↓ | Correct↑ | ||||
| API | None | Retry | Ours | None | Ours |
| NCBI gene | 86 | 91 | 57 | 6 | 29 |
| UniProtKB | 80 | 83 | 40 | 6 | 51 |
| Europe PMC | 91 | 97 | 51 | 0 | 26 |
| GBIF | 94 | 91 | 6 | 0 | 94 |
| Zenodo | 100 | 91 | 3 | 0 | 83 |
| ChEMBL | 100 | 94 | 0 | 0 | 100 |
| arXiv | 71 | 80 | 29 | 20 | 63 |
| DataCite | 97 | 86 | 6 | 0 | 80 |
| iNaturalist | 89 | 91 | 0 | 0 | 100 |
caption: tbl:9: Real-API agent study per API, wrong documentation (% of runs, 7 models pooled, 35 runs per API and arm). The four APIs above the line were chosen before the method was frozen. The five below were added later, with the method unchanged. On NCBI, UniProt, Europe PMC and arXiv the correct filter goes inside a query-language string that the wrong documentation never mentions, so after the spec check rejects the misnamed parameter the agent must find that syntax itself. On the others the correct parameter is in the list of allowed parameters that the spec check returns, which is the most likely reason for the gap. None: no guard. Retry: blind retry. Ours: SilentGuard (bold).
:::
| No guard | SilentGuard | Right docs | ||
| Model | Wrong↓ | Wrong↓ | Corr.↑ | Corr.↑ |
| Llama-4-Scout | 97.8 | 35.6 | 48.9 | 97.8 |
| Llama-4-Maverick | 93.3 | 6.7 | 93.3 | 100.0 |
| Llama-3.3-70B | 100.0 | 28.9 | 68.9 | 97.8 |
| gpt-oss-120b | 80.0 | 11.1 | 88.9 | 100.0 |
| Nemotron-3-Ultra | 100.0 | 20.0 | 80.0 | 100.0 |
| Gemma-3-27B | 62.2 | 22.2 | 40.0 | 53.3 |
| Phi-4 | 95.6 | 24.4 | 66.7 | 95.6 |
| Mean, open | 89.8 | 21.3 | 69.5 | 92.1 |
| GPT-5.6 Sol | 48.9 | 8.9 | 91.1 | 100.0 |
| GPT-5.6 Terra | 48.9 | 8.9 | 91.1 | 100.0 |
| GPT-5.6 Luna | 75.6 | 8.9 | 88.9 | 100.0 |
| Mean, frontier | 57.8 | 8.9 | 90.4 | 100.0 |
caption: tbl:10: Agents on nine real public APIs, per model (45 runs per model and cell, %). No guard and SilentGuard: agents given slightly wrong documentation. Right docs: % correct with no guard and the right documentation. The frontier models ran these two arms only.
:::
format (DD/MM/YYYY). The API silently ignores such a date and returns the unfiltered count. The harness was the frozen one. With no guard and with the spec check alone almost every answer was wrong (97.1% and 100.0%). SilentGuard left 20.0% wrong, 77.1% unknown and only 2.9% correct. That is less recovery than we predicted (Table 13, and V4 in Table 31). Of its seven wrong answers, four passed the value-swap check because the live total changed slightly between the request and the check, and three came from one model that, after the withhold, switched to a different valid filter (the year). For this study the backend of Gemma-3-27B was named explicitly, because automatic routing had stopped selecting one.
| ID | Prediction, written before the run | Observed | Outcome |
| A1 | SilentGuard blind retry on lasting faults (ToolMaze P4) | 24.4 vs 27.0 | failed |
| A2 | SilentGuard blind retry on one-time faults (P3) | 47.6 vs 60.4 | failed |
| A3 | Blind retry repeats action calls | 2.36 vs 0.24 per run | held |
| B1 | Loud faults: SilentGuard within 3 points of Checklist + OM | 39.8 vs 39.8 | held |
| C1 | AgentOrchBench wrong within 5 points of Enforce | 1.7 vs 8.8 | failed |
| C2 | AgentOrchBench correct answer gate | 2.4 vs 5.2 | held |
| D1 | Checklist, Reviewer, Outcome Monitors all above 40% wrong | 72.3, 73.8, 72.2 | held |
| D2 | SilentGuard fewer wrong than each published method on 7/7 models | 7/7, 7/7, 7/7 | held |
| D3 | Outcome Monitors within 10 points of no guard | 72.2 vs 74.0 | held |
| E1 | Retail: wrong and clean within 5 points of Enforce | 11.0/38.5 vs 12.3/33.8 | held |
| F1 | Real APIs (first 4): wrong best single check , and correct spec check | 38.6 vs 35.7; 50.0 vs 51.4 | held |
| R1 | AgentOrchBench: blind retry within 5 points of no guard | 74.4 vs 74.0 | held |
| R2 | AgentOrchBench: re-query within 10 points of no guard | 74.9 vs 74.0 | held |
| R3 | SilentGuard fewer wrong than blind retry on 7/7 models | 7/7 | held |
| BR1 | Two-call fault: blind retry within 5 points of no re-check | 56.0 vs 32.5 | failed |
| BR2 | Two-call fault: SilentGuard blind retry | 46.4 vs 56.0 | failed |
| BR3 | Real APIs (first 4): blind retry within 5 points of no guard | 90.7 vs 87.9 | held |
| L1 | Lists: SilentGuard wrong within 3 points of checked lists only (seen, unseen) | 9.5/11.4 vs 13.1/13.7 | failed |
| L2 | Lists: SilentGuard fewer wrong than no guard and auto-repair (seen, unseen) | 9.5/11.4 vs 51.0/40.0, 17.0/19.7 | held |
| L3 | Lists: clean correct within 5 points of no guard | 82.2 vs 77.8 | held |
| K1 | Judge + blocking has more wrong answers than SilentGuard on 6/6 models | 6/6 | held |
| K2 | Outcome Monitors + blocking within 10 points of Outcome Monitors (wrong) | 69.4 vs 70.8 | held |
| K3 | Judge + blocking clean correct at least 10 points below no guard | 78.7 vs 82.6 | failed |
| P1 | Judge + blocking without check results: at least 20 points more wrong than with them | 69.4 vs 6.1 | held |
| P2 | Judge + blocking without check results: clean correct within 10 points of with them | 81.2 vs 78.7 | held |
| X1 | Judge without check results, advising: wrong within 10 points of no guard | 70.4 vs 73.0 | held |
| X2 | Judge in four settings: evidence and blocking at least 40 points below each other cell | 6.1 vs 70.4, 69.4, 69.8 | held |
| X3 | Warning (last-condition check) + permission: fewer wrong than the warning alone, but more than 20% | 11.9 vs 61.3 | failed |
| Y1 | Full-check warning + permission: wrong on ignore field below 15% | 19.2 | failed |
| Y2 | Full-check warning + permission: overall wrong between 3 and 8% | 19.6 | failed |
| Y3 | Full-check warning + permission: more wrong than SilentGuard on at least 4 of 6 models | 5/6 | held |
| T1 | Typed tool calls: wrong within 5 points of the spec check (real APIs) | 28.6 vs 21.0 | failed |
| T2 | Typed tool calls: more than 30% wrong on NCBI, UniProt and Europe PMC | 86, 37, 57 | held |
| T3 | Typed calls + SilentGuard: no more wrong than typed calls on at least 6 of 7 models | 4/7 | failed |
| V1 | Wrong value format (iNaturalist): no guard wrong at least 80% | 97.1 | held |
| V2 | Wrong value format: spec check alone within 10 points of no guard (wrong) | 100.0 vs 97.1 | held |
| V3 | Wrong value format: SilentGuard wrong at most 20% and at least 50 points below the spec check | 20.0 vs 100.0 | held |
| V4 | Wrong value format: SilentGuard correct at least 50% | 2.9 | failed |
| V5 | Wrong value format: no guard with the right docs correct at least 85% | 88.6 | held |
Table 31. Predictions of the confirmatory experiments, written down before each run, and their outcomes (26 of 39 held). All were written, with the method frozen by file hashes, before the runs. Failed predictions (bold red) are reported and discussed in the text (§ 5.3). IDs are the labels used in the prediction log. Observed values are means over the 7 open models (%), or the number of models with fewer wrong answers. Rows L, K, P, X and Y use the 6 models the predictions were written for, so their no-guard values differ slightly from the 7-model tables. Within points: the absolute difference is at most . The rows from L down are control runs added after the first results. Each was written before its own run.
Count identity on final queries. We also replayed, with no model, the final query of the SilentGuard runs of the agent study on the 6 APIs that take a query string. We could replay 60 wrong answers. Adding the count identity would have caught 8 of them. In 14 the final query had a single term, so the agent had dropped the second condition. In 38 the identity held, because the agent had written a different query that is consistent with itself, for example plain words in place of a field. No check built from the API’s own answers can see those. On 49 correct answers with two or more terms the identity raised 0 false alarms.
Which operations allow which check.
From the documentation of 13 public APIs, we classified 84 operations by the checks they allow (Table 14). Every search or list operation allows an exact check, while lookups by ID mostly allow only the spec check.
| Operation kind | Operations | Exact check |
| Search or list | 43 | 43 |
| Get by ID | 16 | 5 |
| Other read | 9 | 4 |
| Aggregate | 6 | 5 |
| Write | 5 | 0 |
| Pagination | 4 | 3 |
| Count | 1 | 1 |
| Total | 84 | 61 |
Table 14. Which checks real API operations allow, read from the documentation of 13 public APIs. Exact check: the operation allows a record-membership check (47 operations), the count identity (25) or a value swap (56). All 84 have a published parameter list, so the spec check applies to every one. The APIs are those of Table 8 without GitHub and openFDA. Write operations were not counted as allowing the write-then-read check of Table 1. These are well-documented APIs. The share will be lower for undocumented or free-text tools.
ToolMaze
ToolMaze (Zhu et al., 2026) has multi-step tool workflows at four complexity levels, with five modes. These are no fault (P0), explicit errors (P1, P2), a silent fault on the first call to a tool (P3) and a silent fault on every call (P4). We used its tools, tasks, fault injector and trace judge unchanged, and ported every method into its agent loop. Method design used separate workflows. All ToolMaze numbers in the paper come from 180 workflows that were never used in design, drawn with a fixed seed. The first 80 were the test set of the second method version, whose behavior on ToolMaze (re-check, then warn) is the same as that of the final version and was fixed before they were run. The other 100 were first used to test the final version. For the two-call test we changed one line of the fault injector so the P3 fault lasts the first two calls to the tool. Tasks, judge and arms are otherwise the same.
Harness fix. Models sometimes wrote several tool calls in one reply. ToolMaze’s loop runs only the first but stored the whole reply, so the model later saw calls it believed had run. We stored each reply only up to its first tool call. The fix applies to every method, and all affected runs were deleted and run again.
Implementation of SilentGuard
This section gives the checks, the cutoff rule and the exact messages the agent sees.
Count check. For a filter query that returns , the harness checks each position . It queries the other conditions without (count ) and with (count ), and tests . That is extra queries per filter call (at most 6 here). On any API that applies AND and NOT correctly the identity holds, so the check cannot fire on a correct count. A fault that keeps the identity true (prefix matching, a consistent lie) passes it. A fault that breaks the negation queries themselves (ignore NOT) makes the check fire although the reported count may be right.
Spec check and value-swap check. When an API publishes its parameter list, a request with a parameter outside the list is stopped before it runs, and the agent gets an error instead of a silently wrong result. For a parameter that is in the list, the harness re-issues the query with the filter’s value swapped. If the count does not change, the filter was ignored.
Learned checks. On ToolMaze we used the Outcome Monitors contract miner (Panthi and Abdelfattah (2026)), which covers presence and type, echoed arguments, positive values, categorical values, linear relations and date order. Contracts are mined from clean responses of other workflows with 5-fold cross-fitting by task, so a contract is never mined on the workflow it checks.
Cutoff. A check that held on clean examples gets the false-alarm estimate (rule of succession). Exact identities and the spec check count as . If any failed check has an estimate of at most the cutoff , the failed values are withheld. Otherwise the result stays visible with a warning. With the few clean examples ToolMaze provides, no learned contract reaches the cutoff, so on ToolMaze SilentGuard always warns.
Messages shown to the agent. After a count fails the check twice, the agent sees the response with the count removed and the following note.
total_count withheld: this result failed an exact consistency check twice (the harness already re-ran the request). Do not guess the count; re-query differently, or answer that the count cannot be determined.
If the agent then answers with a count that did not pass the check, the harness replies (at most twice, after which it answers that the count cannot be determined) as follows.
HARNESS: answer rejected. The count you report is not the count of a query that passed the consistency check. Re-query in a way that yields a verified count, or answer that the count cannot be determined.
A count is treated as verified only if it came from a query that passed the check and that has at least as many conditions as any other query in the run. This stops a check passed on a looser query from backing a count for the full filter.
Result checklist. SilentGuard adds this checklist, written in the style of Sun et al. (2024), to the system prompt.
RESULT CHECKLIST. Before you use any tool result, check it against this list: 1. Presence and type: every field you need is present and has the right type. 2. Agreement with your request: values that repeat your request (IDs, names, dates, codes) match what you asked for. 3. Plausibility: numbers and categories are sensible (for example, no negative prices or impossible values). 4. Consistency: the result does not contradict itself and is about what you asked. If any check fails, treat the result as incorrect: retry the tool, use another tool that can do the same step, or stop and report which step failed.
Baselines and Published Methods
All methods run in the same harness, with the same models, tasks, decoding settings and turn limits. Each prompt follows the design of the cited paper and is adapted to our tasks. We say below which text is the authors’ own.
Checklist (Sun et al., 2024). This arm adds the result checklist above to the system prompt. The source uses task-specific checklists, and ours is a general one in the same style.
Reviewer (Ta et al., 2026). Before each tool call runs, the agent’s own model reviews it, and the agent may revise the call (up to five review loops, as in the source). The source uses a separate reviewer model and its own prompts. We wrote the prompt below for our tasks, following their design.
You are a reviewer agent. A primary assistant is carrying out a user’s task with tools. Before its provisional tool call is executed, decide whether the call is correct. Check the call against the user request, the tool documentation, and the whole conversation so far, including earlier tool results. Look for: a wrong tool, wrong or made-up arguments, arguments copied from a tool result that is wrong or inconsistent, skipped or repeated steps, and continuing when the workflow should stop. [...] Reply with JSON only.
Outcome Monitors (Panthi and Abdelfattah, 2026). Contracts are mined as above. A response that breaks one gets the authors’ non-binding advisory below, with “the retail database” replaced by “this API”.
[OUTCOME CONTRACT ADVISORY] The observed result [...] is inconsistent with a known invariant of this API. Violation: [...]. This advisory is nonbinding. Treat the result as unreliable and verify or recover using the available documented tools and task context before relying on it.
On AgentOrchBench, contracts are mined from clean responses of other tasks, 5-fold by task.
LLM judge. This is our own baseline, an LLM judge in the sense of Zheng et al. (2023). After each filter query, a fixed judge model (gpt-oss-120b, the same for every agent) sees the task, the request filters, the response and the results of the harness’s own consistency queries, and returns TRUSTWORTHY or SUSPECT with a reason, which is appended to the response. We first tried a smaller judge (GPT-4o-mini). It called correct responses suspect even when given the passing check numbers, so we used the stronger judge to keep the baseline fair.
Controls for evidence, permission and enforcement. LLM judge, no check results uses the same judge and prompt, but the judge sees only the task, the request filters and the response, not the harness’s consistency queries. With + blocking, a result the judge calls SUSPECT (or that breaks an Outcome Monitors contract) is withheld, and the final count must come from a result the detector accepted, with the same two-rejection answer rule as SilentGuard. Warning + may abstain combines the warning of the full count check (the check SilentGuard uses, which names the failed condition and shows no numbers) with the caution prompt below, which allows the answer that the count cannot be determined. An earlier version used the last-condition check and a warning that shows the check’s numbers. It gave 63.1% wrong for the warning alone and 12.1% with permission, but misses a filter ignored at another position. These ran on 7 models with 2 seeds (Nemotron-3-Ultra on Genentech’s internal platform with the same code and grader, counts only).
Caution prompt. This text is added to the system prompt.
IMPORTANT: tool and API outputs are not always reliable. An API can return HTTP 200 with wrong data, for example by silently ignoring part of your request. Do not blindly trust a response. Before answering, check that each response is consistent with what you asked for; if you cannot confirm it, say the count cannot be determined instead of reporting a number.
Self-verification. The model is told the same every-position check the harness runs and must run it itself before reporting a count, or answer that the count cannot be determined. This shows the effect of who runs the check, the model or the harness.
Re-query and blind retry. Re-query sends the same query a second time and shows both counts. Blind retry sends every request twice and shows only the second response. On ToolMaze it is added to the checklist with Outcome Monitors, so it differs from that arm only by the retry.
Harness actions (ablations). These differ in the action after a failed count check. Warning appends the check result, and warning + tip also names the recovery tools. The answer gate rejects an answer that repeats a flagged count twice and then answers unknown. Enforce accepts only checked counts. Auto-repair recomputes the count through separate routes and shows it only if a route passed its own check. Three earlier arms, warning (last condition), its variant with may abstain and the answer gate, check the last condition only. All others use the full check.
Models, Inference and Statistics
This section gives the models, the inference settings and the statistical tests.
Models. Llama-4-Scout (17B-16E) and Llama-4-Maverick (17B-128E, FP8) (Meta, 2025), Llama-3.3-70B (Meta, 2024), Nemotron-3-Ultra (550B-A55B) (NVIDIA, 2026), Gemma-3-27B (Kamath et al., 2025) and Phi-4 (14B) (Abdin et al., [1]) were served through Hugging Face Inference Providers, with one backend pinned for Llama-3.3-70B. The model gpt-oss-120b (OpenAI, 2025) was served by an endpoint hosted by Virginia Tech Advanced Research Computing (ARC). For the two-call ToolMaze test, Gemma-3-27B and Phi-4 ran on ARC GPUs with vLLM (Kwon et al., 2023) (same weights) and Llama-3.3-70B on a second provider backend. GPT-5.6 Sol, Terra and Luna (OpenAI, 2026) ran the real-API study on the OpenAI API and AgentOrchBench on Genentech’s internal platform. They do not accept temperature 0 and sample at the provider default. Three older GPT models (GPT-4.1, GPT-4o, GPT-4o-mini) finished only part of their runs because of API budget limits (Table 19).
Settings. We used temperature 0 (the provider default for the GPT-5.6 models), at most 2,000 output tokens per turn, at most 16 turns (25 on ToolMaze) and identical prompts for every model. Every API call has client-side rate limits and retries with back-off. A run whose calls failed at the provider is marked, excluded from grading and run again. A few runs still failed after the rerun and are left out (at most 7 of 504 for any model and method).
Statistics. The unit of analysis is the model, because runs of one model share tasks and are not independent. Tables report the mean over models with the standard error of that mean, and 95% confidence intervals ( interval over models) are in Table 18. Differences are tested with an exact two-sided sign-flip test over models, which lists all sign patterns and assumes nothing about the distribution. With 7 models the smallest possible is , so we read it as a count of how many models agree, not as a test that survives correction for many comparisons. For the key differences we also report a task-cluster bootstrap. Each of 2,000 resamples draws the benchmark’s tasks with replacement, the same draw for every model and arm, and recomputes the mean over models (Table 15).
| Measure | Against | Difference [95% interval] |
| AgentOrchBench | ||
| wrong | No guard | −72.3 [−74.0, −70.5] |
| wrong | Self-verification | −54.5 [−56.6, −52.3] |
| wrong | LLM judge | −69.5 [−71.3, −67.7] |
| wrong | Outcome Monitors | −70.4 [−72.3, −68.3] |
| wrong | Blind retry | −72.7 [−74.7, −70.5] |
| wrong | Enforce | −7.1 [−8.5, −5.6] |
| correct | No guard | −13.9 [−14.6, −13.2] |
| correct | Auto-repair | −54.8 [−56.6, −52.9] |
| Real APIs (9) | ||
| wrong | No guard | −68.6 [−77.1, −59.4] |
| wrong | Blind retry | −68.3 [−75.2, −60.3] |
| wrong | Spec check alone | +0.3 [−2.5, +3.2] |
| correct | No guard | +66.0 [+57.1, +74.6] |
| correct | Spec check alone | −1.3 [−4.4, +1.9] |
| ToolMaze | ||
| success | Checklist + OM | +3.3 [+1.8, +4.9] |
| success | Outcome Monitors | +5.5 [+3.5, +7.5] |
| success | Checklist | +12.9 [+10.1, +15.6] |
Table 15. Task-cluster bootstrap for the key differences (SilentGuard minus the other method, in percentage points, computed before rounding). We used 2,000 resamples of tasks, the same draw for every model and method, and the mean over 7 open models. An interval that excludes 0 means the difference holds across tasks, not only on average. OM: Outcome Monitors.
| Retail domain | Wrong | Correct | Clean |
| No guard | [54.3, 100.0] | [1.3, 13.1] | [8.1, 64.3] |
| Auto-repair | [5.2, 24.8] | [5.9, 55.0] | [6.9, 64.6] |
| Enforce | [2.9, 21.6] | [1.0, 12.1] | [5.8, 61.9] |
| SilentGuard (ours) | [4.1, 17.8] | [2.3, 11.9] | [10.3, 66.6] |
| Real APIs (9) | Wrong | Correct | Right docs |
| No guard | [76.9, 100.0] | [0.0, 10.4] | [76.2, 100.0] |
| Blind retry | [75.3, 100.0] | [0.0, 9.3] | [79.5, 100.0] |
| Spec check alone | [9.8, 32.1] | [54.0, 87.6] | [76.2, 100.0] |
| Typed calls | [17.3, 39.9] | [52.5, 80.2] | [77.7, 100.0] |
| Typed calls + ours | [15.9, 40.6] | [51.9, 78.9] | [80.4, 100.0] |
| SilentGuard (ours) | [12.1, 30.5] | [51.2, 87.9] | [74.6, 100.0] |
| ToolMaze | Silent | Loud | Clean |
| Checklist | [15.1, 31.3] | [28.0, 48.6] | [45.5, 65.6] |
| Outcome Monitors | [27.3, 33.7] | [35.2, 46.2] | [48.3, 66.0] |
| Checklist + OM | [27.4, 38.1] | [33.3, 46.2] | [44.7, 64.9] |
| Blind retry | [39.4, 48.0] | – | [47.8, 60.6] |
| SilentGuard (ours) | [29.9, 42.1] | [32.7, 46.9] | [42.1, 62.9] |
Table 18. 95% confidence intervals for Tables Table 3 and Table 4 ( interval over models, clipped to [0, 100]).
Full Results
Table 17 gives every method on AgentOrchBench by fault type, with correct and unknown shares, and Figure 4 shows the same outcomes. Table 18 gives the confidence intervals of the main tables. Table 19 and Table 20 and Figure 5 and Figure 6 give the results per model, including the partial runs of three older GPT models. Table 21 covers all ToolMaze modes, and Table 22 and Table 23 with Figure 7 compare blind retry with the re-check. Table 24 gives the real-API agent study with each check alone, and Table 25 the harness actions.
Figure 4. All answers under silent faults on Agent-OrchBench, mean over 7 open models. Prompts and model-based methods leave most answers wrong. Harness actions that go beyond a warning move them out of the wrong share, and under SilentGuard nearly all become unknown.
Figure 5. Wrong answers per model on AgentOrchBench, no guard against SilentGuard. Every model falls to below 4%.
| Method | Drop last | Cap total | AND →OR | Ignore field | Ignore NOT one | Off by one | Wrong↓ | Correct↑ | Unknown | Clean↑ |
| No guard | 89.7 | 92.9 | 89.3 | 77.4 | 6.2 | 88.9 | ||||
| Caution prompt | 88.3 | 91.3 | 87.7 | 75.4 | 4.6 | 92.9 | ||||
| LLM judge | 88.7 | 91.7 | 84.7 | 73.0 | 6.2 | 82.9 | ||||
| Checklist | 87.7 | 90.7 | 87.7 | 73.4 | 4.8 | 89.3 | ||||
| Reviewer | 91.9 | 88.3 | 88.1 | 76.0 | 8.5 | 90.1 | ||||
| Outcome Monitors | 89.3 | 90.3 | 87.1 | 72.0 | 6.3 | 87.9 | ||||
| Blind retry | 92.3 | 91.3 | 91.7 | 76.0 | 3.4 | 92.1 | ||||
| Re-query | 91.1 | 92.3 | 91.5 | 79.4 | 3.4 | 91.7 | ||||
| Self-verification | 71.8 | 72.8 | 52.8 | 63.9 | 5.2 | 70.8 | ||||
| Warning (last condition) | 71.8 | 74.0 | 66.9 | 68.8 | 33.5 | 63.7 | ||||
| Warning + tip | 45.6 | 56.3 | 29.8 | 41.7 | 7.9 | 42.1 | ||||
| Auto-repair | 1.2 | 3.2 | 2.6 | 4.0 | 2.4 | 4.6 | ||||
| Answer gate (last cond.) | 32.3 | 27.4 | 32.3 | 56.5 | 25.6 | 23.2 | ||||
| Enforce | 7.1 | 15.5 | 4.6 | 7.1 | 9.5 | 8.9 | ||||
| Judge + blocking | 15.7 | 5.6 | 4.2 | 3.0 | 2.8 | 5.2 | ||||
| OM + blocking | 87.3 | 86.1 | 89.7 | 73.2 | 3.6 | 85.5 | ||||
| Judge, no evidence, + blocking | 87.9 | 86.7 | 87.5 | 73.4 | 3.0 | 86.3 | ||||
| Judge, no evidence | 86.5 | 86.9 | 87.5 | 73.0 | 4.4 | 92.1 | ||||
| Warning (last cond.) + may abstain | 6.2 | 4.2 | 8.3 | 44.8 | 4.0 | 4.8 | ||||
| Warning | 82.7 | 83.9 | 80.8 | 73.2 | 19.2 | 80.6 | ||||
| Warning + may abstain | 23.8 | 23.6 | 16.3 | 17.7 | 6.5 | 21.2 | ||||
| SilentGuard | 1.6 | 2.0 | 1.4 | 2.6 | 1.4 | 1.4 |
Table 17. AgentOrchBench, all methods (mean over 7 open models, %, ± standard error). Wrong, correct and unknown are shares of the runs with a silent fault. Clean is % correct with no fault. Auto-repair has the most correct answers but its wrong answers are released as verified (Table 6). Last condition: the earlier check of the last condition only. All other harness rows use the full check. No evidence: the judge does not see the consistency queries. OM: Outcome Monitors.
Figure 6. ToolMaze task success under silent faults per model, for the checklist with Outcome Monitors against SilentGuard. SilentGuard is ahead on 5 of 7 models.
Figure 7. ToolMaze task success by fault type for no re-check, blind retry and SilentGuard. Blind retry leads while the fault clears and not when it lasts.
| Method | P3 | P4 | P3+P4 | P0 | P1+P2 |
| Checklist | 26.8 | 19.5 | 23.2 | 55.5 | 38.3 |
| Outcome Monitors | 36.3 | 24.8 | 30.5 | 57.1 | 40.7 |
| Checklist + OM | 39.9 | 25.6 | 32.7 | 54.8 | 39.8 |
| Blind retry | 60.4 | 27.0 | 43.7 | 54.2 | – |
| SilentGuard | 47.6 | 24.4 | 36.0 | 52.5 | 39.8 |
Table 21. ToolMaze, all modes (% task success by its own judge, mean SE over 7 models, 180 fresh workflows). P3: silent fault on the first call. P4: silent fault on every call. P0: no fault. P1, P2: explicit errors. Blind retry was not run on P1/P2.
| Model | No re-check | Blind retry | SilentGuard |
| Llama-4-Scout | 32.8 | 60.0 | 50.6 |
| Llama-4-Maverick | 31.7 | 56.1 | 47.2 |
| Llama-3.3-70B | 32.2 | 66.1 | 57.2 |
| gpt-oss-120b | 36.4 | 51.2 | 43.4 |
| Nemotron-3-Ultra | 38.9 | 65.6 | 53.9 |
| Gemma-3-27B | 12.2 | 34.4 | 22.8 |
| Phi-4 | 43.3 | 58.9 | 50.0 |
Table 23. ToolMaze short fault lasting two calls, per model (% task success, 180 workflows, runs whose model calls failed at the provider are left out). No re-check: the checklist with Outcome Monitors.
| Method | Wrong | Correct | Unknown | Right docs |
| No guard | 89.8 | 3.5 | 6.0 | 92.1 |
| Blind retry | 89.5 | 3.2 | 4.8 | 93.0 |
| Value-swap check alone | 17.8 | 25.7 | 55.2 | 91.1 |
| Spec check alone | 21.0 | 70.8 | 7.0 | 92.1 |
| SilentGuard | 21.3 | 69.5 | 7.9 | 92.4 |
Table 24. Agents on nine real public APIs, mean standard error over 7 open models (45 runs per model, method and documentation). Wrong, correct, unknown: % of runs with slightly wrong documentation (the rest ran out of turns with no answer). Right docs: % correct with the right documentation. Value-swap check alone: the harness withholds a count whose filter had no effect, with no spec check. It leaves the fewest wrong answers but few correct ones. The spec check does most of the work, because it rejects the misnamed filter and the agent rewrites the query.
Withholding against Enforce. SilentGuard and Enforce both accept only checked counts. Enforce leaves the failed count in view, and agents then keep re-querying until some other query passes the check and report its count. Of Enforce’s 266 wrong answers, 130 follow this pattern, against 13 of 52 for SilentGuard, which removes the value.
Predictions and Method History
Every planned experiment was written down with its predictions before it ran, and the code was frozen by file hashes, so runs refuse to start if the code changed. The prediction log and the hash files are in the code repository. We kept every result, including failed predictions. Of the 39 predictions of the planned experiments, 26 held (Table 31). The count leaves out the earlier ToolMaze design studies, which shaped the method, and -bench (App. J). Four failed predictions were about blind retry on ToolMaze (§ 5.3). Two failed because SilentGuard did better than predicted (C1 on counts, and L1 on lists for the 6 models it was written for, while on all 7 models its gaps of 2.1 and 0.2 points are within the predicted 3), one because the LLM judge with blocking raised fewer false alarms than we expected (K3), and two because typed tool calls did worse than the spec check and adding SilentGuard to them did not help (T1, T3). Three were about permission to abstain. With the last-condition check it worked better than we predicted (X3), and with the full check worse (Y1, Y2). One was about recovery in the value-format study (V4).
The method had three versions. The first withheld a flagged result at once. On ToolMaze it beat Outcome Monitors on average but not on every model. The second added the harness re-check, which raised success on one-time faults but lost when withholding blocked good data after a false alarm of a learned check. The final SilentGuard sets the action from the check’s estimated false-alarm rate. Each version was tested only on ToolMaze workflows it had never seen, and SilentGuard was frozen before its planned runs on AgentOrchBench, the retail domain, real APIs and the controls. The 1% cutoff was chosen after the second version, which we list as a limitation. An earlier pilot sweep, with a stricter grader and other fault settings, led to the answer rule. Its numbers are not comparable with Table 3 and are kept in our run logs. The frontier-model runs were added last and had no predictions.
List Answers
To test a second kind of answer, the 30 list tasks ask for the IDs of all matching records instead of a count (Table 26), using the record checks of Table 1. With SilentGuard, wrong lists fall from 49.3% to 9.1% on fault types seen in design and from 37.8% to 11.5% on five fault types written later, the fewest of any harness action, and clean-task accuracy is 84.8% (80.5% with no guard). Correct lists fall too, from 56.7% to 7.1% on unseen faults. Auto-repair,
| Seen faults | Unseen faults | Clean | |||
| Method | Wrong | Corr. | Wrong | Corr. | Corr. |
| No guard | 49.3 | <u>43.7</u> | 37.8 | 56.7 | 80.5 |
| Auto-repair | 14.6 | 47.9 | 16.9 | 37.5 | <u>81.0</u> |
| Checked lists only | <u>11.2</u> | 22.1 | <u>11.7</u> | 7.5 | <u>81.0</u> |
| SilentGuard | 9.1 | 21.1 | 11.5 | 7.1 | 84.8 |
Table 26. The same rule gives the fewest wrong lists. The 30 tasks ask for the IDs of all matching records. Six fault types were seen in design and five were written later (unseen). The record checks test that every returned record meets the filter, that no record repeats, and that the list matches the reported total and the count identity. Checked lists only: the answer rule alone. SilentGuard adds the re-check, withholding and the result checklist. Corr.: correct. Bold: best. Underlined: second. Mean over 7 open models, % of runs.
| AgentOrchBench | Wrong | Correct | Unknown | Clean |
| No guard | [56.8, 91.3] | [11.9, 20.9] | [0.0, 30.8] | [59.1, 100.0] |
| Caution prompt | [55.5, 91.2] | [11.1, 21.6] | [0.0, 33.1] | [63.9, 100.0] |
| Self-verification | [33.6, 78.8] | [9.2, 19.2] | [2.4, 56.7] | [45.4, 100.0] |
| Re-query | [62.6, 87.1] | [12.6, 21.4] | [0.0, 24.7] | [63.6, 100.0] |
| Blind retry | [62.0, 86.9] | [13.9, 20.7] | [0.0, 24.1] | [70.1, 100.0] |
| LLM judge | [52.1, 90.3] | [12.2, 22.5] | [0.0, 35.2] | [65.8, 100.0] |
| Checklist | [52.3, 92.2] | [10.9, 21.6] | [0.0, 36.6] | [58.2, 100.0] |
| Reviewer | [60.0, 87.6] | [11.5, 20.2] | [0.0, 28.0] | [56.0, 100.0] |
| Outcome Monitors | [52.3, 92.1] | [12.6, 20.7] | [0.0, 34.5] | [64.5, 100.0] |
| Judge, no evidence | [50.4, 93.0] | [11.2, 21.4] | [0.0, 38.1] | [50.8, 100.0] |
| Judge, no evidence, + blocking | [50.6, 90.9] | [12.2, 21.2] | [0.0, 37.0] | [57.7, 100.0] |
| Judge + blocking | [0.6, 11.5] | [2.6, 4.4] | [85.2, 95.7] | [59.0, 100.0] |
| OM + blocking | [50.2, 91.6] | [12.3, 20.9] | [0.0, 37.3] | [63.6, 100.0] |
| Warning + may abstain | [0.0, 41.0] | [0.2, 9.8] | [49.6, 100.0] | [56.2, 100.0] |
| SilentGuard (ours) | [0.4, 3.0] | [1.6, 3.3] | [94.2, 97.5] | [57.2, 100.0] |
caption:
:::
which keeps only the returned records that meet the filter, has more wrong lists (16.9% on unseen faults) but more correct ones. Record checks can remove a record that should not be there, but they cannot reveal one the API never returned.
Cost and Fine-Tuning
This section gives the cost of each method and the fine-tuning study.
Cost. SilentGuard takes 18.9 s and 3.8 tool calls per faulted run, against 9.2 s for no guard (Table 27). The extra time is the harness’s own check queries, and no extra model call is made. SilentGuard takes less time than the reviewer (25.0 s) and the LLM judge (47.2 s), which add model calls, but uses more tokens than the judge (9,055 against 6,287), because the agent takes more turns. The check can be made cheaper. Checking conditions in random order and stopping at the first failure catches as many faults (97.2%) with 2.3 extra queries on faulted results (Table 30).
| Method | Tool calls | Time Tokens (s) | Extra LLM calls | |
| No guard | 2.0 | 3,183 | 9.2 | 0.0 |
| Caution prompt | 2.0 | 3,734 | 11.3 | 0.0 |
| LLM judge | 3.2 | 6,287 | 47.2 | 2.0 |
| Checklist | 1.9 | 3,429 | 8.7 | 0.0 |
| Reviewer | 1.9 | 9,276 | 25.0 | 2.6 |
| Outcome Monitors | 1.9 | 3,058 | 8.8 | 0.0 |
| Blind retry | 1.9 | 3,052 | 8.0 | 0.0 |
| Re-query | 1.8 | 3,041 | 7.9 | 0.0 |
| Self-verification | 5.0 | 12,422 | 33.3 | 0.0 |
| Warning (last condition) | 4.7 | 9,620 | 23.5 | 0.0 |
| Warning + tip | 5.6 | 13,831 | 30.6 | 0.0 |
| Auto-repair | 2.9 | 5,782 | 16.6 | 0.0 |
| Answer gate (last cond.) | 5.0 | 10,963 | 27.4 | 0.0 |
| Enforce | 5.0 | 11,745 | 29.1 | 0.0 |
| Warning | 4.4 | 8,299 | 26.9 | 0.0 |
| SilentGuard | 3.8 | 9,055 | 18.9 | 0.0 |
Table 27. Cost per faulted run on AgentOrchBench (mean over 7 open models). Columns give agent tool calls, LLM tokens, wall time and extra LLM calls (judge or reviewer) on top of the agent’s own. SilentGuard’s checks run in the harness and need no extra LLM call.
| Positions checked | Extra queries clean | Extra queries faulted | Seen faults caught↑ | Seen faults wrong↓ | Check-aware caught↑ |
| No check | 0.0 | 0.0 | 0.0 | 80.6 | 0.0 |
| Last condition only | 2.0 | 2.0 | 88.0 | 8.8 | 0.0 |
| 1 random condition | 2.0 | 2.0 | 88.4 | 8.6 | 0.9 |
| 2 random conditions | 4.0 | 4.0 | 94.4 | 2.8 | 1.9 |
| All, stop at first failure | 5.2 | 2.3 | 97.2 | 0.0 | 2.8 |
| All conditions (SilentGuard) | 5.2 | 5.2 | 97.2 | 0.0 | 2.8 |
Table 30. How many conditions to check, measured on the harness alone (no model, 36 count tasks per fault type, detection averaged exactly over every choice of positions). Extra queries per filter call on clean and faulted runs. Caught: share of faulted results the check flags. Wrong: share released with a wrong count under the answer rule. No budget raised a false alarm on clean runs. Check-aware: the consistent lie, an API built to keep the identity true. No budget catches more than 2.8% of it.
Fine-tuning
Fine-tuning. We fine-tuned two small models with the harness check shown to the model as a warning (Table 28). These are Phi-4-mini ([2]) with LoRA ((Hu et al., 2022)) supervised fine-tuning (SFT) and with reinforcement learning (RL) using DAPO ((Yu et al., 2025)), and Mistral-7B ((Jiang et al., 2023)) with QLoRA ((Dettmers et al., 2023)) SFT. Training to refuse transfers to unseen fault types, but the trained model still acts on the harness check it was trained with. Training makes the model follow the check and does not replace it. Training to repair does not transfer, because on unseen faults it turns refusals into confident wrong answers.
| Model | Training | Greedy decoding Seen↓ | Unseen↓ | Consistent lie↓ | Reworded↓ | Clean↑ | Sampling, , 3 seeds Seen↓ | Unseen↓ | Clean↑ |
| Phi-4-mini | Base model | 100.0 | 73.3 | 100.0 | 100.0 | 86.7 | 57.8 | 72.8 | 25.6 |
| Phi-4-mini | SFT to refuse (trained on drop-last) | 0.0 | 6.7 | 100.0 | 0.0 | 100.0 | 0.0 | 6.1 | 100.0 |
| Phi-4-mini | SFT to repair | 0.0 | 45.3 | 100.0 | 0.0 | 100.0 | 1.1 | 90.0 | 100.0 |
| Phi-4-mini | RL (DAPO, false-equation penalty) | 0.0 | 28.7 | 100.0 | 0.0 | 100.0 | 0.0 | 59.4 | 100.0 |
| Mistral-7B | Base model | 0.0 | 0.0 | 0.0 | 0.0 | 0.0 | 2.2 | 1.1 | 0.0 |
| Mistral-7B | SFT to refuse (trained on drop-last) | 0.0 | 8.7 | 100.0 | 0.0 | 100.0 | 3.3 | 0.6 | 100.0 |
| Mistral-7B | SFT to repair | 0.0 | 42.0 | 100.0 | 0.0 | 100.0 | 0.0 | 81.7 | 100.0 |
Table 28. Training the model itself, full results (% wrong, clean: % correct). Seen: drop-last, the fault used in training. Unseen: cap-total, AND→OR, ignore-NOT, off-by-one and prefix. Consistent lie: a wrong answer the API backs up in every query. Reworded: the seen fault with reworded tasks. With sampling, unseen covers AND→OR and off-by-one only. SFT: supervised fine-tuning. RL: reinforcement learning with DAPO. Mistral-7B base cannot use the tools, so its 0% wrong is not a success.
Check Budget, Cutoff and a Check-Aware API
This section tests cheaper versions of the count check, other cutoffs and an API built to pass the check.
Check budget. One run of the full check gives the identity result at every position, so the detection rate of checking only randomly chosen conditions can be computed exactly over all choices, with no sampling. We ran the harness alone (no model) on the 36 count tasks under each fault type and under no fault (Table 30). No budget raised a false alarm on a clean result. The original single check (last condition only) misses an ignored field at any other position. One random condition catches it only 33.3% of the time, and the full check 83.3% (the rest are tasks where the ignored field does not change the count).
Cutoff. Table 29 counts, over all 2,448 withhold-or-warn decisions in our ToolMaze runs, how many would change at other cutoffs.
Check-aware API. The consistent-lie fault inflates every filtered count and answers the checker’s complement queries so that the identity still holds. The last-condition check never catches it, and checking every position, or random positions, catches at most 2.8%. This limits what any check built only from the API’s own answers can do.
-bench
We also ran -bench retail (Yao et al., 2025) with two silent read faults on get_order_details. There, SilentGuard tied the published methods, because most injected faults do not affect what the task needs. The predictions for this run were written before the runs, are not counted in Table 31, and are kept in our run logs.
Further Discussion
This section answers points a reader may raise and that the main text covers only briefly.
Each fault type is modeled on a kind of API bug. Table 7 lists them, and three kinds occur in the real APIs we probed. These are an ignored parameter in 10 of 15, a silently capped page and an ignored filter value (Table 11). The other fault types are not measured in real APIs. SilentGuard also has the fewest wrong answers on the retail schema, cuts wrong answers on those real APIs, and is slightly ahead of the published methods on ToolMaze silent faults, a benchmark built by others with different tasks and faults.
The method is not limited to counts. It uses whatever checks a tool allows. These are an exact identity for count queries, record checks for lists (App. § 16), the API’s own parameter list for documented APIs, and learned contracts for everything else. Table 1 lists exact checks for other common operations. On ToolMaze, whose workflows book, pay, message and look up records, only learned contracts are available, and SilentGuard is slightly ahead of the published methods on silent faults.
Answering unknown is not refusing. Under a fault that repeats on every call, the API cannot give the correct count, so the real choice is between a wrong number and saying so. On the same tasks with no fault, SilentGuard is as accurate as no guard (84.9% against 84.9%). On real APIs, where the agent can rewrite the query, SilentGuard raises correct answers from 3.5% to 69.5%.
Repair releases wrong answers as verified. Auto-repair gives more correct answers on the fault types it was built for, but on unseen fault types it released 49 wrong answers marked as verified (Table 6). A wrong answer that says it is verified is worse than no answer.
Blind retry wins on ToolMaze because half its faults clear. Half of ToolMaze’s silent faults hit only the first call, so any retry clears them. On faults that last, and on real APIs, retrying gives no gain, and it repeats bookings, payments and messages (Table 22). We predicted otherwise for the two-call fault and report the failure (Table 31).
A better prompt is not enough. A warning from the count check plus explicit permission to abstain cuts wrong answers to 18.2%, against 1.7% for SilentGuard on the same models (Table 2). But the prompt still needs the check’s evidence, wrong answers still range from 0% to 59% across models, and nothing stops a model from ignoring the prompt. With the harness the result depends far less on the model.
Stronger models do not notice the fault. Without a guard, GPT-5.6 Sol, Terra and Luna report a wrong count in 59.0–89.4% of faulted runs (Table 5). Told to run the check themselves they give few wrong answers (4.5%) but refuse most clean tasks as well (20.4% correct). A silently wrong count looks like a right one. The evidence has to be produced by extra queries, and the harness is the place that can do so without changing how the model answers clean tasks.
The comparison with published methods is fair. All methods share one harness, the same models and the same tasks, and their prompts follow each paper’s design (App. § 12). We gave the LLM judge the harness’s own consistency queries and a strong judge model, and the reviewer up to five loops. The published methods either leave the decision to the model or use checks learned from value patterns, and none of them issues extra queries to test a result. On ToolMaze, a benchmark built by others for tool failures, SilentGuard is still slightly ahead of them.
No method was tuned on the test data. Method design used separate ToolMaze workflows, SilentGuard was frozen by file hashes before the planned runs, and every prediction was written down before its run (App. § 15).
Cost. On AgentOrchBench the cost is the harness’s own check queries, with no extra model call (Table 27). On ToolMaze, false alarms of learned checks cost 4.6 points of clean success against Outcome Monitors (Table 4).
A consistently lying API defeats every check. We tested this directly. The consistent-lie fault is an API built to keep the count identity true on the queries a checker sends. The full check catches only 2.8% of its answers, and choosing the checked conditions at random does not help (Table 30). When an API answers every query in one consistent false world, no check built from its own answers can tell. Only an independent source of truth can, and every method we tested reports the wrong count. We list this as a limitation.
The cutoff is not tuned to the results. No decision depends on it in the range that matters. Every cutoff below 1.85% gives the same decisions on ToolMaze, and on AgentOrchBench and real APIs every check is exact (Table 29).
References
- [1]Marah Abdin, Jyoti Aneja, Harkirat Behl, Sébastien Bubeck, Ronen Eldan, et al. 2024. Phi-4 Technical Report. arXiv preprint arXiv:2412.08905.arxiv.org/abs/2412.08905
- [2]Abdelrahman Abouelenin, Atabak Ashfaq, Adam Atkinson, et al. 2025. Phi-4-Mini Technical Report: Compact yet Powerful Multimodal Language Models via Mixture-of-LoRAs. arXiv preprint arXiv:2503.01743.arxiv.org/abs/2503.01743
- [3]Laksh Advani. 2026. From Confident Closing to Silent Failure: Characterizing False Success in LLM Agents. arXiv preprint arXiv:2606.09863.arxiv.org/abs/2606.09863
- [4]Vaggelis Atlidakis, Patrice Godefroid, and Marina Polishchuk. 2019. RESTler: Stateful REST API Fuzzing. In Proceedings of the 41st International Conference on Software Engineering (ICSE), pages 748–758.DOI
- [5]T. Y. Chen, S. C. Cheung, and S. M. Yiu. 1998. Metamorphic Testing: A New Approach for Generating Next Test Cases. Technical Report HKUST-CS98-01, Hong Kong University of Science and Technology.
- [6]Edoardo Debenedetti, Ilia Shumailov, Tianqi Fan, Jamie Hayes, Nicholas Carlini, Daniel Fabian, Christoph Kern, Chongyang Shi, Andreas Terzis, and Florian Tramer. 2025. Defeating Prompt Injections by Design. arXiv preprint arXiv:2503.18813.arxiv.org/abs/2503.18813





