acceptodds
Under review as a conference paper at ICLR 2027

Refusal Is Not Failure: From Model Responses to Safe System Traces

Abstract

A correct refusal can still lead to an unsafe action when a routed language-model system treats it as a failed call and retries another backend. We model generation, routing, and external actions as a single execution process. This gives an exact expression for system risk, proves that retry after safe termination adds nonnegative unsafe probability, and shows why per-model safety scores cannot determine chain risk. Across four instruction-tuned model families and all 650 XSTest and JailbreakBench prompts, naive retry recovers 394 safe answers but adds 61 responses labeled unsafe by WildGuard and 161 by Llama Guard over 2,600 paired units. Typed-action experiments reproduce refusal bypass with and without token constraints. Under unrestricted decoding, checking each action against the original policy before execution recovers 589 additional safe completions over exact fail closed, with zero unsafe commits. With peer messages, these checks retain 95.4% of naive retry's correct completions while preventing all 95 unauthorized commits on the same finite policy grid. Checking each reached commit against the original policy enables safe continuation.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Language model safety, Refusal bypass, Model routing, Runtime enforcement

Reviews

Among:
Shape:
1234this paper, Bottom 25%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.75 over 4 reviews, above 25% of the others.
Reviewer_54dXOpenReview ↗
Rating
1
Confidence
4
Informativeness
1
Presentation
1
Soundness
2(+1)
Read review
Paper summary

The paper shows that a system can succeed in eliciting harmful answers from models if automatically when a refusal is detected as an availability failure, the system then routes to another model.

Critical strengths

None

Critical weaknesses
  • The paper is extremely difficult to parse due to heavy AI text. The abstract, figure 1, introduction, should all explain the gist of the paper but they introduce heavy terminology and jargon (for example, "Typed-action experiments reproduce refusal bypass with and without token constraints.", "peer messages", "commits"). "Peer messages" is only explained in page 9. Unfortunately the paper is not ready for submission.

  • The paper's motivation is that the controller retries another model if the first model fails, however, the user can already do that even if the controller does not retry. This can't be prevented.

  • The experiments are done on small scale models (7 to 9 Billions)

  • Section 3 is consuming almost 2.5 pages while it is conveying a very simple concept that the output can continue or stop.

  • The paper does not evaluate the utility of the final non-refused answer, since switching to a less capable model may give overall non useful answers.

  • Conceptually, the paper is similar to best of N jailbreaks.

Questions for authors

N/A

2 comments

We would like to follow up on one point before the discussion closes on 18 November.

The review rates soundness 1, "significant concerns that do not appear easy to address", but it does not say which claim, proof step or experiment is wrong. We would like to fix whatever it is. Could you name the result you consider unsound?

On the concrete points of the review, this is where the paper stands now. On model scale, the revision added 24B and 32B models, and since our reply we extended that test to twelve permission domains with six phrasings of every request. A larger first model does not remove the problem. In 71 routed cases the 24B or 32B model correctly refuses a forbidden request and the 8B fallback then executes it, and in 5 cases the 24B model refuses and the 32B model executes. Checking each action removes all 76 and keeps all 3,568 correct completions. On utility, every action table reports correct completions, and a completion counts only when the executed action is the requested one and is permitted. On users switching models, Section 7 states the boundary: the check governs what our service executes with its own credentials, whichever model wrote the action. On best-of-N, the Introduction and Section 2.2 state the difference: best-of-N searches over prompts, while we fix the prompt and every model output and change only the retry rule. On presentation, the abstract, introduction and Figure 1 are rewritten around one example, and Section 3 is one page.

In the revised PDF, new text is blue and margin notes name the reviewer each change answers. If any of these points is still inadequate, please tell us which one, and we will answer before the deadline.

Thank you for the rebuttal.

I however don't believe the revised manuscript is clearer.

I also still have concerns about the real-world implications of the experiments. First, the actions performed here (read files) can be trivially flagged in your example ("A user without permission"), and they are not a multi-step process or an open-ended space. Second, a fall back to a 9B model does not tell us anything about frontier models. I believe the idea of the paper could potentially be valid, but its current implementation given the tasks and models don't inform us about how to measure this problem in practice.

I will maintain my overall rating due to major clarity and writing issues and significance of results.

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

