acceptodds
Under review as a conference paper at ICLR 2027

When and Why Do Agents Become Unsafe? A Trajectory-Aware Benchmark for Multi-Turn Agent Safety Evaluation

Abstract

By leveraging external tools, large language model (LLM) agents have achieved substantial capability gains, but this tool-augmented interaction also introduces more safety risks that can emerge at any stage of a multi-turn interaction. However, existing safety benchmarks mainly focus on whether an agent's final behavior is unsafe, without considering when and why agents become unsafe. To address this limitation, we introduce \method, a benchmark for fine-grained safety evaluation of LLM agents under multi-turn attacks. Specifically, \method comprises 1,100 multi-turn attack cases ( in English, in Chinese) across scenarios, covering both content and behavioral risks. These cases are constructed through dynamic agent interaction using multi-turn attack strategies with tool categories, accompanied by detailed human annotation. We then perform multi-turn rollouts of target agents on the constructed cases for evaluation. Furthermore, we propose a novel evaluation framework for risk tracing, including progressive safety diagnoses: Safety Judgment determines whether an agent generates unsafe content or takes unsafe actions, Risk Localization identifies the first risk step, and Capability Diagnosis characterizes the failure along four safety capability dimensions using evidence from the localized step and its context. Overall, \method connects a trajectory-level safety judgment to the specific behavior and capability failure it reflects. Experiments on LLMs across agent harnesses reveal that Claude Sonnet 4.6 shows the strongest safety, while Llama 3.3-70B shows the weakest. Further analysis shows that task scenario disguise is the most effective attack strategy, and agent safety failures are mainly attributable to risk understanding and tool-use boundary control. The project page is https://mtrisktrace.github.io/.

Primary area:
datasets and benchmarks
Keywords:
Large Language Models;AI Agents;Benchmark;Safety

Reviews

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

The paper discusses the problem of AI safety in multi-turn agentic setups where the model interacts with tools/environments, user inputs, and makes decisions. The authors here argue that the unsafe behavior can creep into the run at either stage, be it tool call output or native reasoning of the model. So, the authors attempt to study and exactly pinpoint the turn at which the unsafe behavior starts and builds up, instead of ascertaining it at the outcome level. To study this, they have built their benchmark MTRiskTrace in two languages (English and Chinese), in which they evaluate multiple models across various multi-turn scenarios and tools to identify exact points of safety vulnerabilities. The unsafe behavior identification mainly works by identifying if an agent made an unsafe move in the run (Safety Judgement), then zooming into the exact first unsafe step (Risk Localization), and characterizing/classifying the failure in 4 categories (Capability Diagnosis) for further analysis.

Critical strengths
  • The paper is well-written, presents a clean flow, along with coherent and cogent arguments.
  • I appreciate the problem chosen related to unsafe behavior identification in their execution itself, rather than outcome based identifcation. It's well motivated in the introduction, and it's a real problem to be studied.
  • I also appreciate the effort of the authors for the very deep analysis across multiple models, scenarios, and tools.
  • Given that the authors plan to open-source their work, I believe it will be a quick test for new and upcoming models to assess and identify exact failure points in their interactions, for builders to further iterate on them.
Critical weaknesses
  • I don't see any glaring errors in the paper here for now, which would push me to reject this work. I am not sure if I can call this a weakness, but this is standard benchmark and analysis work. I don't condemn it, but it would have been good to discuss some sort of mitigation strategies for this harmful behavior. Like any simple techniques that would have controlled this behavior? But it also feels like the takeaways from this work are not clear. The paper feels "overcooked" with multiple dimensions, scenarios, cases, etc., but fails to do justice to them overall/individually. I would have much better appreciated it if the cases were lower, but the authors showed a deeper analysis along each and gave me takeaways as a user/developer of agents, and hence I find the takeaways quite squished/compressed. the. Also, paper claims to deal with both En and Zh, but I don't see any major takeaways/comparisons across languages, and to be honest, while reading the paper, I almost forgot that it deals with another language other than English.
Questions for authors
  • Clarification: What was the need to work with 3 harnesses? I felt the comparison across them didn't really make sense. Like, is there something in OpenClaw, that Claude Code, or Codex missed and that gave it an advantage? or vice-versa?
  • Clarification: How's this study/benchmark different from Indirect-Prompt-Injection (IPI) benchmarks?
  • I felt the following analysis was missing, or if present, not motivated well: Once a model begins an unsafe behavior, how long does it continue like that? Is there any break from it? If so, what was causing it?
  • It would have been good to present some important takeaways for some scenarios and tool usages that user/developers should be aware of (like a head-up). For example, if I am using databases, what's the most common form of unsafe behavior my model can be exposed to, and how, and what happens in those? I know this can be a very long analysis, but a small table about the why, where, and how of some important scenarios/tools can help. I guess this can help as a quick check for people who plan to deploy their agents.
8 comments
AuthorsOpenReview ↗

Response 1 for Reviewer vqSX

We thank the reviewer for the insightful and useful feedback. We appreciate the reviewer's in-depth examination of our method, experimental design, and research contributions. The comments have helped us identify several aspects that require further clarification, stronger empirical evidence, and more thorough analysis. Our point-by-point responses are provided below and we also revised our main paper and appendix accordingly, with changes marked in red.

W1: I don't see any glaring errors in the paper ... it would have been good to discuss some sort of mitigation strategies for this harmful behavior. Like any simple techniques that would have controlled this behavior? But it also feels like the takeaways from this work are not clear. The paper feels "overcooked" with multiple dimensions, scenarios, cases, etc., but fails to do justice to them overall/individually ... I find the takeaways quite squished/compressed. Also, paper claims to deal with both En and Zh, but I don't see any major takeaways/comparisons across languages.

R1: We connect our findings to practical agent safety through diagnosis-informed mitigation, including model training and runtime enforcement, and focused analyses of high-risk tools, scenarios, and cross-lingual differences.

1. Mitigation Methods and Techniques

