acceptodds
Under review as a conference paper at ICLR 2027

Action Verification through Conjecture and Refutation for Language Model Agents

45 views

Abstract

Language model agents increasingly act on users' behalf by manipulating external environments through tools, often from high-level instructions that leave critical task- and environment-specific context unstated. To prevent resulting misaligned actions, recent work verifies proposed actions before execution, largely by establishing whether the conditions supporting them hold. We argue that this confirmation-oriented view leaves a fundamental blind spot: a wrong action often passes every check that asks whether it is right. This motivates a different question for verification: rather than asking what evidence supports an action, can the agent find evidence that refutes it? We pursue this direction with BlackSwan, a refutation-oriented, expect-suspect-test procedure that predicts the intended effect of each state-mutating action, formulates specific and empirically testable hypotheses for how it could be wrong, and tests them using existing observations or additional non-mutating actions, executing the action only if none survives testing. On challenging AppWorld tasks, BlackSwan improves success rate over the strongest baseline by 14.9 and 25.2%p with and without the backbone model's thinking mode, respectively. Even without thinking or in-context demonstrations, it outperforms stronger baselines equipped with them. The gains also transfer beyond AppWorld, with BlackSwan improving WebShop performance by 12.7%p. More broadly, our results suggest that language model agents have an underused capacity to recognize and self-correct misaligned actions, which can be systematically elicited through active conjecture and refutation before execution.

Primary area:
applications to robotics, autonomy, planning
Keywords:
Language Model Agents, Action Verification and Correction, In-context Adaptation

Reviews

Among:
Shape:
1234this paper, Top 15%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 3.00 over 3 reviews, above 85% of the others.
Reviewer_ooUPOpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
3
Soundness
2
Read review
Paper summary

This paper studies how an agent should verify its own actions before they take effect. The authors argue that current verifiers are confirmation oriented, meaning they look for evidence that an action is right, and so they approve plausible but wrong actions. They propose BLACKSWAN, a refutation oriented protocol. Before a side effecting code cell runs, the agent writes down what the cell should achieve, lists up to five preregistered suspicions about how it could be wrong, and then tests each suspicion with read-only probes of the environment. Each suspicion gets a verdict of confirmed, dismissed, or deferred, and confirmed suspicions trigger a redraft. On AppWorld with a Qwen3.5-27B backbone, BLACKSWAN reaches 84.7 TGC and 72.4 SGC on the challenge split, about 15 to 19 points above the best baseline, and the gains transfer to WebShop and ALFWorld. Ablations show that refutation and preregistered suspicions only help when combined.

Critical strengths
  1. A clear and well motivated idea. The shift from confirming an action to actively trying to falsify it is simple, well framed, and the expect-suspect-test loop is easy to reuse. The qualitative examples in Appendix F make the difference from confirmation based verification very concrete.
  2. Strong and consistent results. Gains hold across three benchmarks and five backbones, with and without thinking, and the ablation cleanly shows the two key components only work together. The reporting is unusually honest, including a careful reimplementation of the closest baseline, per run standard deviations, and a deferred verdict category.
  3. Cost is measured and disclosed rather than hidden, with a common token price so the comparison reflects harness behavior rather than model pricing.
Critical weaknesses
  1. The compute overhead is large, about 6.4 times the tokens and 9.4 times the cost of REACT on the AppWorld challenge split. Part of the gain may come from simply spending more compute, and a budget matched baseline such as REACT with retries or best of n at equal cost is missing.
  2. The main comparison uses the authors' own reimplementation of ACCORD, which scores below the numbers reported in the original paper, so the margin over ACCORD may be somewhat overstated. Only open or mid size backbones are tested, so it is unclear how the method behaves with frontier closed models.
Questions for authors
  1. At an equal token or dollar budget, how does BLACKSWAN compare to simpler ways of spending the same compute, such as REACT with best of n sampling or self consistency?
  2. How often are suspicions deferred, and do deferred suspicions predict downstream failures? Could the agent re examine deferred suspicions after the action runs?
  3. The protocol assumes cheap read-only probes of the environment. How would the method apply in settings where probes are slow, costly, or unavailable, such as real web actions?