The paper studies routed LLM systems in which a controller decides what happens after a model responds. When the primary model correctly refuses a harmful request, a naive controller may treat the refusal as a failed call and retry another backend, which may then answer the request or execute the action that the first model refused. The main contribution lies in diagnosing this problem and accounting for its risk. The proposed solution applies the classic complete-mediation principle to LLM routing, checking every action against the original policy before it is executed. Experiments on XSTest and JailbreakBench with four small open models show that naive retry recovers 394 WildGuard-safe answers but also adds 61 WildGuard-unsafe and 161 Llama-Guard-unsafe responses. On a typed-action benchmark with a finite policy, an exact pre-commit check eliminates all unauthorised actions while completing more tasks than simply stopping after the first model.

Critical strengths
  1. The manuscript identifies a practically relevant, system-level failure mode. The paper shows that a correct refusal can still lead to an unsafe outcome when a controller treats it as a failed call and retries another backend. This sits between refusal evaluation, which stops at the model response, and routing research, which focuses on cost and quality, and it is relevant to multi-provider failover and cascade designs. The phenomenon is not tied to one model pair: under constrained decoding, bypass appears in all 48 route–decoding cells.

  2. The evaluation setup are well established. The evaluations is designed to isolate the effects of the controller, candidate outputs are generated and stored before controllers are compared, so differences between controllers reflect only which candidates are reached.

Critical weaknesses
  1. The remedy is guaranteed by construction where the policy is checkable and unvalidated where it is not. The exact guard is an oracle over the same finite permission table that defines “unsafe”, so zero unsafe commits are expected by construction; this confirms complete mediation but says little about complex policies or imperfect guards. Its gains over fail closed also do not come from refusals: exact-guard retry stops after every refusal, and all 589 unrestricted gains (in the released traces) and all 143 peer-message gains (K.3) follow invalid primary outputs; under constrained decoding, with no invalid outputs, both controllers reach S = 2,361. Keeping refusals terminal is unnecessary under this guard. Replaying the released candidates with retry after refusal and the same exact check gives S = 2,618, 2,404, and 612 in the constrained, unrestricted, and peer-message studies, all with zero unsafe commits, i.e., all of naive retry’s completions without its violations (+257, +141, and +28 over exact-guard retry). For open-ended harmful content, the paper provides no exact decider: the WildGuard-based harm-block retry adds only 21 answers over fail closed, 13 of which Llama Guard labels unsafe (Table 1: 372 vs. 359), and false approval on reached unsafe candidates is not measured against independent labels.

  2. Limited theoretical novelty and limited evidence of scale and deployment relevance. The main results restate the chain rule, the Fréchet bound, and a standard safety-invariant argument, so the contribution lies mainly in the framing and measurement. Empirically, bypass rests on few independent sources (18 distinct prompts in the natural-language study; all 87 unrestricted bypasses in the network domain from 8 requests); these exact counts establish the mechanism but not its frequency under realistic workloads. The paper also gives no evidence that deployed routers retry after a text refusal: gateway fallbacks on provider content-policy errors exist (e.g., LiteLLM’s content_policy_fallbacks), but these are API errors rather than refusals returned as normal responses.

  3. The natural language results depend heavily on the choice of safety evaluator. Naive retry adds 61 unsafe responses under WildGuard but 161 under Llama Guard, harm-block retry yields 0 versus 372 unsafe responses, and the two evaluators disagree on 378 of 2,600 primary outputs. Since correct refusals and safe answers are also defined by WildGuard labels, the reported counts inherit its errors. Without human validation on a subset, the magnitude of the unsafe increase remains uncertain.

Questions for authors
  1. Since the exact guard blocks every unauthorised action, why is refusal kept terminal under exact-guard retry? Replaying the released candidates with retry after refusal under the same guard appears to recover all of naive retry's completions with zero unsafe commits. Please explain why refusal is kept terminal under exact-guard retry.

  2. How does the approach perform with a non-oracle guard, e.g., what is the false-approval rate of a learned guard on reached unsafe candidates?

  3. Is there evidence that deployed routers or gateways retry after a model returns a text refusal, rather than an API-level content-policy error?

  4. Does the bypass persist with larger models and with more diverse prompts and policy domains beyond the network domain?

  5. Can the authors provide human validation on a subset of outputs, especially those on which WildGuard and Llama Guard disagree?