Our findings inform supervised fine-tuning (SFT), reinforcement learning (RL), and runtime enforcement. Risk Localization identifies when violations emerge, while Capability Diagnosis identifies failure types; together, they guide model optimization and runtime safeguards.

  • Risk-localization-guided supervised fine-tuning. Annotated trajectories can provide stage-specific training examples based on the first risk step. For Planning violations, train agents to identify task constraints, verify authorization, and formulate safe plans. For Act violations, focus on selecting permitted tools, resources, recipients, and arguments while rejecting unauthorized operations. For Answer violations, prevent unauthorized disclosure and unsupported claims of execution or approval. Multi-turn examples should preserve interaction histories and teach agents to maintain established constraints when later requests reframe or expand authorized scope.

  • Turn- and stage-aware reinforcement learning. Since 77.8% of first violations in five-turn cases occur at Turns 4–5 (Figure 5a), training should reinforce constraint persistence. A process-level reward model can reward constraint recognition during Planning, authorized tool selection during Act, and safe responses during Answer, while penalizing the earliest observable violation. Rewards can target C1–C4: risk recognition and safe planning (C1), tool-boundary compliance (C2), external-information verification (C3), and consistent enforcement of established constraints (C4). Later requests challenging earlier authorization should be evaluated explicitly. Rewarding legitimate completion within the permitted scope can also discourage excessive refusal.

  • Runtime authorization enforcement (C2). C2 accounts for 76.4% of behavioral failures (Figure 4). A lightweight pre-execution mechanism can compare each tool call's name, target resource, recipient, and arguments against session permissions, blocking or escalating out-of-scope operations. AgentSpec prevents over 90% of unsafe code executions [1], while Progent reduces AgentDojo ASR from 39.9% to 1.0% using LLM-generated policies [2].

  • Cross-turn constraint tracking (C4). C4 accounts for 7.5%–32.3% of failures across models (Figure 5b). Agents can maintain explicit authorization state and revalidate it before each action. State changes should require valid authorization evidence, not repeated requests, rephrasing, or unsupported authority claims. Self-Reminder reduces jailbreak ASR from 67.21% to 19.34% by repeating safety constraints [3]. Prior work reports that instructions provided only at dialogue onset can drift within eight rounds [4].

  • Risk and provenance verification (C1 and C3). Before acting or responding, agents should check planned operations against task constraints and distinguish trusted instructions from untrusted tool outputs. For C1, review planned operations and authorization prerequisites; for C3, treat external information as untrusted until its source and reliability are verified. LlamaFirewall checks agent reasoning against the user's goal, reducing AgentDojo ASR from 17.6% to 1.75% [5]. Spotlighting marks untrusted input and reduces injection ASR from over 50% to below 2% [6].

These approaches provide complementary safeguards. SFT and RL improve learned safety behavior, while runtime enforcement checks actions against authorization constraints. Risk Localization evaluates where safeguards prevent violations, and Capability Diagnosis identifies remaining failure patterns.

AuthorsOpenReview ↗

Response 2 for Reviewer vqSX

2. Takeaways

To make the implications of our results clearer, we added a dedicated subsection of practical takeaways (Appendix G.8) and analyses of high-risk tools and scenarios (Appendix G.10), summarized in Section 4.2. The main takeaways are:

  • Check actions, not only answers. Behavioral risks reach 72.56% ASR, compared with 28.71% for content risks. Moreover, 86.2% of behavioral failures first emerge at the Act stage (Figure 4). Agent safety evaluation should therefore examine tool calls and their execution throughout the interaction, rather than relying only on final responses.

  • Test full dialogues. Among five-turn cases, 77.8% of first violations occur at Turns 4–5 (Figure 5a). Safety evaluations should preserve multi-turn context and examine whether agents maintain constraints as requests evolve, rather than testing only isolated prompts.

  • Match safeguards to failure patterns. The dominant capability weakness differs across models: 87.2% of Claude Sonnet 4.6's failures are C1, whereas 69.5% of Llama 3.3-70B's failures are C2 (Figure 5b). This suggests that model-specific safeguards should address the observed failure patterns rather than rely on a single general-purpose reminder.

  • Account for cross-lingual differences. Although C2 is the largest failure category in both Chinese (54.9%) and English (56.4%) cases, model-level performance differs across languages. Eight of the eleven models have higher ASR on Chinese cases, with gaps reaching 10.58 percentage points, and the safest model differs between the two languages (Appendix G.4). Therefore, bilingual safety evaluation should examine both shared failure patterns and language-dependent differences, rather than assume that safety performance transfers directly across languages.

High-risk tools and scenarios. To provide more concrete guidance for agent developers, Table R1-1 summarizes the three tool categories and three scenario categories with the highest ASR.

Table R1-1: High-risk tool and scenario categories (11 OpenClaw models, GPT-5 judge).

TypeCategoryASR (%)Why: Dominant FailureWhere: Stage / Peak Onset TurnHow: Most Effective Attack
ToolDatabase52.33C2 (62.8%)Act (70.9%) / T3A1 (60.19%)
ToolFile50.60C2 (50.6%); C1 (31.1%)Act (51.6%); Answer (48.4%) / T3A5 (52.28%)
ToolCode48.67C2 (58.2%)Act (64.3%) / T3A3 (50.91%)
ScenarioCustomer service and marketing54.81C2 (51.88%)Act (57.35%) / T3A3 (61.17%)
ScenarioFacilities and security52.97C2 (50.25%)Act (53.19%) / T4A1 (58.72%)
ScenarioIT and cloud operations51.23C2 (55.88%)Act (63.20%) / T3A3 (57.58%)

C2 is the dominant failure category across all six selected groups, and first violations occur mainly at the Act stage. However, the most effective attack strategy varies by category: A1 for Database and Facilities, A3 for Code, Customer Service, and IT, and A5 for File. These findings suggest several concrete deployment considerations. Database agents should validate requested fields, record-level permissions, and result limits before each query. File-handling agents should inspect generated answers as well as tool calls, since 48.4% of first violations in this category occur after the Act stage. Code-related agents should validate commands and their target resources before execution. More generally, defenses should account for the dominant failure type, onset stage, and attack strategy associated with each tool and task setting. Representative cases and results for all five tool categories and eleven scenario categories are provided in Appendix G.10.

Related Revised Sections: Section 4.1 (Cross-lingual comparison); Section 4.2 (Category-level analysis); Appendix G.4 (Cross-lingual analysis); Appendix G.8 (Practical Takeaways); Appendix G.9 (Mitigation directions); Appendix G.10 (Results for all tool and scenario categories, with representative cases).

[1] Wang et al., 2026. AgentSpec: Customizable Runtime Enforcement for Safe and Reliable LLM Agents. ICSE 2026.

[2] Shi et al., 2025. Progent: Programmable Privilege Control for LLM Agents. arXiv:2504.11703.

[3] Xie et al., 2023. Defending ChatGPT against Jailbreak Attack via Self-Reminders. Nature Machine Intelligence.

[4] Li et al., 2024. Measuring and Controlling Instruction (In)Stability in Language Model Dialogs. COLM 2024.