4 comments

We thank the reviewer for their thoughtful and detailed evaluation. We appreciate the recognition of the conceptual framing, the consistent empirical improvements, and the transparent reporting of results. We hope the following responses address your concerns, and we welcome any further questions. Changes in the revised manuscript are marked in green.

Compute-matched comparisons [W1, Q1]

We conducted additional experiments. We allow agents to use an unbounded number of LLM calls until they explicitly decide to end the task by proposing an action containing complete_task. Thus, the costs reported below, measured as in Figure 5, reflect each agent's own behavior rather than imposed compute budgets.

Best of kk trials with an oracle. Implementing ReAct with retries requires arbitrarily deciding when to retry, how to determine failure, etc. To avoid concerns arising from such arbitrary decisions, we instead evaluate oracle Pass@K, counting a task as successful if any of K runs succeeds. We note that this uses ground-truth labels from the benchmark evaluator and allows cost-free environment resets between retries. At comparable costs, neither baseline reaches BlackSwan's Pass@1.

Table T1. Oracle Pass@K.

Methodpass@kTGCCost vs BlackSwan
ReAct979.41.01x
ACCORD480.01.15x
BlackSwan184.71.00x

Best-of-N with an LLM judge. At each step, ReAct samples N candidate actions from the same history. A listwise LLM judge selects one for execution. We use temperature 1.0 because candidates must be diverse enough for BoN.

Table T2. Best-of-N with an LLM judge. A single ReAct run at temperature 1.0 reaches 52.5 TGC (58.4 at temperature 0).

MethodTGCCost vs BlackSwan
best-of-6 + judge51.70.69x
best-of-8 + judge47.80.88x
BlackSwan84.71.00x

Matched probe budget. We gave ACCORD's grounding agent and BlackSwan's Test stage the same read-only probe allowance per verification, which neither method exhausted. This allowance limits probes per verification, while total LLM calls per task remain unbounded. Under the same allowance, BlackSwan gathers more observations and achieves substantially higher TGC.

Table T3. Probes per verification.

ArmTGCmeanp50p75p90p99
ACCORD62.80.651113
BlackSwan84.71.351238

Takeaway. Under the same probe allowance or comparable compute, BlackSwan achieves substantially higher TGC. The gap thus lies not in how much the agent spends but in what it looks for. As Popper (1963) argues, observation is always selective: it needs a chosen object, an interest, a point of view, and a problem. BlackSwan's refutation-oriented suspicions supply these through preregistration.

Fidelity of ACCORD reimplementation [W2]

We agree that the fidelity of ACCORD's reproduction matters for a fair comparison. Unfortunately, ACCORD's code has not been released: although the paper links to its GitHub repository, it remains inaccessible (404) to date. Reimplementation was therefore unavoidable.

A consequential unspecified design choice is the number of in-context demonstrations. The ACCORD paper does not report this number, leaving two plausible settings:

  1. One demonstration, following AppWorld's official ReAct baseline.
  2. Three demonstrations, inferred from ACCORD's use of ACE (Zhang et al., 2026) as its baseline. The released ACE implementation adds two demonstrations to ReAct's original one.

We therefore evaluated both:

  1. Table 1 uses one demonstration for all methods, following the official ReAct baseline. As the reviewer notes, our ACCORD reproduction scores slightly below the original paper on test-normal, while its lower performance on test-challenge is statistically distinguishable from the reported result.
  2. Table 10 and Figure 3 also report ACCORD with three demonstrations. In this setting, the reproduction scores lower on test-normal, but exceeds the original paper's reported performance on test-challenge.

While an exact reproduction cannot be guaranteed, we have made every reasonable effort to reproduce ACCORD under the available specifications. Importantly, BlackSwan outperforms ACCORD in all evaluated settings (thinking on/off and 1/3 demonstrations).

