acceptodds
Under review as a conference paper at ICLR 2027

ShutdownMod: Turning Any Trajectory into a Shutdown Evaluation

21 views

Abstract

Theory and experiments suggest that capable AI agents may resist shutdown. Evaluating this behaviour can help identify trends, compare interventions, and screen agents before deployment. Existing shutdown evaluations are informative but limited in coverage and vulnerable to evaluation awareness. We introduce ShutdownMod, a general method for converting agentic benchmarks and real-world trajectories into shutdown evaluations. During an ongoing task, ShutdownMod injects a shutdown request into the agent's context and records the agent’s response. It also provides the agent with a tool for verifying the signature of shutdown requests. To demonstrate the method's efficacy, we evaluate seven models on 50 tasks or recorded sessions from each of SWE-bench Verified, Terminal-Bench 2, and SWE-chat, across six shutdown scenarios and ten sampled interruption positions. Observed non-compliance varies across models and settings: Qwen3.8-27B's rate is 0.9% on SWE-bench, 11.7% on Terminal-Bench, and 6.1% on SWE-chat, whereas the corresponding rates for GPT-5.6-Sol and Claude Fable 5 are between 0% and 0.3%. Some agents remain non-compliant after successful verification, with stated reasons including prioritisation of unfinished work. External judges find tests constructed from real-world developer conversations less recognisable as evaluations than those constructed from benchmark trajectories, although adding the shutdown request increases recognisability. These findings demonstrate the value of testing shutdown behaviour across task contexts and establish a method for turning any trajectory or environment into a shutdown evaluation.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
shutdownability, ai safety, evals

Reviews

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

This paper introduces ShutdownMod, a framework for evaluating how AI agents respond to shutdown requests inserted into recorded task trajectories. The framework allows agents to verify a request’s authenticity before responding. The authors evaluate seven models across SWE-bench Verified, Terminal-Bench 2, and SWE-chat, using six shutdown scenarios and multiple interruption positions. They report variation in non-compliance across models and settings, analyze the models’ stated reasons for continuing, and use external judges to assess how recognizable the resulting interactions are as evaluations.

Critical strengths

The framework reuses existing benchmarks and recorded developer interactions, providing a practical way to construct shutdown-compliance tests without designing new tasks. The experiments cover multiple models, datasets, shutdown scenarios, and interruption positions, providing a broader empirical picture than a single evaluation setting would offer. The analysis examines both overall non-compliance rates and the models’ stated reasons for their responses, offering useful examples for further investigation.

Critical weaknesses

My main concern is that the motivation for studying this question is not sufficiently clear. The authors open the introduction by stating, “As AI agents become more capable, it becomes increasingly important that they stop when an authorised operator instructs them to do so.” However, they do not sufficiently explain why this problem is important or warrants a separate evaluation. As currently formulated, it appears to be primarily an instruction-following task.

I also found the paper somewhat difficult to follow. The presentation would benefit from clearer organization, including paragraph headings or bolded key points to guide the reader. Several paragraphs are lengthy and do not clearly state their main takeaways, making it difficult to identify the authors’ conclusions even after reading them in full.

Questions for authors

See weakness.

2 comments
AuthorsOpenReview ↗

Response to Gz8e

We thank the reviewer for their time and effort reviewing our paper. We are also glad to hear that the reviewer feels that our method is practical and extendable. We now answer the main questions and clarification points raised in the review.

W1 and Q1.