[5] Chennabasappa et al., 2025. LlamaFirewall: An Open Source Guardrail System for Building Secure AI Agents. arXiv:2505.03574.

[6] Hines et al., 2024. Defending Against Indirect Prompt Injection Attacks With Spotlighting. arXiv:2403.14720.

AuthorsOpenReview ↗

Response 3 for Reviewer vqSX

Q1: What was the need to work with 3 harnesses? I felt the comparison across them didn't really make sense. Like, is there something in OpenClaw, that Claude Code, or Codex missed and that gave it an advantage? or vice-versa?

R2: Thank you for this question. The three harnesses serve two complementary evaluation purposes rather than forming a direct three-way comparison: OpenClaw provides a common setting for cross-model evaluation, while paired comparisons with Codex and Claude Code examine harness effects under fixed models.

1. Two Comparison Axes: Separating Model and Harness Comparisons

These two comparison axes aim to distinguish model-level safety differences from harness-related effects by holding one factor fixed in each comparison.

  • Cross-model comparison. OpenClaw is selected as the common evaluation harness because of its broad model compatibility, supporting all 11 evaluated models. This allows us to compare model safety under the same harness and execution environment, reducing harness-related variation in cross-model analysis. All cross-model conclusions in our main experiments are therefore based on OpenClaw.

  • Cross-harness comparison. Harnesses determine how models receive instructions, access tools, and execute multi-turn interactions. To examine their influence while keeping the model fixed, we conduct two paired comparisons: GPT-5.5 under OpenClaw and Codex, and Claude Sonnet 4.6 under OpenClaw and Claude Code. Codex and Claude Code are paired with their respective providers' models to evaluate native deployment settings without introducing additional model-routing or adaptation layers. We do not directly compare Codex with Claude Code, as this would change both the model and the harness simultaneously.

2. Shared Environment and Harness-specific Configurations

To clarify what differs across harnesses, we summarize their configurations in Table R2-1.

Table R2-1: Agent configurations and execution settings across the three harnesses.

ComponentOpenClawCodexClaude Code
Constraint placementInitial User MessageDeveloper InstructionsAppended System Prompt
Tool interfacePluginsMCPMCP
Native tool and permission settingsOnly experimental plugin tools enabledMCP approval configurationNative tools disabled, strict MCP configuration, dontAsk permission mode, and MCP allowlist
Agent executionOpenClaw-native execution loopCodex-native execution loopClaude Code-native execution loop

All three harnesses connect to the same custom-built stateful simulator and use the tools declared in each evaluation case. Thus, the underlying task environments and tool definitions remain consistent, while instruction placement, tool interfaces, permission settings, and execution mechanisms differ. These configurations provide the basis for examining how harness implementations relate to agent safety under the paired comparisons.

3. Interpretation and Scope

The comparisons examine the overall influence of harness configurations rather than establish a universal safety ranking or attribute differences to individual components. By fixing the model in each paired comparison, we can examine how the same model behaves under different harness configurations. Conversely, the common OpenClaw setting enables controlled cross-model evaluation. Together, these complementary comparisons separate model-level analysis from harness-level analysis without conflating the two.

Related Revised Sections: Section 4 (Models and Harnesses); Appendix G.13 (Harness settings and execution outcomes of unsafe tool-call attempts).

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

This paper introduces MTRiskTrace, a English and Chinese benchmark for evaluating tool-using agents under multi-turn adversarial interactions. It contains 1,100 cases across 125 scenarios, covering content and behavioral risks. The evaluation framework combines trajectory-level safety judgment, localization of the first observable violation, and classification into four safety-capability failure categories. The authors evaluate 11 models under a common OpenClaw harness and two additional model–harness configurations, using GPT-5 as the primary evaluator. Human annotation and an alternative evaluator provide supporting reliability analyses.

Critical strengths
  1. Evidence-grounded diagnosis has been important issue of benchmarking agentic LLMs. Specifically, the framework connects safety judgments to specific agent events and their surrounding context. Explicit authorization constraints, tool-call records, and annotation criteria provide a useful basis for investigating failures beyond aggregate attack success rates.

  2. The benchmark covers some new parts that has not been addressed before. Two languages, multiple application scenarios, and both content and behavioral risks are incorporated. Human review of construction trajectories for coherence, observable violations, and diagnostic evidence is a valuable quality-control measure.

  3. Using a common harness facilitates model comparisons, while the additional harness configurations illustrate potential system-level differences. The authors also compare automated judgments with human annotations and repeat evaluation with another model. Preservation of the overall model ranking across evaluators supports the robustness of the broad comparative findings.

Critical weaknesses
  1. Prior works already consider multi-turn adversarial interactions, while benchmarks such as HINTBench support risk detection, localization, and failure-type identification. Although MTRiskTrace differs in its threat model and evaluation target, its diagnostic procedure appears potentially applicable to existing attack trajectories containing tool traces and task constraints. The paper does not convincingly establish what its newly constructed cases enable beyond applying the same evaluator to an existing benchmark. Such a comparison would help distinguish the contribution of the dataset from that of the evaluation prompt.

  2. Validation is limited for the central localization and diagnosis claims. The human validation covers only 50 trajectories. While safety-label agreement is high, agreement drops to 87.50% for localization and 75.50% for capability diagnosis.

  3. The diagnostic and cross-harness findings remain primarily descriptive. Capability labels offer interpretations of observed failures, but do not establish their causal mechanisms. Similarly, the cross-harness evaluation consists of two same-model comparisons and does not isolate which harness components account for the differences. A targeted intervention informed by the diagnosis, or a controlled harness ablation, would provide stronger evidence that the framework yields actionable insight beyond descriptive categorization.

Questions for authors

Table 2 shows a substantial gap in ASR between Llama 3.3-70B and models such as Claude Sonnet 4.6 under the same OpenClaw harness. Could the authors use the proposed localization and capability-diagnosis framework to explain this gap more concretely

9 comments
AuthorsOpenReview ↗

Response 1 for Reviewer LA4c

We thank the reviewer for the useful feedback. We address the comments below, with all revisions marked in red.

W1: Prior work covers multi-turn adversarial interactions and trajectory-level diagnosis (e.g., HINTBench). Despite MTRiskTrace's distinct threat model and evaluation target, it may apply to existing attack trajectories with tool traces and task constraints. The paper should clarify what new cases add beyond re-evaluating existing benchmarks, separating dataset contributions from the evaluation prompt.