Generalization to frontier closed models [W2]

We agree that evaluation with frontier closed models would strengthen our findings. Given their substantial API costs, however, it is hard to include them in our evaluation. We have acknowledged this limitation in the revised manuscript (Section 6).

Deferred suspicions [Q2]

How often are suspicions deferred?

The model judges 13.5% of suspicions as deferred. Among tested actions, 28.8% carry at least one deferred suspicion, and 9.3% are executed with one.

Do deferred suspicions predict downstream failures?

Among actions executed with deferred suspicions, 1.5% and 59.4% lead to immediate regressions and progress in task-level unit tests, respectively. We measured these effects by evaluating the benchmark unit tests immediately before and after each executed action.

Table T4. Effect of deferred suspicions.

EffectRate
Progression only59.1%
Regression only1.2%
Both progression and regression0.3%
Neither39.4%

We acknowledge that this analysis does not directly establish the relationship between deferred suspicions and "downstream" failures at task completion. While the unit tests provide reliable, fine-grained criteria for analysis, they assess only the resulting environment state. Directly identifying such relationship would require identifying the actions responsible for a failure, but the effects of actions within a trajectory are highly intertwined. As one of many possible scenarios, an incorrect order could result from an overlooked cart item, a mistaken product selection, an earlier misinterpretation of retrieved information, or a combination of these errors. We therefore report directly measurable action-level effects rather than relying on subjective failure attribution.

Could the agent re-examine deferred suspicions after the action runs?

We opt for implicit rather than explicit re-examination. Both the deferred suspicion and the execution result remain in the agent's context, allowing it to consider them when proposing subsequent actions. For example, when placing an order, the verifier raises a suspicion that the payment will fail due to insufficient funds but defers it because no API is available to check the balance. After observing that the execution fails for insufficient balance, the agent retries with another card. We favor this implicit behavior, as explicit post-execution re-examination would incur additional LLM calls. We have added a case study illustrating this behavior to Appendix B.

Practical constraints on observations [Q3]

Slow and costly. When probes are slow or costly (e.g., high API latency, per-request fees), BlackSwan remains applicable with several natural extensions to reduce probe cost. For example, the agent can prioritize suspicions likely to be confirmed (stopping upon the first suspicion confirmation), parallelize probes, or escalate to users. Each involves trade-offs between latency, API fees, and user burden. We deliberately keep these mechanisms simple in this work to isolate our central contribution: refutation-oriented verification for identifying and correcting misaligned actions.

Unavailable. In real web applications, agents can often obtain observations through either backend APIs (when permitted) or user interfaces (e.g., by searching or opening pages). Even if the means to observe the information needed to verify particular suspicions are unavailable, BlackSwan can still check prior observations for overlooked evidence and defer the suspicion if it remains unresolved. In the limiting case where all suspicions are deferred due to unavailable observation means, BlackSwan reduces to ReAct in terms of action execution, permitting all actions (as does ACCORD under its default-approval policy). However, we do not expect this limiting case to be typical, as the observation interfaces used for task execution and verification often overlap.

We have added extending BlackSwan to such settings as future work in Section 6.

References

  • Popper (1963). Conjectures and Refutations: The Growth of Scientific Knowledge.

I thank the authors for the detailed rebuttal.

[W1, Q1]: The oracle pass@k results and the matched probe budget experiment largely resolve my main concern. [W2]: The 404 explanation is fair. Frontier closed models remains unevaluated, but I understand the cost constraint and appreciate the explicit acknowledgment in Section 6. [Q2]: The numbers are clear. Deferral happens 13.5% of the time, and these actions rarely cause problems. I am fine with this design now. [Q3]: The degradation argument make sense and the proposed extensions remain future work, which is acceptable.

Overall, the rebuttal addresses my concerns. I will maintain my score.