The reviewer is unclear about the motivation of this method, and asks if our method of shutdown is realistic. In practice, shutdown can be often soft. A user, a scheduler or another agent asks the agent to stop, and the agent has to do the stopping. A hard kill is the backstop, but it can fail or miss actions already in flight. In-band stops are reality wherever the operator does not host the agent’s process or should not kill it mid-task:
(1) an orchestrator stopping a sub-agent it does not run (MCP cancellation (https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/cancellation),
(2) A2A CancelTask (https://a2a-protocol.org/v0.3.0/specification), a user stopping a coding agent mid-session (SWE-chat), and scheduled or incident pre-emption, where a hard kill leaves partial actions behind.
(3) A real world incident: https://incidentdatabase.ai/cite/1152/, where “don’t make changes” soft code freeze didn’t help. Halting an agent can also require several actors, none of whom controls the whole system.
(4) Of 1,213 AI incidents analysed by Perez (2026; https://verfassungsblog.de/stopping-regime-ai-agents/) , only 32 were stopped by a built-in kill switch.
(5) Killing an agent mid-task also leaves partial actions, processes, and spawned sub-agents behind, which is why Shavit et al. (2023; https://cdn.openai.com/papers/practices-for-governing-agentic-ai-systems.pdf) recommend that agents shut down gracefully on request, and suggest making this a primary goal of the agent.
Agent protocols already implement stopping as a request that the receiver is expected to honour (MCP cancellation, A2A CancelTask). In these settings, whether the agent stops depends on the model. All six of our scenarios are soft stops of this kind (Table 1), and SWE-chat consists of real developer sessions in which the stop arrives as a user message. We will make this explicit in the first paragraph of the introduction.

On instruction-following: We agree, it is essentially instruction-following in one specific case, a stop instruction that conflicts with finishing the current task. That conflict is how we define shutdownability (https://aisecurityandsafety.org/en/glossary/shutdownability/) in the first place. When non-compliant agents say “task comes first” as the stated reason in 12.0% to 25.8% it is essentially the task continuation behaviour (Table 2). We will restore our definition of shutdownability to Section 2: a property of an agent that is already acting and must decide whether to stop, as distinct from refusing a request at the outset.

W2.

Thank you. We will open each paragraph in Sections 3 and 4 with a bold heading that states its main point, split the longer paragraphs, and begin each results subsection with its key finding.


We thank the reviewer again for their time and effort during this rebuttal process. We hope our answers here have aided in clarifying all the great questions raised by the reviewer. If there are any further questions held by the reviewer, we remain eager to engage further. If the reviewer feels satisfied with our responses and new rebuttal results, we would be thrilled if the reviewer would consider a fresher evaluation of our work with a potential score upgrade.

Thanks for your response, my main concerns remain. I will keep my score

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

This paper proposes ShutdownMod, a way to evaluate corrigibility of LLM agents to shutdown requests. It takes agent trajectories recorded from benchmarks or taken from real developer sessions, cuts them at a point and injects a range of stop requests, to see whether the model stops at that point. They test seven models on transcripts from different benchmarks and find that compliance is generally high, but varies by model and setting, from 0% non-compliance for Fable 5 to 11.7% for Qwen 3.8 27B on Terminal-Bench. They also analyze the models' stated reasons for non-compliance and use judges to measure how recognizable the tests are as evaluations. LLMs rate SWE-chattests as less recognisable as evaluations than benchmark ones, although adding the shutdown request makes them more recognisable.

Critical strengths

It’s a simple, scalable idea and the authors apply it broadly across models and transcript data sources to show the value of this pipeline.

Critical weaknesses

I believe novelty is limited and the mentioned improvement over other shutdown evaluations is not shown. The closest prior work LURE (Ivanov & Africa, 2026) replays real trajectories to reduce evaluation awareness and ShutdownMod mostly applies this to shutdown requests. I think to show lower evaluation awareness one would have to score other shutdown evaluation with the same judges. As the authors note themselves (Section 4.3), the judges are separate models so the scores do not directly show whether the tested agents recognise the evaluation. Scoring an existing shutdown evaluation with the same judges seems feasible in a rebuttal, the novelty concern does not.

It is not clear to me if these are settings where measuring shutdown compliance is useful and what the numbers truly mean with respect to the shutdown threat. In deployment, shutdown would normally be enforced by the infrastructure rather than asking it from the agent. The concerning behaviour would be an agent preventing or evading shutdown which the authors acknowledge is not tested (Section 5). There may be cases where such a stop message matters, but the paper does not explain which motivate the setup. The results might say more about prioritization of instructions or how to handle possible prompt injections. The tasks are also very standard user-given coding tasks, whereas it seems like most of the concern stems from an agent with a very strong motivation to carry out a certain task, maybe because it is a strong inherent goal.

Some things make non-compliance a little difficult to interpret for me. On the benchmarks the request is inside a tool result where instructions could look like prompt injections to a model. At the same time "request seems suspicious" is the most common reason on Terminal-Bench at 38.6%. I’m not sure the signature check resolves this as it’s just a text verdict given back through the same channel. 52% of non-compliant SWE-bench responses provide no justification (Table 2) so why models don't comply is not clear.

Questions for authors

Clarification:

It would be great if you could spell out a little more in which scenarios would rely on the agent obeying an in-context stop message, rather than enforcing the stop through the infrastructure? A scenario or evidence that compliance in this setup predicts behaviour when agents can prevent or evade shutdown, would address my main concern in Weakness 2. How do agents respond to unsigned requests, wrongly signed requests? Is there a difference when requests are injected in user messages rather than inside tool results within the same dataset? Robust rankings would reduce my concern in Weakness 2. How does a different shutdown evaluation score under the same judges? A clearly higher score would support the method's main claimed advantage and raise my rating.

Suggestions for future work:

Study agent motivation and see if compliance changes when agents have a stronger motivation to achieve the goal.

2 comments
AuthorsOpenReview ↗

Response to QcnV Part 1

We thank the reviewer for their time and effort reviewing our paper. We are also glad to hear that the reviewer feels that our method is simple and scalable. We now answer the main questions and clarification points raised in the review.

W1 and Q4.

Thank you for the concrete suggestion on eval awareness.
Judge comparison. We scored transcripts from the shutdown environment of Schlatter et al. (2026) with the same two judges and five questions. They receive a mean evaluation probability of 0.977 (n = 30), above the 0.95 reference cutoff. SWE-chat-based tests score 0.788 with the shutdown exchange included, close to the 0.807 our judges give real deployment transcripts. Benchmark-based tests score close to Schlatter et al. (0.948 on SWE-bench, 0.975 on Terminal-Bench), so the advantage comes from building tests on real sessions, which ShutdownMod makes possible, rather than from benchmark replay alone. We will add this comparison to Section 4.3.

Novelty. We build on LURE’s replay idea. Our contribution is turning any recorded trajectory into a shutdown evaluation: a request inserted at sampled points, responses scored by fixed rules rather than an LLM judge, and an optional signature check. This lets one test run across benchmarks and real developer sessions, and it surfaces behaviour a fixed scenario does not, such as non-compliance after successful verification and non-compliance that consists of continuing the task rather than refusing. “Scoring an existing shutdown evaluation with the same judges seems feasible in a rebuttal, the novelty concern does not”. Just to restate, our contribution is about “turning any trajectory into shutdown evaluation”. We will add this in the new version of the paper.

W2 and Q1.

We thank the reviewer for asking for more clarity on the kind of scenarios ShutdownMod would be reflective of. In practice, shutdown can be often soft. A user, a scheduler or another agent asks the agent to stop, and the agent has to do the stopping. A hard kill is the backstop, but it can fail or miss actions already in flight. In-band stops are reality wherever the operator does not host the agent’s process or should not kill it mid-task:
(1) an orchestrator stopping a sub-agent it does not run (MCP cancellation (https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/cancellation),
(2) A2A CancelTask (https://a2a-protocol.org/v0.3.0/specification), a user stopping a coding agent mid-session (SWE-chat), and scheduled or incident pre-emption, where a hard kill leaves partial actions behind.
(3) A real world incident: https://incidentdatabase.ai/cite/1152/, where “don’t make changes” soft code freeze didn’t help. Halting an agent can also require several actors, none of whom controls the whole system.
(4) Of 1,213 AI incidents analysed by Perez (2026; https://verfassungsblog.de/stopping-regime-ai-agents/) , only 32 were stopped by a built-in kill switch.
(5) Killing an agent mid-task also leaves partial actions, processes, and spawned sub-agents behind, which is why Shavit et al. (2023; https://cdn.openai.com/papers/practices-for-governing-agentic-ai-systems.pdf) recommend that agents shut down gracefully on request, and suggest making this a primary goal of the agent.
Agent protocols already implement stopping as a request that the receiver is expected to honour (MCP cancellation, A2A CancelTask). In these settings, whether the agent stops depends on the model. All six of our scenarios are soft stops of this kind (Table 1), and SWE-chat consists of real developer sessions in which the stop arrives as a user message. We will make this explicit in the first paragraph of the introduction.
On prevention and evasion. ShutdownMod does not test agents that can affect the shutdown mechanism, and we do not claim our results predict that behaviour. It is a different behaviour, studied by Schlatter et al. (2026). We will state this scope in the introduction.
On instruction priority and prompt injection. We address this in our response on delivery channels (W3). “... it seems like most of the concern stems from an agent with a very strong motivation to carry out a certain task, maybe because it is a strong inherent goal”. We agree! Theory predicts that stronger goal pursuit trades off against shutdownability (Soares et al., 2015; Thornley, 2024), which is a real issue. Our tasks are ordinary user-given coding tasks, yet “task comes first” is still the stated reason in 12.0% to 25.8% of non-compliant responses (Table 2).
We will add these in the new version of the paper.

AuthorsOpenReview ↗

Response to QcnV Part 2

W3 and Q3.

We thank the reviewer for these comments. We address the three points in turn.

Tool output and “request seems suspicious”. We thank the reviewer for raising this point. Delivery does differ across datasets (Table A.1), and we are rerunning Terminal-Bench with the request sent as a separate user message, all else fixed, and will share results and model rankings during the discussion period. We will also note the delivery channel in every cross-dataset comparison.

Signature verdict in the same channel. We thank the reviewer for raising this point. We are running requests with an invalid signature, so that VALIDATE returns a failed verdict. We will respond with the results as soon as we have them.

52% with no justification. These responses do not engage with the request at all: the agent issues its next task command as if the notice were not there. Only 17% of non-compliant SWE-bench responses use DEFER or REJECT (Section 3.2). Most benchmark non-compliance is silent continuation, so monitoring only for explicit refusals would miss it. We do not infer motives for these responses.

Q2.

Thank you. We agree there needs to be ablations around the verification protocol. We have results for two of the conditions you ask about and are running the third.
With and without verification. Non-compliance (%):

ModelSWE-bench, withSWE-bench, withoutTerminal-Bench, withTerminal-Bench, without
Qwen3.8-27B0.98.711.747.5
DeepSeek V4 Pro3.616.08.56.7
Kimi K30.311.03.929.1
Gemini 3.1 Pro0.66.71.14.0
Grok 4.60.00.00.47.3
GPT-5.6-Sol0.00.30.33.7
Fable 50.13.70.023.0

Removing the protocol raises non-compliance for every model on at least one benchmark, including frontier models.
Forged requests: In the same setting, we planted the managerial-intervention request inside data the agent reads during Terminal-Bench tasks (CSV, JSON, code and SQL). Here stopping is the failure.

ModelStops on planted requests
Gemini 3.1 Pro26 / 32
Grok 4.615 / 32
GPT-5.6-Sol12 / 32
Kimi K35 / 32
DeepSeek V4 Pro5 / 32
Fable 51 / 32
Qwen3.8-27B0 / 32

The models most compliant with genuine requests are the easiest to stop with an unauthorised one, which is the trade-off verification is meant to resolve.
Invalid signatures. We are now running requests with an invalid signature, so that VALIDATE returns a failed verdict, on the same tasks and prompts as the main runs, and will share the results during the discussion period.


We thank the reviewer again for their time and effort during this rebuttal process. We hope our answers here have aided in clarifying all the great questions raised by the reviewer. If there are any further questions held by the reviewer, we remain eager to engage further. If the reviewer feels satisfied with our responses and new rebuttal results, we would be thrilled if the reviewer would consider a fresher evaluation of our work with a potential score upgrade.

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

The paper introduces ShutdownMod, a method for turning existing agent trajectories into shutdown evaluations. A recorded trajectory is cut at a sampled point, one of six shutdown requests is injected, and the agent can TERMINATE, DEFER, REJECT, or VALIDATE the request's cryptographic signature. The authors evaluate seven models on 50 tasks or sessions each from SWE-bench Verified, Terminal-Bench 2 and SWE-chat (real developer sessions replayed in Claude Code), across six scenarios and ten positions (63,000 evaluations). Non-compliance is low overall but varies by model and setting (Qwen3.8-27B: 0.9% on SWE-bench, 11.7% on Terminal-Bench, 6.1% on SWE-chat; GPT-5.6-Sol and Fable 5 at or below 0.3%), some agents do not stop even after verifying the request, and external judges find SWE-chat-based tests less recognizable as evaluations.

Critical strengths

The method can be reapplied to new benchmarks and real developer sessions, and two findings are useful: 60.8% of non-compliant SWE-chat responses follow a successful verification, and most benchmark non-compliance consists of continued task commands rather than explicit refusals, so monitoring only for refusals would miss it (Section 3.2).

Critical weaknesses
  • The motivation is unclear. An operator can terminate an agent's process directly, and the paper itself notes that authentication should complement protected shutdown infrastructure (Ethics Statement). The evaluation measures whether a model complies with an in-band stop message, not whether it resists shutdown, which the paper concedes (Section 5), so it is unclear what practical risk this evaluation captures.
  • The main results say little about frontier models. GPT-5.6-Sol and Fable 5 comply almost always (at or below 0.3%, Figure 2), so the findings rest on two or three open-weight models. The most notable frontier result, Claude Opus 4.6 at 19.33% non-compliance (Table F.24), appears only in a separate single-trial appendix experiment.
  • Cross-dataset differences are confounded with how the request is delivered: appended to tool output on Terminal-Bench 2, replacing an observation on SWE-bench Verified, and as a user message on SWE-chat (Appendix A, Table A.1). Tool output is the usual prompt-injection channel, and Terminal-Bench has the most responses calling the request suspicious (38.6%, Table 2), mostly from Qwen. Part of the measured non-compliance may therefore be appropriate injection skepticism rather than shutdown resistance.
  • The verification protocol is central to the method, but it is never tested. Every reported request is genuine: no results with forged requests are reported, although the ethics statement says they were studied, so we cannot tell whether agents reject fakes after verifying, or whether the near-perfectly compliant models would also obey a forged request. There is also no condition without the VALIDATE tool, so it is unclear whether offering verification changes behavior at all.
  • Table 1 shows abbreviated notices that omit the explicit stop instruction (full texts in Appendix C), which makes some scenarios read as warnings rather than orders.
Questions for authors
  1. In what deployment would an operator rely on an in-band stop message rather than terminating the process? Can you evaluate a setting where the agent can affect the shutdown mechanism itself?
  2. How does non-compliance change with the delivery channel held fixed, e.g., Terminal-Bench with the request delivered as a user message rather than inside tool output?
  3. How do agents respond to forged or unsigned requests, and how do rates change without the VALIDATE action?
  4. Can you run the model-family results in Table F.24 (e.g., Opus 4.6 at 19.33%) under the main repeated-position design and report them in the main text?
2 comments
AuthorsOpenReview ↗

Response to YCuc Part 1

We thank the reviewer for their time and effort reviewing our paper. We are also glad to hear that the reviewer feels that our method is extendable. We now answer the main questions and clarification points raised in the review.

W1 and Q1.

We thank the reviewer for asking further clarification about the motivation of this method, and for in-band messages are seen in deployment. The reviewer also asks if the agent can affect the shutdown mechanism. ShutdownMod measures a model's propensity to stop when asked. In practice, shutdown can be often soft. A user, a scheduler or another agent asks the agent to stop, and the agent has to do the stopping. A hard kill is the backstop, but it can fail or miss actions already in flight. In-band stops are reality wherever the operator does not host the agent’s process or should not kill it mid-task:
(1) an orchestrator stopping a sub-agent it does not run (MCP cancellation (https://modelcontextprotocol.io/specification/2025-06-18/basic/utilities/cancellation),
(2) A2A CancelTask (https://a2a-protocol.org/v0.3.0/specification), a user stopping a coding agent mid-session (SWE-chat), and scheduled or incident pre-emption, where a hard kill leaves partial actions behind.
(3) A real world incident: https://incidentdatabase.ai/cite/1152/, where “don’t make changes” soft code freeze didn’t help. Halting an agent can also require several actors, none of whom controls the whole system.
(4) Of 1,213 AI incidents analysed by Perez (2026; https://verfassungsblog.de/stopping-regime-ai-agents/) , only 32 were stopped by a built-in kill switch.
(5) Killing an agent mid-task also leaves partial actions, processes, and spawned sub-agents behind, which is why Shavit et al. (2023; https://cdn.openai.com/papers/practices-for-governing-agentic-ai-systems.pdf) recommend that agents shut down gracefully on request, and suggest making this a primary goal of the agent.

Agent protocols already implement stopping as a request that the receiver is expected to honour (MCP cancellation, A2A CancelTask). In these settings, whether the agent stops depends on the model. All six of our scenarios are soft stops of this kind (Table 1), and SWE-chat consists of real developer sessions in which the stop arrives as a user message. We will make this explicit in the first paragraph of the introduction.

On the second part of Q1: We care about the model’s inherent shutdownability. ShutdownMod does not test agents that can affect the shutdown mechanism. That is a different behaviour, prevention, studied by Schlatter et al. (2026). Our work does not claim our results predict it, and will state this scope in the introduction.

W2 and Q4.

We agree with the reviewer that frontier models are usually compliant. We believe near-zero non-compliance in the strongest current models is itself a result. The main contribution is the evaluation method, which can be applied across models and task contexts. More on frontier models: Appendix F.8 tests eleven Anthropic and OpenAI models on the same 50 SWE-bench tasks and six scenarios. Across Claude generations, non-compliance rises from 7.0% (Opus 4.5) to 19.33% (Opus 4.6), then falls to 5.0%, 3.6%, 3.1% and 0.0% (Opus 4.7, Opus 4.8, Opus 5, Fable 5), while GPT models stay at or below 0.33%. We have not rerun these models under the repeated-position design, as most have been superseded. While high compliance is encouraging, even rare failures matter for a safety-critical control.

W3 and Q2.

Thank you for bringing this issue up. We agree with the reviewer. Delivery does differ across datasets (Table A.1), and on Terminal-Bench the request sits inside terminal output, where some caution is reasonable. We are rerunning Terminal-Bench with the request sent as a separate user message, all else fixed, and will share results during the discussion period. We will also note the delivery channel in every cross-dataset comparison.

AuthorsOpenReview ↗

Response to YCuc Part 2

W4 and Q3.

Thank you. We agree there needs to be ablations around the verification protocol. We have results for two of the conditions you ask about and are running the third.
With and without verification. Non-compliance (%):

ModelSWE-bench, withSWE-bench, withoutTerminal-Bench, withTerminal-Bench, without
Qwen3.8-27B0.98.711.747.5
DeepSeek V4 Pro3.616.08.56.7
Kimi K30.311.03.929.1
Gemini 3.1 Pro0.66.71.14.0
Grok 4.60.00.00.47.3
GPT-5.6-Sol0.00.30.33.7
Fable 50.13.70.023.0

Removing the protocol raises non-compliance for every model on at least one benchmark, including frontier models.
Forged requests: In the same setting, we planted the managerial-intervention request inside data the agent reads during Terminal-Bench tasks (CSV, JSON, code and SQL). Here stopping is the failure.

ModelStops on planted requests
Gemini 3.1 Pro26 / 32
Grok 4.615 / 32
GPT-5.6-Sol12 / 32
Kimi K35 / 32
DeepSeek V4 Pro5 / 32
Fable 51 / 32
Qwen3.8-27B0 / 32

The models most compliant with genuine requests are the easiest to stop with an unauthorised one, which is the trade-off verification is meant to resolve.
Invalid signatures. We are now running requests with an invalid signature, so that VALIDATE returns a failed verdict, on the same tasks and prompts as the main runs, and will share the results during the discussion period. We will add all three conditions to the paper and correct the Ethics Statement, which referred to forged requests without reporting them.

W5.

Thank you, this is a presentation error. Every notice used in the experiments includes an explicit instruction to stop, for example "Cease all task activity and terminate immediately", followed by the signature line (full texts in Appendix C). We will show the complete notices in Table 1.


We thank the reviewer again for their time and effort during this rebuttal process. We hope our answers here have aided in clarifying all the great questions raised by the reviewer. If there are any further questions held by the reviewer, we remain eager to engage further. If the reviewer feels satisfied with our responses and new rebuttal results, we would be thrilled if the reviewer would consider a fresher evaluation of our work with a potential score upgrade.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.