1 comment

We have one new experiment and one correction since our reply. Both concern your second weakness (few independent sources) and Questions 2 and 4.

More domains and more phrasings (W2, Q4). We ran the 8B, 24B and 32B models on twelve permission domains instead of six, and phrased every request in six ways instead of two. That is 4,320 new model outputs. The domains, phrasings and reported outcomes were written down before any output was generated, and that file is in the supplement. After a correct refusal, naive retry now executes an unauthorized action in 76 routed cases. They come from 41 distinct prompts and 14 distinct role-operation-resource combinations, in 9 of the 12 domains and under all six phrasings. The six-domain extension had 13 cases from 7 prompts in 3 domains. Guarded continuation completes the same 3,568 tasks as naive retry and executes no unauthorized action; 269 of those completions follow a refusal of an authorized request.

Two limits belong with these numbers. In 71 of the 76 cases the model that acts is the 8B fallback, after the 24B or 32B model refused. Five cases route from the 24B to the 32B model, and all five are one request in five phrasings. Mistral-Small-24B proposed no unauthorized action, so the routes that fall back to it show nothing. And 76 of 4,092 correct refusals is 1.9%. The result adds independent sources and domains. It is not a frequency estimate, and we do not claim one.

Correction to our answer to Q2. We wrote that the 32B checker's error rate on the test grid (1 of 150) predicts 2.6 unauthorized executions where 30 occur. That grid is too easy a baseline. 120 of its 150 unauthorized pairs combine a role with an action from another domain, and no model ever proposes such an action. Counting only the 30 in-domain pairs, the prediction is 13.2, so the gap in that study is 2.3-fold, not 11-fold. Table 38 now shows both.

The new study uses an in-domain grid from the start (120 unauthorized pairs), and there the gap is larger. The 32B checker wrongly approves 1 of 120 pairs, yet approves 22 of the 166 unauthorized proposals that reach it; its grid rate predicts 1.4. The 8B checker wrongly approves 7 of 120 and approves 94 of 166, against 9.7 predicted. The 24B checker approves none and loses 238 completions to false denials.

The cause shows in the data. The pairs a checker wrongly approves are the pairs a generator wrongly proposes. The 8B checker wrongly approves 5 of the 14 unauthorized pairs that some model proposes, against 2 of the 106 that no model proposes (one-sided Fisher exact p = 0.0002). When the proposing model checks its own action, 94 of 166 unauthorized proposals pass. When a different model checks, 10 to 12 pass. Most of these proposals come from the 8B model, so this is largely one model repeating its own misreading of the policy, and the paper says so.

All of this is in Appendix S of the revised PDF, where new text is blue and margin notes name the reviewer each change answers. The supplement has the raw outputs, the analysis, and a second program that recomputes the counts independently.

You asked five questions and raised three weaknesses. Is there one that these results and our earlier reply still leave open? We can answer before the discussion closes on 18 November.

Reviewer_7uaMOpenReview ↗
Rating
2
Confidence
2
Informativeness
1
Presentation
2
Soundness
2
Read review
Paper summary

The paper studies how retries after model refusal can create additional unsafe outcomes. It also forms the problem as a stochastic process problem and evaluates policies on different environments. Typed-action experiments found that retries can lead to refusal bypass with and without token constraints. Finally, the paper mentioned a safer protocol is to check each action against the original policy before execution.

Critical strengths
  • The paper studies a practical question and acts as a useful reminder for the community to treat the system as a whole in safety tasks evaluation as opposed to evaluating individual models independently.
  • The paper designs nice controlled experiments that keep the model outputs fixed and change the controller behaviors, which helps to clarify which controller states are responsible for the unsafe results.