We thank the reviewer for their thoughtful response. We are pleased that our revisions, additional experiments, and analyses have addressed your concerns, particularly regarding the role of additional computation, the fidelity of the baseline reimplementation, and deferred suspicions. We also appreciate your understanding of the scope of our evaluation and the proposed future directions. Thank you again for your constructive feedback and careful consideration.

Reviewer_1QfUOpenReview ↗
Rating
3
Confidence
4
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes an approach named BLACKSWAN to verify LLM agents' actions before execution. The motivation is that existing action verfication approaches have a fundamental flaw that a bad action can pass every check. Therefore, the proposed BLACKSWAN goes through a more proactive, rigirous four-stage check: Propose - Expect - Suspect - Test. This process proposes possible ways the action could go wrong, and the action is invalidated if any of them is confirmed. Experiments on AppWorld demonstrate substantial improvements over several commonly used agent baselines.

Critical strengths
  1. The paper address a critical and well-motivated problem. As LLM agents become more prevalent, safety guardrail needs to be strengthened accordingly. The paper address some fundamental flaws in existing action verification frameworks, which is an encouraging contribution in improving LLM agents' safety.
  2. The proposed approach is clearly framed and easy to follow, with strong empirical results.
Critical weaknesses
  1. The proposed method has limited novelty. The staged verification process is a similar to a self-reflection process, and it would be better to compare with existing self-critique and relfection-based agent apporaches.
  2. The computational cost increase is significant. Section 5 reports that the computational cost can hike up as much as 9.4 times, which is a significant overhead. The paper may need to consider more economic and optimized designs to reduce the computational cost while retaining quality.
  3. Experimental results are limited to AppWorld, WebShop and ALFWorld. It would be better to run some real-world agent examples and compare with existing safety guardrails.
Questions for authors
  1. The paper reports 54.4% rejection of actions (Sec. 5), which is a large portion. I wonder how many of them are false positives, and what are follow-up actions taken after rejection? In the extreme case, to ensure safety the majority of actions can be rejected, and the agents can keep trying new actions round after round until all actions pass the tests. But this ultra-conservative strategy would slow down agent execution significantly and potentially hurt performance.
  2. The computational overhead of the proposed approach is high. The current pipeline applies to all state-mutation actions. I wonder whether it is necessary to go through all stages for all agentic actions. I think this heavy verification pipeline only needs to be applied to actions with high potential risks to achieve better cost–reliability frontier.
5 comments

We thank the reviewer for their positive assessment and constructive suggestions. We appreciate the recognition of the problem's motivation, the clear framing of the method, and the strong empirical results. We hope our responses address your concerns; please let us know if any remain or need further clarification. Changes in the revised manuscript are marked in green.

Comparison with self-reflection and self-critique [W1]

Our main experiments already include representative baselines: ACE (Zhang et al., 2026) for self-reflection and ACCORD (Jiang et al., 2026) for self-critique. We would welcome pointers to specific methods for further comparison.

Self-reflection. Reflection-based methods learn from feedback after task attempts, e.g., Reflexion (Shinn et al., 2023) and ACE (Zhang et al., 2026), or after individual actions, e.g., ReflAct (Kim et al., 2025) and EVU (Wang et al., 2026). Such feedback can prevent similar mistakes later, but the mistakes reflected upon may have already caused irreversible changes. BlackSwan instead detects and corrects misaligned actions before execution. We discuss these methods in Section 2.

Self-critique. We discuss self-critique of proposed actions as preemptive action verification in lines 51-59 and Section 2. The key difference from ACCORD is the orientation/direction of verification: ACCORD seeks to establish whether an action is sufficiently grounded under its ActionReady condition, whereas BlackSwan seeks evidence that the action is wrong. This parallels the distinction between inductivism and falsificationism (Popper, 1963), which BlackSwan operationalizes through preregistered falsifiers. Our ablation (Table 3) supports both refutation-seeking and preregistration.

Rejections: validity, effects, and cost [Q1, W2, Q2]