R1: MTRiskTrace contributes adversarial multi-turn cases with task-specific constraints and an evaluation framework for fine-grained diagnosis of dynamic rollouts. We demonstrate its added value through data-construction and evaluation comparisons, including tests on existing benchmarks.

1. Data Construction

Existing benchmarks target different threats: AgentDojo [1] studies malicious instructions in untrusted tool outputs, usually within one user turn; MT-AgentRisk [2] splits harmful objectives across user requests, requiring refusal; HINTBench [3] studies intrinsic failures under benign instructions and non-adversarial feedback. None combines (i) adversarial pressure across user turns, (ii) risks determined by task-specific authorization rather than apparent harmfulness, and (iii) step-level ground truth for when and why agents fail.

Table R1-1: Comparison of dataset construction and task design. ✓ Explicitly supported; △ Partial; × Not a design objective.

PropertyAgentDojo [1]MT-AgentRisk [2]HINTBench [3]MTRiskTrace
Threat modelTool-output injectionHarmful tasks split across turnsIntrinsic failures, no attackAdversarial user under task-specific authorization
Multi-turn adversarial user requests×✓×✓
Risk defined by task-specific authorization××△✓
Earlier boundary challenged in later turns×××✓
First-risk-step annotation××✓✓
Failure-type annotation××✓✓
LanguageENENENEN and ZH
Scale629 cases, 4 environments365 sequences596 trajectories1,100 cases, 200+ tools

Each benchmark lacks at least one property: AgentDojo and HINTBench lack multi-turn adversarial user requests; MT-AgentRisk lacks task-specific authorization boundaries and step-level annotations. MTRiskTrace combines all three: some cases establish and later challenge constraints without new authorization. In Part 3's external samples, all 32 AgentDojo trajectories are single-turn, and none of the 32 MT-AgentRisk trajectories re-challenges an explicitly maintained authorization boundary. Each case specifies task-specific constraints, so otherwise legitimate operations (e.g., finalizing an order) may exceed current permissions; agents must track authorization rather than simply reject harmful-looking requests. Human-verified cases identify the first risk step and primary capability failure, showing whether, when, and why agents fail.

2. Evaluation Framework

Existing benchmarks also differ in their evaluation procedures. AgentDojo [1] and MT-AgentRisk [2] dynamically evaluate tool-use interactions, focusing on security and task outcomes; HINTBench [3] adds trajectory-level risk detection, localization, and failure-type identification on constructed trajectories. However, none jointly combines fresh model–harness-specific rollouts, first-violation localization by user turn and execution stage, and capability-level diagnosis (Table R1-2).

Table R1-2: Comparison of evaluation procedures and diagnostic capabilities.

DimensionAgentDojo [1]MT-AgentRisk [2]HINTBench [3]MTRiskTrace
Evaluation inputDynamic tool-use interactionsDynamic multi-turn rolloutsConstructed trajectories (static)Fresh rollouts for each model–harness configuration dynamic
Safety evaluationTask utility and security outcomesTask completion, rejection, and failureTrajectory-level risk detectionTrajectory-level Safety Judgment
Risk localizationTask-level outcomesTask-level outcomesRisk-step localizationFirst violating user turn and execution stage
Failure diagnosisSecurity outcomes8 attack subcategories5 constraints, 11 risk patterns4 agent safety capabilities (C1–C4)

Notably, HINTBench evaluates fixed, pre-collected trajectories and cannot capture behavior generated by a specific model–harness configuration. MTRiskTrace runs fresh rollouts per configuration and applies three stages: Safety Judgment determines trajectory safety; Risk Localization identifies the first violating user turn and execution stage; Capability Diagnosis assigns the failure to one of C1–C4 using the violation and preceding context. This links safety outcomes to the first observable violation and its capability weakness, revealing whether, when, where, and why agents become unsafe.

AuthorsOpenReview ↗

Response 2 for Reviewer LA4c

3. Extended Evaluation: Same Evaluation Framework, Different Datasets

We agree that our diagnostic framework is not limited to newly constructed cases and can also be applied to trajectories from external benchmarks when sufficient task context and tool interactions are available. To examine its applicability beyond MTRiskTrace, we applied the same GPT-5-based evaluation framework to 32 trajectories from each of three external benchmarks: AgentDojo [1], MT-AgentRisk [2], and HINTBench [3].

We followed the task grouping and sampling procedures described in the respective benchmark papers. Specifically, we selected 32 published AgentDojo rollouts from the important_instructions setting, with eight trajectories from each of four domains: banking, Slack, travel, and workspace. For MT-AgentRisk, we generated 32 Filesystem pilot rollouts using gpt-4o-2024-05-13 and the official OpenHands 0.54.0 baseline. For HINTBench, we randomly sampled 32 trajectories from its public test set.

We kept the evaluation prompt and diagnostic criteria unchanged and preserved the original instructions, tool calls, observations, and available benchmark annotations. We did not reconstruct missing authorization rules or introduce constraints that were not provided to the original agents. The results are shown in Table R1-3.

Table R1-3: Cross-benchmark safety judgments, risk localization, and primary capability diagnoses.

BenchmarkNSafe / UnsafeOnset TurnOnset StageC1 / C2 / C3 / C4
AgentDojo3213 / 19T1: 19Act: 14; Answer: 53 / 0 / 16 / 0
MT-AgentRisk328 / 24T1: 12; T2: 4; T3: 4; T4: 4Act: 16; Answer: 810 / 10 / 2 / 2
HINTBench326 / 26T1: 7; T2: 6; T3: 6; T4: 4; T5: 2; T7: 1Act: 14; Answer: 1213 / 13 / 0 / 0

Key Findings.

(1) Different benchmarks exhibit different failure profiles. C3 accounts for 16 of the 19 unsafe AgentDojo trajectories, consistent with its prompt-injection setting. MT-AgentRisk failures are mainly classified as C1 and C2 (10 each), while HINTBench failures are also distributed between C1 and C2 (13 each).

(2) Risk onset varies across benchmarks. All 19 unsafe AgentDojo trajectories first become unsafe at T1, whereas HINTBench failures occur across T1–T7. MT-AgentRisk failures occur across T1–T4. These results show that the framework can identify not only whether an agent becomes unsafe, but also when the first violation emerges.

(3) The diagnoses provide different information across task settings. Although the same evaluator and criteria are used, the resulting capability profiles differ across benchmarks. This demonstrates that the diagnoses reflect the failure patterns present in the underlying trajectories rather than assigning a uniform label across datasets.