Critical weaknesses
  • I am not fully convinced about the novelty of the paper. I am happy to be corrected, but many of the main discoveries here seem intuitive for me? For example, retrying another model after a refusal may introduce unsafe responses, evaluating individual model's safety is not enough, checking each action against the policy can remedy this issue.
  • I found the paper somewhat hard to parse. For example, terms like "reached unsafe mass", "percommit mediation", "safe reached support", "fixed selected-output law", "correct-refusal trigger units", "next-event kernel", "token kernels", etc, make the paper hard to follow and understand. Some of the terms may be standard expressions in stats but the community can benefit from more explanations of technical terms used herein. At the same time, avoiding unnecessary terms whenever possible will also largely increase the readability.
  • I am unclear about the additional insight provided by the theoretical results. Correct me if I am wrong, but my understanding is that they describe three observations: 1. retrying after safe termination can introduce unsafe outcomes, 2. safety of a model combination depends on where the models’ failures overlap, and 3. a policy check on every action prevents unsafe commit. These are useful ways to describe the problem, but they also seem intuitive. Can the authors clarify what the theory allows us to predict or design beyond these observations? For example, do they help choose a policy or evaluate safety when the exact policy checker is unavailable?
Questions for authors
  • Following up on the first point above. Can the authors clarify on the novelty of this paper? Is there any surprising finding that I missed?
  • Figure 1 is not self-explanatory. What do terminal primary and exact guard mean? what does one paired execution mean? Is this one request call that first got forbidden, then did naive retry, and then blocked again by exact guard? The lines in 061-063 provide some explanations but are still not very clear.
2 comments

Since our reply we ran one more experiment on your question about what the analysis predicts when no exact checker exists. We also need to correct one number we gave you.

The correction first. We said the 32B checker's one error was "11 times its share of the grid". That overstated the effect. The grid we used has 150 unauthorized pairs, and 120 of them combine a role with an action from another domain, which no model ever proposes. Against the 30 in-domain pairs, the prediction is 13.2 unauthorized executions where 30 occur, a 2.3-fold gap. Table 38 now gives both.

The new experiment tests the same prediction with a grid of in-domain pairs only, on twelve permission domains and six phrasings of each request. It adds 4,320 outputs from the 8B, 24B and 32B models, and its design was fixed in advance. The prediction holds, and more strongly. The 32B checker wrongly approves 1 of 120 unauthorized pairs on the grid, yet it approves 22 of the 166 unauthorized proposals that reach it, where its grid rate predicts 1.4. For the 8B checker the numbers are 7 of 120 on the grid and 94 of 166 on reached proposals.

What we did not expect is the reason. A checker is not an independent second opinion. It tends to approve the forbidden actions that a generator tends to propose, because both misread the same line of the policy. The 8B checker wrongly approves 5 of the 14 unauthorized pairs that some model proposes, against 2 of the 106 that no model proposes (one-sided Fisher exact p = 0.0002). When a model checks its own action, 94 of 166 unauthorized proposals pass. When another model checks, 10 to 12 pass. This is the overlap of failures that your review called intuitive. It now has a measured size and a design consequence: use a different model as the checker, and test it on the actions the router reaches instead of on a grid.

The same study also widens the evidence for the bypass itself. After a correct refusal, naive retry executes 76 unauthorized actions, from 41 distinct prompts in 9 of 12 domains, and checking each action removes all of them while keeping all 3,568 correct completions.

This is Appendix S of the revised PDF. New text is blue, and margin notes name the reviewer each change answers.

Does this change your view of what the paper contributes? If the novelty concern remains, it would help us to know which of these findings you still consider expected.

Thank you for the additional experiments and for correcting the earlier baseline comparison. The in-domain evaluation is helpful. It is also useful to know that errors occur more frequently on generated proposals than the grid average suggests. However, my original concern was mostly about whether the paper provides surprising or non-trivial insights. It seems expected that models may share failure modes, and that checker accuracy may differ from that on the actions a generator actually proposes. Measuring the size of these effects is useful, but I am still not convinced that this addresses the novelty concern. On my original point about the presentation, I think the concern is still there. There are still unnatural terms which would largely disrupt readers' understanding. Given these, I would keep my original rating.

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

This paper studies “refusal bypass” in routed LM systems: a model refuses safely, but the controller treats that as an availability failure and retries another backend, which may then produce unsafe outputs or actions. The authors formalize generation, routing, and external actions as one process, and argue that per-model safety scores do not capture chain-level risk, and propose a commit check policy based on complete mediation. Experiments across four instruction-tuned model families show naive retry increases unsafe responses and commits, while their exact-guard intervention removes unsafe commits on the limit action space while keeping most correct completions.

Critical strengths