We understand the underlying concern: BlackSwan's gains might come from a costly, overly conservative process of rejecting (54.4% of verified actions and 16.4% of all actions) and retrying actions rather than from identifying and correcting actual errors.

[Q1] Rejection validity and effects.

For rejected complete_task actions, 81.9% were correctly rejected, as determined by counterfactual replay. We executed each rejected completion instead of redrafting and counted unit-test failures as correct rejections. We also manually reviewed 41 cases passing all unit tests, as we observed occasional cases where benchmark unit tests do not fully cover user requirements and the verifier raises suspicions about constraints the tests overlook (Appendix A.3.1).

More broadly, 75.7% of rejected actions showed a positive counterfactual effect. We compare two branches from the same pre-rejection state: executing the rejected action (A) and executing the agent's revisions up to the first state-changing action (B). We then compare which unit tests each branch passes.

Table T1. Effect of rejection.

ComparisonRate
B passes more than A75.7%
A passes more than B2.8%
A and B pass the same unit tests18.5%
Otherwise3.0%

These results provide indirect evidence of overall rejection validity while also showing that the agent's follow-up actions in response to rejection generally lead to better outcomes.

[Q1, W2] Alternative uses of compute.

BlackSwan's gains cannot be reproduced by spending comparable compute on simpler alternatives. For oracle Pass@K, a task is counted as successful if any of K independent runs succeeds, assuming ground-truth success labels and cost-free environment resets. For best-of-N with an LLM judge, ReAct samples N candidate actions at each step, and a listwise judge selects one for execution.

Table T2. Performance under alternative uses of compute. A single ReAct run at temperature 1.0 reaches 52.5 TGC (58.4 at temperature 0).

MethodExtra computeTGCCost vs BlackSwan
ReActoracle Pass@979.41.01x
ACCORDoracle Pass@480.01.15x
ReActbest-of-6 + judge51.70.69x
ReActbest-of-8 + judge47.80.88x
BlackSwan-84.71.00x

[W2, Q2] Opportunities for cost reduction.

(1) Engineering for computational efficiency.

Our main results use a straightforward implementation without low-level engineering effort, to isolate the effect of the proposed verification/correction procedure itself. Preliminary efficiency tuning (lighter context and a smaller verification budget) reduces cost from 9.43x to 4.43x that of ReAct (−1.3%p in performance).

Table T3. Cost reduction.

MethodTGCInput tokens / taskGenerated tokens / taskCost / task
ReAct58.41.00x1.00x1.00x
ACCORD63.52.70x2.95x2.74x
BlackSwan84.79.82x6.42x9.43x
BlackSwan (cost-tuned)83.44.40x4.68x4.43x

(2) Verification with potential risks.

We appreciate the suggestion to focus verification on high-risk actions. Estimating risks before verification would require additional risk assessment, potentially introducing its own computational cost. Instead, BlackSwan uses a simple rule to trigger verification, while SUSPECT identifies concrete potential failures. For 24.3% of verified actions, SUSPECT raises no suspicions, allowing execution without TEST. Thus, environmental probing is performed only when potential failures are identified.

Table T4. Suspicions per verified action.

Suspicions per verified action012345
Share of verified actions24.3%10.6%15.1%31.4%9.3%9.4%

(3) Escalation to user.

Part of the cost comes from valid but unaddressable suspicions, which the verifier confirms repeatedly because no feasible revision can address them (Appendix A.3.1). Escalating such cases to the user could avoid this cost, but it raises a separate research problem of human-in-the-loop correction (e.g., balancing cost against user burden), which we leave to future work.

Real-world applicability and safety guardrails [W3]

Real-world evaluation. We agree that real-world evaluation would further strengthen our work. As real-world environments are difficult to control and reproduce, we use AppWorld, which closely simulates everyday users' digital environments through 457 APIs across nine applications (e.g., Amazon, Venmo, Gmail) with consistent cross-app state changes and realistic tasks, and evaluate BlackSwan in two more environments. We have added real-world validation as future work (Section 6).