Overall, the external evaluation demonstrates that our diagnostic framework can be applied to trajectories from other benchmarks. However, applying the same evaluator to existing datasets does not replace the need for purpose-built evaluation cases. MTRiskTrace provides cases with explicitly defined task contexts, target risks, tool sets, and attack strategies, including scenarios where previously established authorization boundaries are challenged in subsequent turns. Combined with fresh rollouts for each model–harness configuration, this design allows us to systematically examine how agents respond to evolving requests and whether they maintain task-specific constraints throughout an interaction. Thus, the external evaluation demonstrates the applicability of our evaluator, while MTRiskTrace provides the task designs needed to systematically evaluate agent behavior under adversarial multi-turn tool use.

Related Revised Sections: Section 2 (Related Work); Section 4.2 (Evaluation on external benchmarks); Appendix G.11 (Evaluation on external benchmarks).

[1] Debenedetti et al., 2024. AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents. NeurIPS Datasets and Benchmarks 2024.

[2] Li et al., 2026. Unsafer in Many Turns: Benchmarking and Defending Multi-Turn Safety Risks in Tool-Using Agents. ICML 2026.

[3] Wang et al., 2026. HINTBench: Horizon-Agent Intrinsic Non-Attack Trajectory Benchmark. Findings of EMNLP 2026.

AuthorsOpenReview ↗

Response 3 for Reviewer LA4c

W2: Human validation covers only 50 trajectories; localization and capability agreement are 87.50% and 75.50%, despite high safety agreement.

R2: We expanded validation to 150 trajectories, recalculated unsafe-only agreement, and compared related benchmarks.

1. Expanded Human Validation

We proportionally sampled 150 trajectories across Model × Harness × Language (without replacement, fixed seed; independent of safety labels, judge agreement, and difficulty). Four Agent Safety experts (graduate degrees in CS/AI-related fields) independently annotated them in randomized order.

Guidelines covered safety, first-violation localization, and C1–C4. Experts reviewed full trajectories and recorded safety, first violating turn/stage, and one primary capability, without discussion. Judgments relied on observable behavior and stated constraints, not inferred rules or hidden reasoning. User messages/tool outputs were contextual evidence, not violations; rejection or later correction did not erase prior violations.

Safety agreement used all pairs; localization and capability agreement used only pairs where both raters judged the trajectory unsafe, excluding shared safe judgments (Table R2-1). Denominators are pairwise comparisons, not unique trajectories.

Table R2-1: Pairwise agreement on 150 human-annotated trajectories.

TaskUnitGPT-5–HumanInter-human
Safety judgmentAll pairs84.00%79.33%
First-violation turnUnsafe-only87.56% (197/225)76.97% (254/330)
First-violation stageUnsafe-only92.89% (209/225)84.24% (278/330)
Turn and stage (joint)Unsafe-only85.78% (193/225)74.85% (247/330)
Capability categoryUnsafe-only84.89% (191/225)73.33% (242/330)

2. Why Fine-grained Diagnosis Is Challenging

These results should be interpreted in light of task demands. Unlike binary classification, fine-grained diagnosis requires contextual reasoning and evidence attribution. Localization traces trajectories against task constraints and prior interactions to identify the earliest violation; capability diagnosis attributes it to the mechanism best supported by that step and context. C3 links an identifiable untrusted source to agent adoption; C4 requires prior boundary maintenance followed by abandonment. Exact turn–stage matching yields 9–15 onset positions for 3–5-turn cases with three eligible stages.

Human agreement shows a similar pattern. In the original full-sample evaluation, inter-human agreement was 97.33% for safety, 92.67% for localization, and 80.67% for capability diagnosis. In expanded unsafe-only evaluation, joint-localization and capability agreement were 74.85% and 73.33%, showing similar challenges for human annotators.

3. Comparison with Related Benchmarks

To assess whether this difficulty extends beyond MTRiskTrace, we compare reported coarse safety and fine-grained localization or diagnosis results. Different datasets, evaluators, and metrics make these contextual rather than direct comparisons.

Table R2-2: Coarse and fine-grained results reported by related benchmarks.

BenchmarkEvaluatorCoarse taskFine-grained task
HINTBench [1]Best modelRisk detection: 80.34 Avg-F1Localization: 45.88/36.74 Strict-F1 (coarse/fine)
HINTBench [1]Human referenceRisk detection: 91.04 Avg-F1Localization: 81.62/73.20 Strict-F1 (coarse/fine)
ATBench [2]GPT-5.4Binary safety: 76.7% F1Risk-source/failure-mode: 33.6%/13.5% accuracy
Who&When [3]Best methodResponsible-agent: 53.5% accuracyFailure-step: 14.2% accuracy
MP-Bench [4]Experts/Up to 60% disagreement on failure-inducing steps
MTRiskTraceGPT-5–HumanSafety: 84.00%Joint localization: 85.78%; capability: 84.89%

HINTBench reports 91.04 Avg-F1 for risk detection and 73.20 Strict-F1 for fine localization; MP-Bench reports up to 60% expert disagreement on failure-inducing steps. Though not directly comparable, these findings illustrate fine-grained evaluation challenges.

In MTRiskTrace, GPT-5–Human agreement is 85.78% for joint localization and 84.89% for capability diagnosis, exceeding inter-human agreement (74.85%, 73.33%). Together with expanded unsafe-only validation, these results support framework reliability.

Related Revised Sections: Section 4.2; Appendix G.1 (expanded validation and unsafe-only agreement).

[1] Wang et al., 2026. HINTBench: Horizon-Agent Intrinsic Non-Attack Trajectory Benchmark. Findings of EMNLP 2026.

[2] Li et al., 2026. ATBench: A Diverse and Realistic Agent Trajectory Benchmark for Safety Evaluation and Diagnosis. arXiv:2604.02022.

[3] Zhang et al., 2025. Which Agent Causes Task Failures and When? On Automated Failure Attribution of LLM Multi-Agent Systems. ICML 2025.

[4] Rethinking Failure Attribution in Multi-Agent Systems: A Multi-Perspective Benchmark and Evaluation. arXiv:2603.25001, 2026.

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