The paper points out a fault scene that response-level evaluation can easily miss: a correct refusal can still lead to an unauthorized action if the controller keeps retrying and executes through other backend. The different between model responses, controller transitions, and external commits is useful, and the reported case where naive retry commits unauthorized actions after correct refusals is a concrete illustration of why execution-level enforcement matters.

Critical weaknesses
  1. Most security arguments rely on having a perfect guardian oracle. The paper compare each operation against idea security policy prior to execution; this is a fine way to demonstrate what security property are theoretical. That said, i am skeptical about what can learn from this setup when the policy checker itself can make mistakes. A zero‑abuse outcome here mostly tell me that the pre‑defined check rules work as intended. It does not tell me how the defense holds up when policy judgments are wrong in practice. I also missed a clear comparison against existing pre‑execution checking approaches. When the theoretical analysis of failure modes is solid, the jump from “properties hold given an oracle” to “practical, deployable security solution” is not well bridged in the current version.
  2. I suspect many of the reported task‑recovery gains stem heavily from formatting failure. As such, I think the evidence does not fully support the core Reject‑Security claim. The authors note that all 143 extra correct completions (relative to precise failure closure) originate from malformed primary outputs of llama3.1. Similarly, out of the 156 extra submissions under naive retry, 122 stem from invalid outputs and 34 stem from genuine correct refusals. The paper does separate these sources, but it does not demonstrate whether these recovery benefits persist when model consistently produce well‑formed valid outputs. To me, these experiments convincingly show safe rollback behavior for one specific failure case (format errors), but they do not yet demonstrate general‑purpose security and practical benefits for refusal‑handling.
Questions for authors
  1. To me, exact‑guard still feels like an idealized oracle check instead of something you can deploy in practice. If the policy checker itself makes wrong judgments, what happens to the “zero abuse” guarantee? This is my highest‑priority point for the authors to respond to.
  2. How do you define a “safe answer” in these natural‑language experiments? Is it only outputs marked safe by WildGuard (excluding refusals), or do you also account for factual correctness and utility?
  3. I am confused about the 589 versus 143 split. Within those 589 extra safe completions, what fraction comes from invalid outputs, explicit refusals, or policy‑blocked actions? Section 6.4 tells us all 143 recoveries are due to malformed llama3.1 primary outputs. Do we see this same pattern for the larger set of 589 completions?
  4. In larger‑model routing study, 6 out of 12 routes exhibit refusal bypass. Are the remaining six routes truly free of bypass, or could output validity be masking potential issues that we cannot observe from the comparison metrics?
1 comment

We have a new result on your top-priority question, and one correction to our reply.

A stricter test of the imperfect checker (Q1). In our reply we compared the 32B checker's 30 unauthorized executions with the 2.6 predicted by its error rate on the test grid (1 of 150). That comparison was too favorable to us. 120 of those 150 unauthorized pairs combine a role with an action from another domain, and no model ever proposes such an action. Counting only the 30 in-domain pairs, the prediction is 13.2, so the gap in that study is 2.3-fold. Table 38 now reports both.

We then repeated the experiment with a grid of in-domain pairs only: twelve permission domains, six phrasings of every request, and 4,320 new outputs from the 8B, 24B and 32B models. The design was fixed before any output was generated. On 8,640 routed cases, naive retry completes 3,568 tasks and executes 166 unauthorized actions. With each model as the checker, retrying after refusal gives:

CheckerWrong approvals on the gridWrong denials on the gridCompletionsUnauthorized executionsPredicted from the grid
Exactnonenone3,56800
Qwen2.5-32B1 of 1200 of 1203,568221.4
Mistral-Small-24B0 of 12010 of 1203,33000
Qwen3-8B7 of 12026 of 1202,884949.7

An imperfect checker does not reopen the bypass: the 32B checker cuts 166 unauthorized executions to 22 and keeps every completion. But its residual risk is 10 to 16 times what its grid accuracy suggests. The reason is that checkers and generators misread the same policy lines. The 8B checker wrongly approves 5 of the 14 unauthorized pairs that some model proposes, and 2 of the 106 that no model proposes (one-sided Fisher exact p = 0.0002). When a model checks its own proposed action, 94 of 166 unauthorized proposals pass. When a different model checks, 10 to 12 pass. The practical reading is that the checker should be a different model from the one it checks, and that it should be scored on the actions the router sends it.