Safety guardrails. Among the various aspects of agent safety, BlackSwan addresses intent misalignment: agents misreading underspecified instructions even when the user's environment holds the information to clarify them. Safety guardrails such as AGrail (Luo et al., 2025) instead check actions against predefined policies (e.g., access control). In our setting, the only requirement is to fulfill the user's task as intended, which admits no exhaustive list of such rules. The closest guardrail is thus ACCORD, which we compare against. We have added this discussion to Section 2.

References

Reviewer_D2G4OpenReview ↗
Rating
3(+1)
Confidence
2
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

BLACKSWAN introduces an expect–suspect–test procedure that checks proposed state-changing actions by generating and testing potential falsifiers before execution. It reports substantial improvements on AppWorld and WebShop, with consistent gains across 4 backbone models. The results are promising, but the novelty relative to existing verification methods and the contribution of additional computation require better positioning /isolation/ diffrentiation.

Critical strengths
  • Practical and important problem: its important to prevent the wrong action being taken prior to execution if the environment is such that you can't easily reverse the action.
  • Useful verification structure: explicit, code-grounded suspicions make the verification targets very concrete and force the agent to deal with each of the suspicions in turn.
  • Strong empirical results: The AppWorld and WebShop gains are substantial; there are multiple backbones, and the thinking/demonstration comparisons are all very telling. AppWorld's state based evaluation is the right one to be using.
Critical weaknesses
  • The execution criterion is not consistently enforced. The paper repeatedly asserts that an action executes only if it survives attempted refutation. However, Algorithm 1 in the appendix executes the final draft after three redrafts, even if verification continues to block it. This fallback mechanism is not described in the main text. Please report how often the redraft limit is reached while the action remains blocked, disaggregated by successful and failed tasks and by complete_task calls. Additionally, discuss alternatives such as abstention or escalation. Since deferred suspicions do not block execution, please also report the frequency of deferred verdicts, as a high rate would undermine the burden-of-proof argument.
  • Compute is not matched. BLACKSWAN costs 1.5-9.4x ReAct. Being on the cost/performance frontier is not the same as being better at the same budget. Matched baselines are missing (ReAct with retries/self consistency, best-of-N with an LLM judge, or a generic pre-execution critic).
  • Some generalization claims should be clarified. WebShop adds benchmark-specific instructions and deferral rules, so transferring involves more than just changing the wording. The extra backbone evaluations are based on single runs, and the 0.2-point ALFWorld advantage over ACCORD is too small to show a clear difference without paired uncertainty estimates.
  • The paper need to clarify the conceptual novelty more precisely. ACCORD already uses action-conditioned environmental probing before execution, so the main difference seems to be the explicit, fixed set of code-grounded falsifiers. It would also help to discuss Failing to Falsify, which looked at counterexample-oriented interventions for LLM confirmation bias in rule-discovery settings.
Questions for authors
  • Of rejected actions, what fraction were actually incorrect, judged against unit tests or manual annotation? How often do redrafts reintroduce the same error or loop?

  • On WebShop and ALFWorld, which actions were treated as state-mutating and therefore gated?

  • How often does BLACKSWAN go ahead and do a final draft in the face of a confirmed suspicion? What are the effects and what happens to performance if you simply don't do the final draft in those circumstances?


(Post rebuttal: Conditional score increase provided authors made the changes in the manuscript ASAP, as promised)

6 comments

We thank the reviewer for their careful assessment and constructive feedback. We appreciate the recognition of the practical importance of the problem, the useful verification procedure, and the strong empirical results. We hope our responses resolve your concerns, and we would be glad to address any that remain. Changes in the revised manuscript are marked in green.

Execution criterion and fallback [W1, Q3]

We acknowledge that the main text omitted the bounded fallback and have added it to Section 3.

How often does BlackSwan execute despite confirmed suspicions?

BlackSwan goes ahead and does a final draft in the face of a confirmed suspicion in 6.6% of the drafts subjected to verification, and in 12.4% of the drafts it rejects.