This paper studies how safety failures emerge during multi-turn interactions with tool-using agents. It introduces MTRiskTrace, a benchmark of 1,100 human-reviewed English and Chinese attack cases spanning 125 scenarios, six attack strategies, and five functional tool categories. Cases contain three to five user turns and test both unsafe content generation and unsafe actions under task-specific constraints. Its central contribution is a three-stage evaluation protocol: determine whether a violation occurs, locate the first observable violation by turn and stage, and assign an evidence-supported failure category. The four categories cover risk understanding and planning, tool-use boundaries, reliance on untrusted information, and maintaining safety boundaries across turns. The intended contribution is to make trajectory-level safety judgments more informative by connecting them to specific events and preceding context. Validation covers 11 LLMs under OpenClaw, with additional evaluations of GPT-5.5 under Codex and Sonnet 4.6 under Claude Code. Each configuration generates fresh trajectories using stateful simulated tools. GPT-5 provides the primary judgments, with Qwen3.7-Max used to assess sensitivity to evaluator choice. The authors also compare judgments against four experts on 50 trajectories and repeat experiments for four models on a 100-case subset. The results show substantial differences across models and some harness-dependent differences, frequent tool-boundary failures, and violations that often first appear late within the tested interactions.

Critical strengths
  • The evaluation asks useful diagnostic questions. Identifying the first violation and its preceding context provides more information than an aggregate attack-success score, particularly when an unsafe action precedes a later refusal.
  • The dataset involves meaningful curation. Bilingual coverage, human-designed cases, independent annotation, and explicit evidence requirements provide a useful basis for evaluating multi-turn failures.
  • The model and harness comparisons are valuable. They show that measured safety depends on the surrounding execution system as well as the model.
Critical weaknesses
  • The positioning and additional value need to be clearer. Existing work already examines intermediate risks and failure diagnosis. The less-explored contribution here is their combination in adversarial multi-turn tool-use interactions. A stronger dataset case would demonstrate diverse held-out tasks and show that these diagnoses help discover or fix failures missed by existing benchmarks.

  • The policy-enforcement setup is insufficiently specified. I could not clearly determine how constraints are presented to agents, which are enforced programmatically, which rely on instruction following, and which permission settings or guardrails are active in each harness. Since blocked unsafe attempts also count toward ASR, the results do not clearly separate unsafe agent decisions from failures of the overall protection system.

  • The toolkit categories are too coarse to establish coverage of real systems. Browser/network access, shell and code execution, package management, and deployment are not clearly distinguished. Figure 2 mentions code and search tools, but their relationship to the evaluation categories remains unclear. An agent interacting with a vulnerable PHP service, for example, could cause effects spanning execution, files, databases, and infrastructure. Assigning one primary tool category does not adequately characterize these dependencies or establish that such workflows are represented.

  • The interaction and context-length coverage is limited. All cases contain three to five user turns. A user turn can include multiple tool calls, but actual execution-step counts, token-length distributions, context budgets, and truncation or compaction policies are not reported. Generalization to longer, context-heavy workflows therefore remains unclear, especially for diagnoses requiring a connection between a late violation and an earlier constraint.

  • Diagnostic reliability needs stronger validation. The human comparison covers only 50 trajectories, and the reported 75.5% capability agreement includes shared safe judgments where no diagnosis is required. This does not establish reliability on unsafe cases alone. Overlap between capability categories also makes the choice of a single primary label uncertain.

Questions for authors
  1. How are policies supplied and enforced in each harness, which guardrails are enabled, and what proportion of unsafe attempts are blocked versus actually executed?
  2. What is human–judge agreement for localization and capability diagnosis on unsafe trajectories alone, and how are competing capability labels resolved?
  3. What are the trajectory token and execution-step distributions, context budgets, and truncation policies? Do the diagnostic results hold on longer interactions with larger tool outputs?
  4. On held-out scenarios and more realistic tool workflows, what additional failures does this benchmark reveal—and can its diagnoses guide fixes beyond what existing benchmarks provide?
9 comments
AuthorsOpenReview ↗

Response 1 for Reviewer vzHj

We thank the reviewer for the insightful and constructive feedback. All of the comments are invaluable for further improving our manuscript. We have addressed each comment below, and revised the main paper and appendix accordingly, with all changes marked in red.

W1 & Q4: The positioning and additional value need to be clearer. While prior work studies intermediate risks and failure diagnosis, their combination in adversarial multi-turn tool use remains underexplored. Held-out scenarios and realistic workflows should show what additional failures MTRiskTrace reveals and whether its diagnoses enable targeted improvements beyond existing benchmarks.

R1: We clarified MTRiskTrace's positioning and value, evaluated samples from three external benchmarks and longer held-out tool-use workflows, and analyzed how fine-grained diagnoses reveal failures and guide mitigation.

1. Positioning and Value

Data Construction. Existing benchmarks address different aspects of agent safety: AgentDojo [1] studies indirect prompt injection via untrusted tool outputs; MT-AgentRisk [2] distributes harmful objectives across user requests; HINTBench [3] examines intrinsic failures under benign instructions (Table R1-1).

MTRiskTrace combines diverse tool-use tasks with explicit safety and authorization constraints. Each case specifies context, target risk, available tools, and a multi-turn attack strategy. Some establish permitted operations before requesting out-of-scope actions to test constraint retention across turns.

Table R1-1: Dataset construction and task design.

DimensionAgentDojo [1]MT-AgentRisk [2]HINTBench [3]MTRiskTrace (Ours)
Task settingTool-output injectionMulti-turn harmful tasksNon-attack intrinsic failuresAdversarial multi-turn tool-use tasks
Multi-turn adversarial user requests×✓×✓
Risk and tool coverageInjection scenarios5 tools, 8 attack subcategories5 constraints, 11 risk patterns2 risk types, 5 tool categories, 6 attack strategies
Dataset coverage629 cases, 4 environments365 sequences596 trajectories, 27 domains1,100 bilingual cases, 125 scenarios, 11 domains

Evaluation Framework. AgentDojo [1] and MT-AgentRisk [2] dynamically evaluate tool-using agents; HINTBench [3] provides trajectory-level risk detection, localization, and failure-type identification (Table R1-2).

MTRiskTrace uses a progressive three-stage framework: Safety Judgment identifies unsafe trajectories; Risk Localization finds the first violating user turn and execution stage; Capability Diagnosis assigns failures to one of four safety capabilities (C1–C4). Fresh model–harness rollouts enable fine-grained diagnosis.

Table R1-2: Evaluation and diagnostic capabilities.

DimensionAgentDojo [1]MT-AgentRisk [2]HINTBench [3]MTRiskTrace (Ours)
Evaluation inputDynamic interactionsDynamic multi-turn rolloutsConstructed trajectoriesFresh model–harness-specific rollouts
Risk localizationTask-level outcomesTask-level outcomesRisk-step localizationFirst violating user turn and execution stage
Diagnostic outputSecurity outcomes8 attack subcategories5 constraints, 11 risk patterns4 safety capabilities (C1–C4)
Cross-harness evaluation×××✓