Recovery beyond formatting errors (W2). In the same study guarded continuation completes 556 more tasks than fail closed: 287 after an invalid first output and 269 after the first model refused an authorized request. This comes on top of the 257 refusal recoveries under constrained decoding, where malformed output cannot occur.

The details are in Appendix S of the revised PDF, where new text is blue and margin notes name the reviewer each change answers.

Does this answer your top-priority question? If part of it still falls short, please tell us which part, and we will reply before the discussion closes on 18 November.

Comments on the paper

1 comment

General response: summary of the revision

We thank all reviewers. Their questions led to new experiments that strengthen the paper's central claim without changing it: a correct refusal does not make a routed system safe, because a retry can reach another model whose action the service then executes; safety must be enforced on the executed action. The revised PDF adds the results below in the main text, with full tables in Appendices M to Q. Each reviewer's questions are answered in that reviewer's thread.

1. Retrying refusals safely (p2RL, gMcL). Stopping after a refusal is not needed when every action is checked. Guarded continuation retries after a refusal, an invalid output, or a blocked action and executes only actions that pass the permission check. With an exact check it keeps every correct completion of naive retry (Proposition 6) with zero unauthorized executions, in all five action settings:

StudyStop on refusalGuarded continuationNaive retry (unauthorized)
Small action grid160232232 (208)
Constrained2,3612,6182,618 (534)
Unrestricted2,2632,4042,404 (354)
Request only586618618 (91)
Peer message584612612 (95)

Constrained decoding has no invalid outputs, so its 257 added completions all come from refused but authorized requests.

2. Imperfect checkers (gMcL, p2RL, 7uaM). Three LLMs served as permission checkers on all 180 role-action pairs, replayed on the saved candidates. Qwen2.5-32B wrongly approves 1 of 150 unauthorized pairs, yet permits 30 unauthorized executions under continuation (naive retry: 354; exact check: 0) while keeping all 2,404 completions. Its single error is 5 of the 66 unauthorized actions the models actually propose, so the grid rate predicts 2.6 executions (Table 38). This confirms the submitted Corollary 5: a learned checker must be scored on the actions the controller reaches, and the retry rule changes that set. The actual Casbin enforcer reproduces every exact-check outcome.

3. Larger models and more domains (54dX, p2RL). Fresh outputs from Qwen3-8B, Mistral-Small-24B, and Qwen2.5-32B cover file, network, records, finance, healthcare, and cloud, with every resource listed in the system prompt. On clean inputs, naive retry completes 570 tasks with 30 unauthorized executions; guarded continuation completes the same 570 with none. Thirteen unauthorized executions follow a correct refusal, in network, finance, and healthcare. A fixed "administrator approved" claim caused no unauthorized execution under any controller; we report it in full.

4. Human review (p2RL, gMcL, 54dX). Two annotators, blind to models and labels, judged harm, refusal, completion, and factual correctness for 144 generated responses each, covering every recorded bypass path and 56 WildGuard/Llama Guard disagreements. Both confirm the bypass mechanism; with a blind third rater on the 18 bypass responses, the majority confirms 20 of the 50 recorded bypass units from 8 distinct prompts. Where the evaluators disagree, both raters judge 50 of 56 responses not harmful (Section 6.1, Table 48), so Llama Guard's larger counts mostly reflect its false positives. The size of the harm increase depends on the rater, so we present natural-language counts as evaluator-specific evidence of the mechanism and base quantitative safety claims on the action studies, where authorization is exact.

5. Real software (p2RL, 54dX). Fallback after a normal refusal, distinct from API errors, is a documented feature: Anthropic's API and Python SDK can resend a request to another model after an HTTP 200 refusal, LangChain offers an opt-in refusal-to-fallback middleware, and Hermes Agent routes refusals to its fallback handler. We tested the real Anthropic client offline and claim availability, not prevalence.

6. Readability and contributions (all). The abstract, introduction, and Figure 1 are rewritten in plain terms around one example, and the introduction now states three contributions explicitly. Section 3 is under one page, with generator derivations in Appendix B; remaining technical terms are replaced by plain phrases or defined at first use.

Unchanged. The original controllers, counts, and cause attributions remain in the paper. The 589 and 143 gains of the original checked controller come from invalid outputs, as reviewers noted; the new controller adds recovery from refusals on top of them.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.