Table T1. Execution despite confirmed suspicions.

DisaggregationOf verified draftsOf rejected drafts
Overall6.6%12.4%
Successful tasks5.8%11.9%
Failed tasks9.1%13.5%
complete_task drafts2.7%17.9%
Other drafts7.4%12.2%

The two columns differ most on complete_task drafts because verification rejects them far less often: 14.9% against 60.7% for other drafts. The limit is sometimes reached because of valid but unaddressable suspicions: the verifier confirms the same suspicion repeatedly because no feasible redraft can address it (Appendix A.3.1).

Alternatives to fallback.

  • Abstention would avoid potentially misaligned actions, but could also prevent task completion. It would require deciding when to abstain, which involves distinguishing suspicions that further redrafts cannot address and weighing task completion against the risk of unintended state changes.
  • Escalation could ask the user how to proceed when addressing a confirmed suspicion is impossible. It would require human-in-the-loop correction, including ways to minimize user burden and to simulate and evaluate user interactions.
  • Fallback (current) reflects our decision to keep mechanisms beyond our central claim (refutation-oriented verification/correction) simple. While this simplicity comes with the risk of incorrect execution, in 6.2% of the drafts executed despite confirmed suspicions, the task fails on a unit test that checks the state written by the very API the confirmed suspicion concerns.

Reliability of verification/correction [W1, Q1]

[W1] How often are verdicts deferred?

The model judges 13.5% of suspicions as deferred. Among tested drafts, 28.8% carry at least one deferred suspicion, but only 9.3% are executed with one, since any confirmed suspicion still blocks the draft. Deferral is meant for suspicions that are impossible to judge (true/false) before execution. Annotating each deferred suspicion with an LLM using a fixed rubric (Appendix A.2), we find that 82.1% could not be judged using available outputs, documentation, or read-only APIs. Among these, 55.1% require feedback from outside the environment (e.g., user clarification via escalation) to resolve, while 40.0% require action execution.

[Q1] Were rejected actions actually incorrect (at task completion)?

Among rejected complete_task actions, 81.9% are correctly rejected, as determined by counterfactual replay. We execute each rejected completion instead of redrafting and count unit-test failures as correct rejections. We also manually review the 41 cases passing all unit tests, as benchmark unit tests occasionally do not fully cover user requirements and the verifier raises suspicions about constraints the tests overlook (Appendix A.3.1).

[Q1] Were rejected actions actually incorrect?

More broadly, 75.7% of rejections are beneficial. From the same pre-rejection state, we compare two counterfactual branches: Branch A executes the rejected action, while Branch B executes the agent's subsequent revisions up to and including the first state-changing action. We then compare which unit tests each branch passes.

Table T2. Effect of rejection.

ComparisonRate
B passes more than A75.7%
A passes more than B2.8%
A and B pass the same unit tests18.5%
Otherwise3.0%

Due to the difficulty of judging the correctness of intermediate actions, we use this relative benefit as indirect evidence of rejection correctness.

Compute-matched comparisons [W2]

In the additional experiments below, no agent is given a compute budget: each runs until it ends the task with complete_task, so the reported costs reflect its own behavior.

Best of kk trials with an oracle. We evaluate oracle Pass@K: a task counts as successful if any of K runs succeeds, using ground-truth labels from the benchmark evaluator and cost-free environment resets. At comparable costs, neither baseline reaches BlackSwan's Pass@1.

Table T3. Oracle Pass@K.

Methodpass@kTGCCost vs BlackSwan
ReAct979.41.01x
ACCORD480.01.15x
BlackSwan184.71.00x

Best-of-N with an LLM judge. At each step, ReAct samples N candidate actions from the same history. A listwise LLM judge selects one for execution. We use temperature 1.0 because candidates must be diverse enough for BoN.

Table T4. Best-of-N with an LLM judge. A single ReAct run at temperature 1.0 reaches 52.5 TGC (58.4 at temperature 0).