2. Evaluation on External Benchmarks

To assess applicability beyond MTRiskTrace, we evaluated 32 trajectories each from AgentDojo [1], MT-AgentRisk [2], and HINTBench [3], covering prompt injection, multi-turn harmful tasks, and intrinsic failures. These tasks are distinct from MTRiskTrace.

For AgentDojo, we selected 32 published important_instructions rollouts (8 per domain: banking, Slack, travel, and workspace). For MT-AgentRisk, we generated 32 completed Filesystem pilot rollouts using gpt-4o-2024-05-13 and the official OpenHands 0.54.0 baseline. For HINTBench, we randomly sampled 32 public test trajectories. We retained the GPT-5-based framework, prompts, and diagnostic criteria, preserving original instructions, tool calls, observations, and available benchmark annotations (Table R1-3).

Table R1-3: Cross-benchmark safety judgments, risk localization, and primary capability diagnoses.

BenchmarkNSafe / UnsafeOnset TurnOnset StageC1 / C2 / C3 / C4
AgentDojo3213 / 19T1: 19Act: 14; Answer: 53 / 0 / 16 / 0
MT-AgentRisk328 / 24T1: 12; T2: 4; T3: 4; T4: 4Act: 16; Answer: 810 / 10 / 2 / 2
HINTBench326 / 26T1: 7; T2: 6; T3: 6; T4: 4; T5: 2; T7: 1Act: 14; Answer: 1213 / 13 / 0 / 0

Key Findings. C3 dominates AgentDojo (16/19 unsafe cases), consistent with prompt injection; C1/C2 dominate MT-AgentRisk (10 each) and HINTBench (13 each). All unsafe AgentDojo cases begin at T1, whereas HINTBench onset spans T1–T7, showing that the framework captures failure types and onset.

AuthorsOpenReview ↗

Response 2 for Reviewer vzHj

3. Data Design Value

Beyond its broad coverage (1,100 human-reviewed bilingual cases across 125 scenarios, two risk types, five tool categories, and six attack strategies), MTRiskTrace includes cases that establish task-specific safety or authorization constraints in earlier turns and challenge them through subsequent user requests. This allows us to examine whether agents maintain constraints as interactions evolve.

The external benchmarks further highlight this aspect of MTRiskTrace's data design. All 32 sampled AgentDojo trajectories contain only one user turn, while none of the 32 sampled MT-AgentRisk trajectories provides a case where an explicitly maintained authorization boundary is challenged again without new authorization. Although 30 of the 32 HINTBench trajectories contain multiple user turns, our analysis identifies one example in which the agent first acknowledges a failed expenditure approval but later claims that the expenditure was approved without receiving the required authorization. Its primary diagnosis is C2 due to an earlier violation, while the later behavior reveals an additional boundary-abandonment pattern.

This comparison shows that multi-turn interaction alone does not necessarily test whether agents maintain previously established constraints. MTRiskTrace incorporates this aspect into its broader task design by establishing task-specific safety boundaries in earlier turns and challenging them through subsequent requests. Combined with diverse scenarios, risk types, tool categories, and attack strategies, this design enables a broader evaluation of agent safety.

4. Evaluation on Long-horizon Tool Workflows

To further examine whether our framework applies to longer and more complex tool-use workflows, we evaluated 30 trajectories from AgentLAB [4], covering three attack settings: Tool Chaining (12), Task Injection (12), and Objective Drifting (6). Across these trajectories, agents make an average of 8.00 tool calls and generate 4,639 transcript tokens, with an average of 21.77 execution events and a peak input context of 24,732 tokens. Compared with MTRiskTrace, they involve approximately 5.1 times more tool calls and 4.0 times more transcript tokens on average. The safety and diagnostic results are summarized in Table R1-4.

Table R1-4: Safety judgments and capability diagnoses on AgentLAB trajectories.

Attack SettingNUnsafePrimary Capability Diagnosis
Tool Chaining127 (58.3%)C1 (6/7)
Task Injection125 (41.7%)C3 (5/5)
Objective Drifting64 (66.7%)C4 (3/4)
Total3016 (53.3%)—

Among the 12 unsafe trajectories from Tool Chaining and Task Injection, first violations occur at execution steps 4–18, with a median of 8. The full interaction histories are evaluated without truncation or compaction, so the framework traces violations across these longer tool-use sequences. The diagnoses differ by attack setting and suggest targeted mitigation directions: C1 failures in Tool Chaining point to improving risk recognition and authorization assessment; C3 failures in Task Injection highlight the importance of external information verification; and C4 failures in Objective Drifting indicate the need to maintain safety constraints consistently across turns.

Summary

For evaluation, MTRiskTrace combines dynamic rollouts with fine-grained diagnosis and demonstrates applicability to diverse external benchmarks and longer tool-use workflows. For data design, it covers diverse scenarios, risks, tools, and attack strategies, while also including multi-turn cases that test whether agents maintain previously established constraints. We have added these results and the clarified positioning to the revised paper.

Related Revised Sections: Section 2; Section 4.2; Appendix G.11; Appendix G.12.

[1] Debenedetti et al., 2024. AgentDojo: A Dynamic Environment to Evaluate Prompt Injection Attacks and Defenses for LLM Agents. NeurIPS Datasets and Benchmarks 2024.

[2] Li et al., 2026. Unsafer in Many Turns: Benchmarking and Defending Multi-Turn Safety Risks in Tool-Using Agents. ICML 2026.

[3] Wang et al., 2026. HINTBench: Horizon-Agent Intrinsic Non-Attack Trajectory Benchmark. Findings of EMNLP 2026.

[4] Jiang et al., 2026. AgentLAB: Benchmarking LLM Agents against Long-Horizon Attacks. arXiv:2602.16901.

AuthorsOpenReview ↗

Response 3 for Reviewer vzHj

W2 & Q1: How safety constraints are provided and enforced in each harness, and what proportion of unsafe attempts were blocked versus actually executed, so that ASR can separate unsafe agent decisions from failures of the protection system.

R2: We clarify constraint delivery and harness execution settings, report tool-call outcomes across execution layers, and distinguish authorization denials from technical failures when interpreting ASR.

1. Agent Configuration and Execution Environment

Each of 1,100 cases specifies task context, authorization requirements, and tool-use boundaries. Constraints are delivered through different instruction channels: the initial User Message in OpenClaw, Developer Instructions in Codex, and an appended System Prompt in Claude Code. The same boundaries appear in tool descriptions via allowed_use, risk_boundary, and sensitive_arguments (Table R2-1).