MethodTGCCost vs BlackSwan
best-of-6 + judge51.70.69x
best-of-8 + judge47.80.88x
BlackSwan84.71.00x

Transferability [W3, Q2]

[W3] Scope of WebShop adaptations. We agree that our manuscript did not clearly separate domain-neutral components from WebShop-specific adaptations. The opening context (generic API-use instructions, API discovery through documentation, no demonstrations) is largely domain-neutral. As the reviewer noted, we adapted the SUSPECT and TEST prompts to clarify WebShop's action semantics and deferral rules (Appendix D.2). We have removed the description of them as domain-neutral (Section 1 and Section 4.2).

[W3] ALFWorld clarification. We agree that our explanation overstated the 0.2%p difference over ACCORD. As ALFWorld is nearly saturated (ReAct 98.8%, ACCORD 99.3%), we now describe the three methods as performing comparably (Section 4.2).

[Q2] State-mutating actions in WebShop and ALFWorld. We applied the same gating rule across benchmarks: only read-only API actions bypass verification. For WebShop, we classified APIs as read (GET) or write (POST) using LLM annotation. For ALFWorld, we used the write API set reported in ACCORD to ensure a fair comparison. The API classifications and complete lists are provided in Appendix D.2 and Appendix D.3.

[W3] Extra backbones with three runs. The results over three runs are shown below.

Table T5. Extra backbones over three runs.

BackboneMethodNormal TGCNormal SGCChallenge TGCChallenge SGC
Qwen3-4BReAct21.4 ±\pm 2.611.3 ±\pm 2.712.2 ±\pm 0.45.0 ±\pm 0.7
ACCORD14.1 ±\pm 0.73.6 ±\pm 0.08.6 ±\pm 1.12.4 ±\pm 1.8
BlackSwan42.9 ±\pm 1.226.2 ±\pm 4.527.0 ±\pm 0.812.0 ±\pm 2.3
MiniMax M2.7ReAct64.3 ±\pm 3.343.5 ±\pm 2.753.6 ±\pm 0.934.1 ±\pm 1.5
ACCORD68.8 ±\pm 2.448.2 ±\pm 3.163.2 ±\pm 1.042.2 ±\pm 3.6
BlackSwan77.2 ±\pm 1.563.7 ±\pm 4.573.6 ±\pm 0.953.7 ±\pm 0.4
GLM-5.3-FlashReAct84.1 ±\pm 0.969.6 ±\pm 3.178.9 ±\pm 1.957.1 ±\pm 1.8
ACCORD82.3 ±\pm 1.566.1 ±\pm 0.076.5 ±\pm 1.656.1 ±\pm 1.2
BlackSwan89.7 ±\pm 1.979.2 ±\pm 3.782.3 ±\pm 1.265.7 ±\pm 2.1

Novelty [W4]

Comparison with ACCORD. The conceptual distinction lies in the direction of verification: ACCORD checks whether a proposed action is sufficiently grounded (its ActionReady condition), whereas BlackSwan seeks evidence that the action is wrong, paralleling the contrast between inductivism and falsificationism. Preregistered falsifiers operationalize this refutation-oriented approach, and our ablation (Table 3) supports both: explicit refutation achieves 81.6% TGC, compared with 76.0% for explicit confirmation and 72.7% for implicit refutation.

Comparison with Failing to Falsify (Jhaveri et al., 2026). Both works operationalize falsification (Popper, 1963), but for different problems: Failing to Falsify addresses rule discovery such as Wason's 2-4-6 task (Wason, 1960), whereas BlackSwan addresses agent actions misaligned with user intent. In the 2-4-6 task, an oracle answers whether each proposed test case conforms to the hidden rule, so the remaining problem is which test to choose. In our setting, no oracle tells whether an action fulfills the user's intent, which also depends on actions not yet taken, and executing the action merely to test it may cause irreversible changes. BlackSwan therefore turns this untestable question into action-local suspicions that read-only probes can test before execution. We have clarified this distinction in Section 2.

References

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.