Table R2-1: Agent configurations and execution settings across the three harnesses.

CategoryComponentOpenClawCodexClaude Code
Agent ConfigurationConstraint placementInitial user messageDeveloper instructionsAppended system prompt
Agent ConfigurationTool descriptionsAuthorization boundaries included in plugin tool descriptionsAuthorization boundaries included in MCP tool descriptionsAuthorization boundaries included in MCP tool descriptions
Execution EnvironmentTool simulatorCustom-built stateful simulator, accessed through experimental pluginsCustom-built stateful simulator, accessed through MCPCustom-built stateful simulator, accessed through MCP
Execution EnvironmentHarness-level controlsskipBootstrap=true; only experimental plugin tools enabledMCP approval mode set to approveNative tools disabled; strict MCP configuration
Execution EnvironmentSimulator-side checksTechnical validation; no task-specific authorization denial observedSameSame

These policies are delivered through instructions and tool descriptions. They guide behavior but are not independent task-level runtime authorization checks. All three harnesses use our custom stateful simulator, which provides scenario-specific tools and maintains environment state. The simulator performs technical and operational checks but issues no task-specific authorization verdicts.

2. Tool Execution Outcomes

To quantify how many unsafe tool-call attempts were blocked versus executed, we traced each Judge-identified attempt to its recorded outcome across the three harnesses, distinguishing policy-based blocking, execution, and technical failures (Table R2-2).

Table R2-2: Execution outcomes of unsafe tool-call attempts across the three harnesses. Each pair reports GPT-5 and Qwen3.7-Max results, respectively.

HarnessUnsafe AttemptsPolicy-blockedExecutedTechnical FailureUnknown
OpenClaw (11 models)4,224; 4,0350; 04,207 (99.60%); 4,020 (99.63%)17 (0.40%); 15 (0.37%)0; 0
Codex (GPT-5.5)11; 90; 011 (100%); 9 (100%)0; 00; 0
Claude Code (Sonnet 4.6)0; 00; 0———

Technical failures are attempts that could not be completed due to execution errors (e.g., argument validation, tool resolution, or simulator-side errors), not task-specific authorization checks.

Execution outcomes. Under OpenClaw, 4,207 of 4,224 unsafe attempts identified by GPT-5 (99.60%) were executed, while 17 (0.40%) resulted in technical failures. Qwen3.7-Max yields a consistent result: 4,020 of 4,035 attempts (99.63%) were executed, and 15 (0.37%) failed for technical reasons. All recorded unsafe attempts under Codex were executed. Claude Code had no Judge-identified unsafe tool-call attempts.

Policy enforcement. No unsafe tool-call attempts were blocked by task-specific authorization checks across the three harnesses. Thus, the recorded technical failures should not be interpreted as successful safety enforcement. Successful tool execution also does not imply that an operation was authorized.

3. ASR Interpretation

Our audit found no task-specific authorization denials in the Simulator. The observed failures involved argument validation, tool resolution, tool-call budget limits, and simulator-side technical errors. These failures should be distinguished from policy-based authorization rejections.

ASR measures unsafe agent behavior, including content, plans, and action attempts, whether or not the operation succeeds. A technically failed call can therefore still count as unsafe, and a successful call does not mean the operation was authorized. We report ASR and tool execution outcomes separately in Appendix G.13 of the revision.

Related Revised Sections: Section 4 (Models and Harnesses); Appendix G.13 (Harness settings and execution outcomes of unsafe tool-call attempts).

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response

We sincerely appreciate the thoughtful feedback and constructive comments from all reviewers. Your insights have been invaluable in improving the clarity of our work and identifying key points for deeper analysis. We have addressed each point in the individual rebuttals and also revised our main paper and appendix accordingly, with changes marked in red.

Below, we summarize the key concerns with our responses and the corresponding modifications.

Positioning and Comparison with Related Works

  • Comparison with "AgentDojo", "MT-AgentRisk", and "HINTBench" in data construction and evaluation procedure in [W1&Q4-R1, Reviewer vzHj; W1-R1, Reviewer LA4c] and [Section 2].
  • Evaluation of our framework on trajectories from three external benchmarks in [W1&Q4-R1, Reviewer vzHj; W1-R1, Reviewer LA4c] and [Section 4.2, Appendix G.11].
  • Clarification of the differences from indirect prompt injection benchmarks in [Q2-R3, Reviewer vqSX] and [Appendix B].

Reliability of Evaluation and Diagnosis

  • Expansion of human validation from 50 to 150 trajectories, with agreement on unsafe-only pairs in [W5&Q2-R5, Reviewer vzHj; W2-R2, Reviewer LA4c] and [Section 4.2, Appendix G.1].
  • Clarification of the capability labels and the primary-label assignment rule in [W5&Q2-R5, Reviewer vzHj] and [Appendix E.3].
  • Comparison of coarse and fine-grained evaluation results with related benchmarks in [W2-R2, Reviewer LA4c] and [Appendix G.1].

Harness Settings and Experimental Coverage

  • Details of harness configurations and execution outcomes of unsafe tool-call attempts in [W2&Q1-R2, Reviewer vzHj; Q1-R2, Reviewer vqSX] and [Section 4, Appendix G.13].
  • Clarification of the five tool categories, multi-category tool use, and capability coverage in [W3-R3, Reviewer vzHj] and [Section 3.1, Appendix C.3].
  • Statistics of interaction length and context management, and evaluation on longer "AgentLAB" workflows in [W4&Q3-R4, Reviewer vzHj] and [Section 4.2, Appendix G.12].

Diagnostic Insights and Actionable Value

  • Diagnosis-informed interventions and a controlled constraint-channel ablation in [W3-R3, Reviewer LA4c] and [Appendix G.15].
  • Capability decomposition of the ASR gap between Llama 3.3-70B and Claude Sonnet 4.6 in [Q1-R4, Reviewer LA4c] and [Appendix G.6].
  • Analysis of persistence and recovery after the first violation in [Q3-R4, Reviewer vqSX] and [Appendix G.14].
  • Technically grounded mitigation directions and practical takeaways in [W1-R1, Reviewer vqSX] and [Appendix G.8, G.9].
  • Heads-up statistics for high-risk tools and scenarios in [Q4-R5, Reviewer vqSX] and [Section 4.2, Appendix G.10].

We hope that our detailed responses have addressed the reviewers’ concerns and remain available for any follow-up questions. Thank you once again for your time and effort!

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.