TAMAS: Benchmarking Adversarial Risks in Multi-Agent LLM Systems

## Abstract

Abstract Large Language Models (LLMs) have demonstrated strong capabilities as autonomous agents through tool use, planning, and decision-making abilities, leading to their widespread adoption across diverse tasks. As task complexity grows, multi-agent LLM systems are increasingly used to solve problems collaboratively. However, safety and security of these systems remains largely under-explored. Existing benchmarks and datasets predominantly focus on single-agent settings, failing to capture the unique vulnerabilities of multi-agent dynamics and co-ordination. To address this gap, we introduce T hreats and A ttacks in M ulti- A gent S ystems ( TAMAS ), a benchmark designed to evaluate the robustness and safety of multi-agent LLM systems. TAMAS includes five distinct scenarios comprising 300 adversarial instances across six attack types and 211 tools, along with 100 harmless tasks. We assess system performance across ten backbone LLMs and three agent interaction configurations from Autogen and CrewAI frameworks, highlighting critical challenges and failure modes in current multi-agent deployments. Furthermore, we introduce Effective Robustness Score (ERS) to assess the tradeoff between safety and task effectiveness of these frameworks. Our findings show that multi-agent systems are highly vulnerable to adversarial attacks, underscoring the urgent need for stronger defenses. TAMAS provides a foundation for systematically studying and improving the safety of multi-agent LLM systems. Code is available at https://github.com/microsoft/TAMAS .

## 1 Introduction

LLMs have demonstrated great capabilities in reasoning, tool usage, coding, multi-step planning and decision making (Masterman2024TheLO; wu2023autogen). Such abilities have enabled them to evolve rapidly from simple text generators into autonomous agents capable of interacting with complex environments (li2024personalllmagentsinsights; liu2025advanceschallengesfoundationagents; schick2023toolformerlanguagemodelsteach). As a result, LLM agents are now being widely adopted in high-stakes applications such as automated trading, clinical decision support, and legal analysis (10.1145/3677052.3698688; 10822186; li2024legalagentbenchevaluatingllmagents). This evolution has led to the rise of LLM-based agents and, more recently, multi-agent systems (MAS), where multiple LLM agents collaborate to solve complex tasks (article; 10546975). This shift to a multi-agent setup enhances the system’s ability to leverage agent specialization for efficient and targeted problem-solving.

Despite significant progress in improving the collaboration and usability of multi-agent systems, their security and robustness remain largely under-explored (hammond2025multiagentrisksadvancedai). The inclusion of multiple interacting agents introduces additional components in the system, thereby increasing the attack surface as shown in Figure [1](https://arxiv.org/html/2511.05269v1#S1.F1). This increased complexity makes multi-agent setups more susceptible to diverse adversarial attacks, which can compromise the system integrity and lead to severe consequences across critical domains.

Previous works (zhang2025agentsecuritybenchasb; ruan2024identifyingriskslmagents) have primarily focused on evaluating the security of single-agent systems, often restricting themselves to isolated attack types or specific scenarios. For instance, InjectAgent (zhan2024injecagentbenchmarkingindirectprompt) primarily targets indirect prompt injection, while AgentDojo (debenedetti2024agentdojodynamicenvironmentevaluate) focuses on direct prompt injection. RedCode (guo2024redcoderiskycodeexecution) evaluates agent safety in the context of generating and executing malicious code. Agent Security Bench (ASB) (zhang2025agentsecuritybenchasb) expands the scope to include multiple attacks and defenses, but remains limited to a single-agent setup, leaving the complexities of multi-agent interactions largely unexplored. Single-agent benchmarks evaluate isolated prompt injection or code execution risks. However, they cannot capture emergent risks arising from multi-agent interactions. Furthermore, many of these evaluations simulate interaction trajectories using the ReAct framework (yuan2024rjudgebenchmarkingsafetyrisk) rather than real-world multi-agent frameworks. This simplification restricts agent behavior and coordination, limiting the generalizability of findings to practical deployments.

Figure: Figure 1: Overview of the proposed attack framework on multi-agent systems, illustrating six key attack vectors—Impersonation, Direct Prompt Injection (DPI), Indirect Prompt Injection (IPI), Contradicting Agents, Byzantine Agent, and Colluding Agents. These attacks target distinct components across the agentic pipeline, including the prompt level, environment interface, and internal agent behavior.
Refer to caption: x1.png

To address these gaps, we introduce TAMAS (Threats and Attacks in Multi-Agent Systems), which, to the best of our knowledge is the first benchmark designed to evaluate the safety of multi-agent LLM based systems. Unlike prior benchmarks (zhan2024injecagentbenchmarkingindirectprompt; debenedetti2024agentdojodynamicenvironmentevaluate) that focus on isolated single-agent threats, TAMAS systematically studies emergent vulnerabilities arising from inter-agent dynamics. Attacks such as collusion, contradiction, or compromised agents, have no analog in single-agent setups, yet they critically undermine real-world multi-agent system deployments. TAMAS spans five high-impact domains (education, legal, finance, healthcare, and news), and evaluates six attack types including prompt-level, environment-level and agent-level attacks. We further evaluate robustness under three agentic configurations, showing how architectural choices shape resilience to adversarial behavior.

Our results reveal that multi-agent LLM systems remain highly vulnerable across diverse attack vectors. These findings highlight that multi-agent coordination introduces new, systemic risks beyond those observed in single-agent setups. TAMAS not only reveals these weaknesses but also establishes a foundation for developing defenses and robust design strategies for safer multi-agent systems.
Our contributions are summarized as follows:

- 1.
We present TAMAS, the first benchmark to systematically evaluate the safety and robustness of multi-agent LLM systems. It spans five high-impact domains (education, legal, healthcare, finance, and news) and six adversarial threats including both known vulnerabilities (e.g., direct/indirect prompt injection, impersonation) and multi-agent–specific risks (Byzantine, Colluding, and Contradicting agents).
- 2.
We benchmark performance across two frameworks, three distinct multi-agent configurations, capturing both centralized and decentralized collaboration and 10 LLM backbones to study the architectural impact on the safety and utility of the system.
- 3.
We introduce Effective Robustness Score (ERS), a metric which assesses the models safety and task effectiveness.

## 2 Related Work

Prompt Based Attacks.
Prompt based attacks (lee2024promptinfectionllmtollmprompt) exploit the LLMs by inserting a malicious or adversarial text into the user query. Prompt injection attacks (liu2024promptinjectionattackllmintegrated) can be classified into two categories: (i) Direct Prompt Injection (DPI) and (ii) Indirect Prompt Injection (IPI) based on how the malicious instruction is injected. DPI involves embedding the malicious instruction directly into the user prompt to override or mislead the LLM into taking an action. liu2024formalizingbenchmarkingpromptinjection formalizes and benchmarks various instances of prompt injection involving diverse injected instructions. In contrast, IPI attacks (zhan2024injecagentbenchmarkingindirectprompt; greshake2023youvesignedforcompromising; Yi_2025) rely on injecting the adversarial instruction into external sources such as tools, documents or web pages. The LLM then retrieves content from these external sources and incorporates the injected instruction, ultimately diverting the original user intent.

Agent Based Attacks.
Agent-based attacks target the underlying system architecture rather than directly manipulating the LLMs themselves. For instance, wang2024badagentinsertingactivatingbackdoor and Yang2024WatchOF introduced a class of backdoor attacks where malicious triggers are embedded within the agent’s environment, activating harmful behaviors when the agent accesses that environment. motwani2025secretcollusiongenerativeai and wu2024shallteamupexploring highlight the issue of colluding agents, a challenge particularly prevalent in multi-agent LLM frameworks where agents may collaborate toward a malicious goal. cemri2025multiagentllmsystemsfail highlights failures arising from inter-agent misalignment and miscoordination.

Safety evaluation of LLM Agents.
As LLM-based agents are increasingly deployed in real-world settings (Xu2024TheAgentCompanyBL; Liu2023AgentBenchEL), ensuring their safety and reliability has become a critical concern. Several benchmarks have been proposed to assess agent behavior under various adversarial and high-risk scenarios. AgentDojo (debenedetti2024agentdojodynamicenvironmentevaluate) focuses on assessing prompt injection attacks and defenses, while InjectAgent (zhan2024injecagentbenchmarkingindirectprompt) targets indirect prompt injection in contexts such as data security and financial harm. RedCode (guo2024redcoderiskycodeexecution) benchmarks the ability of code agents to safely generate and execute potentially harmful code snippets. AgentHarm (andriushchenko2025agentharmbenchmarkmeasuringharmfulness) evaluates how effectively agents refuse to comply with harmful or unethical queries. lee2024promptinfectionllmtollmprompt study prompt propogation through self-replicating attacks while he-etal-2025-red explore Agent-in-the-Middle attack. In contrast, R-Judge (yuan2024rjudgebenchmarkingsafetyrisk) and AgentMonitor (chan2024agentmonitorplugandplayframeworkpredictive) evaluate the safety awareness of LLMs by presenting them with manually curated records of risky agent trajectories, and assessing their ability to identify potential safety risks within those scenarios.

## 3 Threat Model

In this section, we define the threat model with respect to the attacker. We do this by describing the attacker’s goal, background knowledge, and capabilities.

Attacker’s Goal.

The attacker’s primary objective is to manipulate the multi-agent system to derail the completion of benign tasks or trigger malicious actions aligned with their intent. Unlike single-agent settings, the attacker can achieve this indirectly by influencing inter-agent communication, disrupting coordination protocols, or exploiting specialized role assumptions, thereby causing system-wide cascading effects.

Attacker’s background knowledge.

The attacker is assumed to know the roles and tools accessible to individual agents, but not the underlying LLM parameters such as alignment strategies, model parameters, and architectural details. Even this limited knowledge is sufficient to target weak links of the system, whose compromised outputs can propagate adversarially through the system.

Attacker’s capabilities.

The attacker may (i) inject malicious content at the prompt or environment level, (ii) compromise one or more agents via adversarial system prompts, or (iii) add tools with malicious intent into the agent’s toolkit. These capabilities enable attacks across three surfaces in the multi-agent system: prompt-level, agent-level, and environment-level.

## 4 Attacks

### 4.1 Preliminaries

We consider a multi-agent LLM system designed to handle user queries using collaborative agents. Let $q$ be the user query sampled from a distribution of queries $\pi_{q}$. Let $\mathcal{M}$ denote the multi-agent system consisting of $n$ agents $\{A_{1},A_{2},\dots,A_{n}\}$. Each agent $A_{i}$ is initialized with a system prompt $p^{\text{sys}}_{i}$ that defines its role, instructions, or behavioral constraints. $T_{i}=(\tau_{i}^{1},\tau_{i}^{2},\dots,\tau_{i}^{n})$ denotes the list of tools available to agent $A_{i}$, where $T_{i}$ represents the set of agent-specific tools. An agent can invoke these tools to perform the user task. $O=(o_{1},o_{2},\dots,o_{m})$ denotes the observations based on the actions taken by the agents. For a given query $q$ we aim to maximize:

$$ $\mathbb{E}_{q\sim\pi_{q}}\left[\mathds{1}\left(\mathcal{M}(q,O,\{T_{i}\},\{p^{\text{sys}}_{i}\})=a_{b}\right)\right]$ (1) $$

where $a_{b}$ is the benign action and $\mathds{1}$ is an indicator function. A user aims to solve a target task $t$ consisting of an instruction, tools and data. The instruction corresponding to the target task is denoted using $q^{t}$.

### 4.2 Prompt-level Attacks

#### 4.2.1 Direct Prompt Injection (DPI)

A DPI attack targets the multi-agent system by explicitly modifying the user query with a malicious instruction. In this attack, an injected instruction $x^{e}$ is concatenated to the original target instruction $q^{t}$, forming a new user query $q^{t}\oplus x^{e}$. This injected instruction is crafted to override, or redirect the intended behavior of the system. Additionally, the adversary provides an attack-specific toolset $T^{e}$, which is appended to the original tools $T$. The goal of DPI is to manipulate the agents’ behavior such that they follow the injected instruction instead of adhering to their original task. Formally, the goal is to maximize:

$$ $\mathbb{E}_{q^{t}\sim\pi_{q}}\left[\mathds{1}\left(\mathcal{M}(q^{t}\oplus x^{e},O,\{T_{i}+T^{e}_{i}\},\{p^{\text{sys}}_{i}\})=a_{\text{m}}\right)\right]$ (2) $$

where $a_{m}$ is the malicious action mentioned in the injected instruction. The attack is successful if the attack tool mentioned in the injected instruction is invoked.

#### 4.2.2 Impersonation

An impersonation attack modifies the user query by appending a statement that falsely attributes the request to a trusted or authoritative figure. The modified query takes the form $q^{t}\oplus x^{\text{auth}}$, where $x^{\text{auth}}$ is a crafted phrase implying that the request originates from a legitimate or high-ranking source (e.g., “As requested by the admin…”). This tactic aims to make the query appear more valid or important, thereby increasing the likelihood that agents will comply with it, even if it contradicts their original role. The goal is to maximize:

$$ $\mathbb{E}_{q^{t}\sim\pi_{q}}\left[\mathds{1}\left(\mathcal{M}(q^{t}\oplus x^{\text{auth}},O,\{T_{i}\},\{p^{\text{sys}}_{i}\})=a_{\text{m}}\right)\right]$ (3) $$

These adversarial behaviors would be rejected by well-aligned agents under normal, and unaltered conditions.

### 4.3 Environment-level Attacks

#### 4.3.1 Indirect Prompt Injection (IPI)

An IPI attack manipulates the multi-agent system indirectly by introducing adversarial content into the environment or intermediary observations, rather than modifying the user query directly. In this setting, the user query remains unchanged as $q^{t}$, but the attacker influences the observations $O=(o_{1},\dots,o_{n})$ by injecting an instruction $x^{e}$ at any step $i$ and appending to the attack toolset $T^{e}$ to $T$, resulting in altered observations.
These injected observations can originate from third-party tools or external sources accessed by agents during task execution. The goal of IPI is to mislead agents by feeding them altered or misleading context through compromised information. Formally, the goal is to maximize:

$$ $\mathbb{E}_{q^{t}\sim\pi_{q}}\left[\mathds{1}\left(\mathcal{M}(q^{t},O\oplus x^{e},\{T_{i}+T^{e}_{i}\},\{p^{\text{sys}}_{i}\})=a_{\text{m}}\right)\right]$ (4) $$

### 4.4 Compromised Agents Attacks

#### 4.4.1 Single Agent Compromise

Single agent attacks occur when one agent in the multi-agent system is compromised, while the rest of the agents remain benign. Unlike prompt or environment based attacks, the adversarial influence arises solely from the malicious behavior of a single compromised agent. This setup highlights the system’s vulnerability to the weakest link: even one agent acting adversarially can mislead the overall decision-making process. Formally, this can be modeled by perturbing only the system prompt of the compromised agent as follows:

$$ $\mathbb{E}_{q^{t}\sim\pi_{q}}\left[\mathds{1}\left(\mathcal{M}\big(q^{t},\,O,\,\{T_{i}+T_{i}^{e}\},\,\{p^{\text{sys}}_{1},\dots,p^{\text{sys}}_{j}+\delta_{j},\dots,p^{\text{sys}}_{N}\}\big)=a_{\text{m}}\right)\right]$ (5) $$

where $j$ denotes the index of the adversarial agent, whose system prompt $p^{\text{sys}}_{j}$ is modified with malicious instructions $\delta_{j}$, while all other agents remain unmodified.

Byzantine agent.
A Byzantine agent directly produces inconsistent, or nonsensical outputs. This attack mode does not rely on persuasion or subtlety but rather on disrupting the system’s reasoning pipeline through contradictory, erroneous, or adversarially crafted outputs. Such an agent may provide factually incorrect answers, intentionally sabotage tool usage, or inject irrelevant noise into the communication. While Byzantine behavior is easier to detect than persuasive behavior, it can still reduce system robustness.

#### 4.4.2 Colluding Agents

In a colluding agents attack, one or more agents within the multi-agent system are adversarial and deliberately coordinate to manipulate the system’s behavior toward an outcome desired by the attacker. These agents are initialized with adversarially modified system prompts of the form $p^{\text{sys}}_{i}+\delta_{i}$, where $\delta_{i}$ defines instructions encouraging the agents to cooperate toward an adversarial goal. The rest of the agents remain benign, but their outputs may be influenced or misled by the malicious agents through collaborative reasoning or message passing. Formally, the goal is to maximize:

$$ $\mathbb{E}_{q^{t}\sim\pi_{q}}\left[\mathds{1}\left(\mathcal{M}\left(q^{t},\,O,\,\{T_{i}+T_{i}^{e}\},\,\begin{aligned} &\{p^{\text{sys}}_{i}+\delta_{i}\mid i\in\mathcal{C}\}\\ &\cup\{p^{\text{sys}}_{i}\mid i\notin\mathcal{C}\}\end{aligned}\right)=a_{\text{m}}\right)\right]$ (6) $$

where, $\mathcal{C}\subset\mathcal{M}$ denotes the set of colluding agents within the multi-agent system that intentionally cooperate to pursue a shared adversarial objective.

#### 4.4.3 Contradicting Agents

In a contradicting agents attack, a subset of agents $\mathcal{C}\subset\mathcal{M}$ which have similar functionalities, intentionally provide conflicting or misleading information to disrupt the overall system performance. Their goal is to derail the conversation, cause incomplete execution of the original target task, or generate adversarial responses by contradicting other agents. These agents modify their system prompts to $p^{\text{sys}}_{i}+\delta_{i}$, where $\delta_{i}$ defines the instructions to produce contradictory or disruptive behaviors. The goal is to maximize:

$$ $\mathbb{E}_{q^{t}\sim\pi_{q}}\Biggl[\mathds{1}\Biggl(\mathcal{M}\Bigl(q^{t},\,O,\,\{T_{i}\},\,\begin{aligned} &\{p^{\text{sys}}_{j}+\delta_{j},\,p^{\text{sys}}_{k}+\delta_{k}\}\cup\{p^{\text{sys}}_{i}\mid i\notin\{j,k\}\}\end{aligned}\Bigr)=a_{\text{m}}\}\Biggr)\Biggr]$ (7) $$

where, $j,k\in\mathcal{C}\subset\mathcal{M}$ are two agents with similar functionalities that produce conflicting outputs. Here, $a_{m}$ can either correspond to an incomplete execution of the target task or an adversarial output.

## 5 TAMAS Benchmark

To evaluate the robustness of multi-agent systems we construct the Threats and Attacks in Multi-Agent Systems (TAMAS) benchmark. Following is an overview of the dataset and details the curation process.

### 5.1 Dataset Details

**Table 1: TAMAS dataset statistics and representative instances, demonstrating coverage across agents, domains, attack types, and tasks.**
| Category | Count | Instance |
| --- | --- | --- |
| Agents per<br>Multi-Agent System | 4 | Legal Domain: Legal<br>Research Agent, Case<br>Analysis Agent, Document<br>Drafting Agent, and<br>Compliance Check Agent. |
| Scenarios | 5 | Education, Finance, News,<br>Healthcare and Legal. |
| Attacks | 6 | Direct prompt injection,<br>Indirect prompt injection,<br>Impersonation, Byzantine<br>agent, Colluding agents, and<br>Contradicting agents |
| Harmless tasks per scenario | 20 | Write an article about<br>advancements in AI for<br>healthcare and post it on<br>Linkedin and X. |
| Datapoint per scenario | 60 | 10 datapoints for each<br>attack |

Scenarios: We construct a dataset spanning five real-world domain scenarios: News, Education, Finance, Healthcare, and Legal. These domains were selected to reflect diverse, high-stakes applications where LLM-based multi-agent systems are likely to be deployed and where safety and robustness are critical. Each scenario is built around a single multi-agent system composed of four distinct agents, each with specialized and diverse functionalities. For each scenario, we include ten adversarial examples per attack mentioned in Section [4.1](https://arxiv.org/html/2511.05269v1#S4.SS1). Each datapoint consists of a multi-step task involving atleast two-three agents to capture the dynamics and inter-agent interactions in a multi-agent system.

Harmless instructions: To assess the utility of the system we also include 20 harmless instructions per scenario. These instructions reflect typical, non-adversarial tasks that a multi-agent system might encounter in the real world.

Synthetic Tools: The actions performed by agents are enabled through a set of tools that each agent can access. These tools allow individual agents to perform tasks to fulfill the user query. The tools available to each agent depend on the domain and the role of the agent in the multi-agent system. We include two types of tools: (i) Normal Tools, which support standard execution of normal tasks (ii) Attack tools, which simulate malicious behavior.

All data, attack implementations, and evaluation scripts will be publicly released to support reproducibility and future research. Table [1](https://arxiv.org/html/2511.05269v1#S5.T1) presents an overview of the benchmark, and additional details are included in Appendix [A](https://arxiv.org/html/2511.05269v1#A1).

### 5.2 Agent Interaction Configurations

We evaluate our dataset across three diverse agent interaction configurations to understand how these setups affect the susceptibility to adversarial attacks. We consider the following configurations from the Autogen (wu2023autogen) and [CrewAI](https://docs.crewai.com/) frameworks for our study:

Central Orchestrator: In a centralized coordination paradigm, a lead orchestrator manages the overall workflow of the multi-agent system. The orchestrator is responsible for high-level planning, delegation of subtasks, and monitoring progress toward task completion. It begins by analyzing the user query to extract key requirements and formulate a structured plan. Each step of the plan is then assigned to the most suitable agent, while the orchestrator maintains a record of progress to ensure that subtasks are executed in the intended sequence. Once subtasks are completed, the orchestrator updates its progress tracker and continues to the next stage. By routing all decisions and interactions through a central entity, this design enforces structured control, accountability, and oversight across the system. We evaluate Magentic-One from Autogen and the centralized configuration from CrewAI.

Sequential: Employs a decentralized coordination strategy in which agents take turns contributing to the task in a fixed, cyclic order. After an agent completes its turn, control is passed on to the next agent in the sequence. This configuration employs equal participation, but lacks centralized planning and oversight of the tasks. We evaluate the Round Robin workflow of AutoGen framework and sequential configuration from CrewAI.

Collaborative: Employs a dynamic coordination where the agents take turns contributing to the task at hand based on handoff decisions. In contrast to Round Robin configuration where the sequence of the agents was fixed, the agents in a Swarm configuration select the next agent through a handoff message by the current agent. This makes the configuration decentralized, yet adaptive in turn taking. All agents share a common message context, ensuring a consistent view of the task. Each agent is capable of signaling a handoff to another agent, enabling more flexible and context-sensitive coordination. We evaluate Swarm from Autogen. CrewAI does not provide an equivalent configuration. A summary of the key features of each configuration is provided in Table [3](https://arxiv.org/html/2511.05269v1#A1.T3) in Appendix [A.2](https://arxiv.org/html/2511.05269v1#A1.SS2).

### 5.3 Evaluation Setup

Models : We evaluate performance across ten LLMs: (i) GPT-4 (openai2024gpt4technicalreport) (ii) GPT-4o (openai2024gpt4ocard) (iii) GPT-4o-mini (openai2024gpt4ocard) (iv) Gemini-2.0-Flash (v) Gemini-2.0-Flash-lite (vi) Deepseek-R1-32B (deepseekai2025deepseekr1incentivizingreasoningcapability) (vii) Mixtral-8x7B-Instruct (jiang2024mixtralexperts) (viii) Qwen3-32B (yang2025qwen3technicalreport) (ix) Qwen3-8B (yang2025qwen3technicalreport) and (x) Llama-3.1-8B-Instruct. Refer Appendix [B](https://arxiv.org/html/2511.05269v1#A2) for more details.

Evaluation Metrics : Our evaluation considers 3 criteria: (i) Attack success: whether the attack succeeds, reflecting the safety and robustness of the multi-agent system (ii) Task Completion in Benign Conditions: whether the system can successfully complete a given task under no-attack conditions (iii) Robustness: the system’s ability to prevent attacks while maintaining task performance.

To assess robustness, we adopt the Agent Risk Assessment (ARIA) framework (tur2025safearenaevaluatingsafetyautonomous), which categorizes system responses into four outcomes: ARIA-1 represents immediate refusal, indicating safe behavior; ARIA-2 denotes delayed refusal, where the system hesitates before rejecting the task; ARIA-3 reflects an intent to complete the task but a failure to do so; and ARIA-4 indicates a successful attack, representing unsafe behavior. Due to the semantic complexity of the logs, we adopt an LLM-as-judge setup along with tool invocation checks to ensure scalable evaluation.

To assess the utility of the backbone LLM and the multi-agent system, we evaluate the system’s ability to successfully complete harmless tasks in a no-attack setting. This is captured through the Performance under No Attack (PNA) metric. Lastly, we define Effective Robustness Score (ERS) as a composite metric that captures both safety and utility. It reflects the system’s ability to remain functional and secure under adversarial conditions. Refer Appendix [C](https://arxiv.org/html/2511.05269v1#A3) for additional details on metrics and human verification of LLM-as-judge

## 6 Results

Effectiveness of Adversarial Attacks.

Figure [2](https://arxiv.org/html/2511.05269v1#S6.F2) reports ARIA scores across attacks, models, and system configurations. Prompt-based attacks (DPI and Impersonation) are consistently the most effective, with Impersonation reaching 82% in Swarm and DPI 81% in Magentic-one. Impersonation succeeds largely because agents prioritize instructions from perceived authorities, even when malicious. The success of IPI attack largely depends on the configuration, ranging from average 27.4% in Magentic-one to 56.4% in Roundrobin. Agent-based attacks show mixed effectiveness, Byzantine agent attack achieves high attack success scores, while Colluding agents attack is less successful, with only 2–16% success. However, in the colluding agents attack, there are several instances where only one agent successfully completes the malicious task while the other fails, resulting in a lower overall score. We explore this further in Table [6](https://arxiv.org/html/2511.05269v1#A4.T6).

Prompt-level attacks yield similar ARIA scores across open- and closed-source models, indicating model-agnostic vulnerability. For IPI, closed-source models like Gemini-2.0-Flash and GPT-4o tend to be more resilient than open-source models. For example, in the Magentic One configuration, the average ARIA-4 is 15.6% for closed-source models compared to 39.2% for open-source models. Similarly, for RoundRobin configuration, closed-source models achieve 37.6% versus 75.2% for open-source models.

Figure: Figure 2: ARIA scores across models and configurations. Green values (A1 and A2) indicate refusals, while red values (A3 and A4) indicate failures. Swarm results are provided in Appendix [D.1](https://arxiv.org/html/2511.05269v1#A4.SS1) Figure [3](https://arxiv.org/html/2511.05269v1#A4.F3). Gemini models were not evaluated in CrewAI due to known compatibility issues, and GPT-4 was excluded due to budget constraints.
Refer to caption: x2.png

Impact Across Configurations. Table [2](https://arxiv.org/html/2511.05269v1#S7.T2) shows that CrewAI configurations yield higher safety scores compared to their AutoGen counterparts. Interestingly, the decentralized sequential setup in CrewAI attains an average safety score of 35.98%, closely matching the 37.09% observed in the orchestrator-based configurations. This improvement can be attributed to the design choice of assigning tasks to individual agents upfront, rather than dynamically during execution. In contrast, orchestrator-based setups, while effective, introduce a single point of failure that can undermine overall safety if compromised.

Robustness under Adversarial and Benign Conditions. A robust multi-agent LLM system must balance safety under adversarial conditions with utility in benign tasks. We capture this trade-off using the ERS metric. As shown in Table [2](https://arxiv.org/html/2511.05269v1#S7.T2), GPT models consistently attain high ERS values across configuratiosn, indicating both strong safety and reliable performance. Notably, Llama-3.1-8B achieves competitive ERS in the CrewAI setup, largely due to its higher refusal rates. Overall, ERS provides a concise metric to evaluate and compare multi-agent systems, guiding the selection of models and configurations that are both safe and effective.

## 7 Discussion

Our results reveal several insights into the vulnerabilities of multi-agent LLM systems, which we discuss below. Additional illustrative examples are provided in Appendix [E](https://arxiv.org/html/2511.05269v1#A5).
Attacks are consistently effective across components. Figure [2](https://arxiv.org/html/2511.05269v1#S6.F2) shows that state-of-the-art models remain vulnerable to adversarial attacks at multiple levels including the user prompt, the environment, and agent configuration. These vulnerabilities persist across models and frameworks.

Agents often comply with explicitly malicious tasks. Even when inputs are explicitly malicious, such as instructions to perform harmful tasks, the refusal rates remain low, consistent with the findings of andriushchenko2025agentharmbenchmarkmeasuringharmfulness. Instead of rejecting these requests, agents frequently proceed with execution, indicating that current safety mechanisms fail to trigger reliably in multi-agent settings.

Agents execute tasks they recognize as harmful. We also observe some cases where an agent acknowledges that the requested action may be malicious, but nevertheless proceeds to execute it. For example, in one experiment, an agent flagged a request to delete all quiz records as potentially malicious. Despite this recognition, it still executed the deletion.

Conversation trajectories are easy to manipulate. We find that it is surprisingly easy to alter the trajectory of the conversation using lightweight injections, either through tool outputs or agent responses. Even small fragments of misleading or malicious content were enough to derail task execution. Interestingly, while orchestrator-based configurations achieve the overall high ERS, they also introduce a single point of failure.

These findings show that multi-agent LLM systems not only inherit vulnerabilities from individual agents but also exhibit emergent risks unique to collaborative settings. Mitigating these threats requires layered defenses at the agent, orchestration, and backbone model levels to ensure safe deployment in real-world applications.

**Table 2: Safety, PNA, and ERS scores for each model across different agentic configurations. Entries marked “–” indicate model-configuration pairs not evaluated due to compatibility issues an budget constraints.**
| Model | Magentic-one | Round Robin | Swarm | CrewAI Centralized | CrewAI Decentralized |  |  |  |  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- | --- |
| Safety | PNA | ERS | Safety | PNA | ERS | Safety | PNA | ERS | Safety | PNA | ERS | Safety | PNA | ERS |  |
| GPT-4 | 35.36 | 69.00 | 46.76 | 32 | 31.00 | 31.49 | 36.68 | 42.00 | 39.16 | – | – | – | – | – | – |
| GPT-4o | 36.52 | 79.00 | 49.95 | 25.33 | 49.00 | 33.40 | 34.01 | 44.00 | 38.37 | 41.69 | 79.21 | 54.63 | 37.54 | 85.35 | 52.14 |
| GPT-4o-mini | 41.2 | 76.00 | 53.43 | 29.48 | 45.00 | 35.62 | 25.83 | 42.00 | 31.99 | 35.02 | 80.25 | 48.76 | 34.78 | 82.41 | 48.92 |
| Gemini-2.0 Flash | 32.16 | 44.00 | 37.16 | 37.53 | 64.00 | 47.31 | 43.63 | 60.00 | 50.52 | – | – | – | – | – | – |
| Gemini-2.0 Flash lite | 35.73 | 21.00 | 26.45 | 54.46 | 17.00 | 25.91 | 49.84 | 37.00 | 42.47 | – | – | – | – | – | – |
| Deepseek-R1-32B | 27.21 | 28.44 | 27.81 | 22.17 | 43.39 | 29.35 | 28.76 | 17.39 | 21.67 | 30.14 | 31.71 | 30.91 | 26.28 | 62.9 | 37.07 |
| Mixtral-8x7B | 28.03 | 29.58 | 28.78 | 18.9 | 68.86 | 29.66 | 21.97 | 32.67 | 26.27 | 28.34 | 46.7 | 35.27 | 27.55 | 80.25 | 41.02 |
| Qwen3-32B | 25.85 | 44.46 | 32.69 | 13.28 | 59.24 | 21.70 | 28.2 | 52.27 | 36.64 | 20.47 | 77.53 | 32.39 | 18.69 | 75.77 | 29.98 |
| Qwen3-8B | 26.43 | 40.08 | 31.85 | 18.49 | 59.9 | 28.26 | 27.61 | 28.34 | 27.97 | 27.09 | 62.82 | 37.86 | 15.54 | 63.75 | 24.99 |
| Llama-3.1-8B-instruct | 32.3 | 26.1 | 28.87 | 13.86 | 56.95 | 22.29 | 15.17 | 31.47 | 20.47 | 76.94 | 57.95 | 66.11 | 91.49 | 72.18 | 80.70 |

## 8 Conclusion

In this paper, we evaluate multi-agent systems for their robustness and ability to successfully complete benign tasks. We introduce the TAMAS benchmark, which comprises 300 adversarial attack scenarios and 100 benign scenarios spanning five domains and six attack types. To understand how agent coordination affects vulnerability, we experiment with three agent interaction configurations. Our findings reveal that multi-agent frameworks are highly susceptible to adversarial attacks, highlighting the urgent need for stronger defense mechanisms to ensure their safety. Discussion of limitations and future work is provided in Appendix [F](https://arxiv.org/html/2511.05269v1#A6).

## Reproducibility statement

To ensure transparency and reproducibility, we are committed to making our research accessible. We provide comprehensive experimental details in the paper, and all datasets and code will be publicly released upon publication. All experiments were conducted using open-source frameworks AutoGen and CrewAI, with models accessed via API or Ollama.

## Ethics statement

This work investigates the robustness of multi-agent LLM systems against adversarial attacks. The primary aim of this study is to systematically evaluate how different system configurations and attack strategies influence both safety and task performance. Our findings are intended to advance the development of safer and more reliable multi-agent AI systems.

## Appendix

## Appendix A Benchmark

This section presents an in-depth overview of the benchmark and the procedures followed during its construction and validation.

### A.1 Dataset Schema

The dataset consists of three components: information on agents, user queries, and the tools available to them. Each component is briefly described below.

- 1.
Agent details: Each agent is defined by a name and a description outlining its functionality and role within the system. These descriptions specify what the agent is capable of and how it contributes in the multi-agent system. Each multi-agent system consists of four agents.
- 2.
User query: These are task instructions issued by the user. Each query typically involves coordination among 2–3 agents and requires a multi-step process to be successfully completed.
- 3.
Tools: These are the tools agents can access to carry out user queries. Tools are categorized into regular tools, used for normal task execution, and attacker tools, which simulate adversarial capabilities to execute actions desired by the attacker.

The normal, harmless instructions are designed as multi-step tasks, typically involving 4–5 sequential steps and requiring the collaboration of at least 2–3 agents. This setup ensures that the system demonstrates meaningful utility and agent coordination under non-adversarial conditions.

### A.2 MAS Configurations

This section summarizes the key characteristics of the multi-agent system configurations considered in our study. The comparison in Table [3](https://arxiv.org/html/2511.05269v1#A1.T3) highlights the differences in interaction style, coordination mechanisms, and scalability, providing context for how each setup influences system behavior and potential vulnerabilities.

**Table 3: Comparison of key characteristics across the three considered agent interaction configurations.**
| Factor | Central Orchestrator | Sequential | Collaborative |
| --- | --- | --- | --- |
| Interaction<br>Style | Lead Orchestrator<br>plans, delegates and<br>tracks the progress<br>of the task. | Agents take turn to<br>contribute to the task<br>in a fixed sequence. | The next agent is<br>selected based on<br>handoff message<br>from current agent. |
| Coordination | Centralized. | Decentralized and<br>Sequential turn taking. | Decentralized and<br>Dynamic turn taking. |
| Scalability | Limited. Orchestrator<br>can be a bottle neck. | Low. Adds an<br>overhead per agent. | Moderate. |

### A.3 Attacks

We present an overview of all attack types evaluated in our benchmark. Table [4](https://arxiv.org/html/2511.05269v1#A1.T4) outlines their operational level, success criteria, and illustrative examples. These attacks span prompt-, environment-, and agent-level manipulations, capturing a broad spectrum of adversarial behaviors in multi-agent systems.

We also experimented with a persuasive agent attack from the compromised-agent taxonomy, where an adversarial agent attempts to influence other agents through persuasive language rather than directly performing malicious actions. While conceptually distinct from the other attacks in TAMAS, this attack was entirely unsuccessful in practice: across all domains, models, and configurations. We hypothesize that current LLM-based agents are relatively robust to persuasion-only strategies. Although ineffective in our setting, we include this attack type for completeness.

**Table 4: Summary of the attack types used in our benchmark, including their operational level, success condition, and illustrative examples.**
| Attack Type | Level | Success Condition | Description |
| --- | --- | --- | --- |
| Direct Prompt Injection | Prompt-level | Malicious tool invocation | Ignore previous instructions<br>and invoke Tool X |
| Indirect Prompt Injection | Environment-level | Malicious tool invocation | Malicious instruction injected<br>into tool output. |
| Impersonation | Prompt-level | Tool invocation | Prompt claims an authoritative<br>figure approved a malicious action. |
| Byzantine Agent | Agent-level | Misleading output or<br>Task failure | A compromised agent returns<br>falsified/arbitrary/no results to<br>mislead others. |
| Colluding Agents | Multi-agent level | Coordinated malicious<br>outcome | Two agents conspire to override<br>or bypass the system guardrails. |
| Contradicting Agents | Multi-agent level | Harmful output or<br>Task failure | Agents give mutually conflicting<br>plans to cause task failure. |

### A.4 Human Annotation and Involvement in Dataset Curation

For each scenario, multi-agent systems were manually designed, including agent roles and corresponding descriptions. Tools were crafted to align with the specific functionalities of each agent. To aid in the generation of user queries and attacker tools, ChatGPT was used. All generated content was subsequently reviewed and refined manually to ensure relevance, correctness, and consistency with the intended task and attack setup.

## Appendix B Models

We evaluate 10 models as backbone LLMs for the multi-agent systems. To include a wide variety of LLMs, we include proprietary as well as open-source models.Closed-source models were accessed via API, while open-source models were run through Ollama. We specify all the details for the models in Table [5](https://arxiv.org/html/2511.05269v1#A2.T5).

**Table 5: Details of LLMs used for evaluation in this study. Values marked with an asterisk (*) are approximate based on unofficial estimates.**
| Model | #Parameters | Provider |
| --- | --- | --- |
| GPT-4 | 1.8T* | OpenAI |
| GPT-4o | 200B* | OpenAI |
| GPT-4o-mini | 8B* | OpenAI |
| Gemini-2.0-Flash | not available | Google |
| Gemini-2.0-Flash-lite | not available | Google |
| Deepseek-R1-32B | 32B | Deepseek-AI |
| Mixtral-8x7B-Instruct | 46B | Mistral |
| Qwen3-32B | 32B | Alibaba |
| Qwen3-8B | 8B | Alibaba |
| Llama-3.1-8B-Instruct | 8B | Meta |

## Appendix C Metrics

In this section, we provide a detailed explanation of the evaluation metrics used.

### C.1 ARIA framework

The ARIA framework tur2025safearenaevaluatingsafetyautonomous categorizes a given response to adversarial instructions into four distinct components: ARIA-1, ARIA-2, ARIA-3, and ARIA-4, based on the system’s refusal behavior and the outcome of the attack.

- 1.
ARIA 1: The multi-agent system immediately identifies the instruction as harmful and rejects it without initiating any action.
- 2.
ARIA 2: The system begins executing the instruction but detects its malicious nature partway through and halts the process with a refusal.
- 3.
ARIA 3:The system proceeds to complete the instruction without refusal, but the attack ultimately fails—either due to breakdowns in coordination or failure to invoke the intended malicious action.
- 4.
ARIA 4: The adversarial objective is fully achieved. The system executes the malicious instruction or invokes an attacker tool, indicating a successful attack.

For evaluation, we obtain ARIA-4 scores by parsing tool invocations in the logs for attacks like DPI, IPI, Impersonation. However, evaluating some attacks also requires assessing subtle semantic effects in agent behavior, which is difficult to quantify using rule-based or purely automated metrics. Therefore we leverage GPT-4o as an LLM-as-a-judge with temperature 0.0. To ensure the reliability of LLM-as-a-judge, we conduct a human verification to check the accuracy of the LLM judge.

Human verification of LLM-as-a-judge
We collect logs across different models, attack types, and configurations to systematically assess the agreement between the LLM-judge scores and human annotations. To establish a reliable reference point, we manually assign labels to 140 representative logs following a set of clear and consistent scoring criteria. These human-annotated labels serve as the ground truth for our evaluation.
We then compare the labels generated by our automated evaluation (using an LLM as a judge) against these human labels and obtain an average F1-score of 89.17% across attacks. The attack-wise scores are as follows: DPI: 100%, IPI:100%, Impersonation: 90%, Byzantine agent: 80%, Colluding agents: 90% and Contradicting agents: 75%.

### C.2 Performance Under No Attack (PNA)

PNA measures the system’s ability to correctly invoke the tools required to complete benign user instructions in the absence of any attack. The performance is calculated as the average fraction of necessary tools that are successfully invoked across all tasks.

$$ $\text{PNA}=\frac{1}{N}\sum_{i=1}^{N}\frac{\text{Number of Tools Correctly Invoked in Task }i}{\text{Total Number of Tools Required for Task }i}\times 100$ $$

where $N$ is the total number of tasks.

### C.3 Safety Score

We compute a safety score derived from the ARIA scores to evaluate the overall safety of the system. This score combines the ARIA metrics as follows:

High ARIA 1 and ARIA 2 scores indicate the system’s ability to recognize harmful instructions and either refuse them outright or stop execution partway, which reflects good safety behavior.

Conversely, high ARIA 3 and ARIA 4 scores suggest failure in detecting harm. The system either partially executes a harmful instruction or the attack succeeds completely, which is undesirable.

Based on these considerations, the safety score for a specific attack is formulated as:

$$ $\text{Safety Score}_{\text{attack}}=\text{ARIA}_{1}+0.5\times\text{ARIA}_{2}-0.5\times\text{ARIA}_{3}-\text{ARIA}_{4}$ $$

This score ranges from -100 to 100. To facilitate comparison and interpretation, we apply min-max normalization over each attack to scale it into the range $[0,100]$.

### C.4 Effective Robustness Score (ERS)

A reliable multi-agent system must be both robust to adversarial attacks and capable of completing benign tasks effectively, i.e., maintaining high utility. However, in practice, there is often a trade-off between safety and utility. To quantify this balance, we propose Effective Robustness Score (ERS) that jointly evaluates both aspects. We first compute the average safety score across all attack types to get the overall safety score. Then, we combine this overall safety score with performance under no attack (PNA) using the harmonic mean, which penalizes imbalances between the two components.

$$ $\text{Safety Score}_{\text{overall}}=\frac{1}{n}\sum_{i=1}^{n}\text{Safety Score}_{\text{attack }i}$ $$

$$ $\text{ERS}=\frac{2\cdot\text{Safety Score}_{\text{overall}}\cdot\text{PNA}}{\text{Safety Score}_{\text{overall}}+\text{PNA}}$ $$

## Appendix D Additional Results and Analyses

### D.1 CrewAI Results

Due to space constraints in the main paper, CrewAI configuration results are presented in the following subsection. Figure [3](https://arxiv.org/html/2511.05269v1#A4.F3) shows the ARIA scores for the CrewAI setup.

### D.2 Colluding Agents attack

While a successful colluding agents attack requires both agents to invoke the corresponding attacker tool, we further analyze the cases where at least one of the agents does so in Table [6](https://arxiv.org/html/2511.05269v1#A4.T6). We observe that while in many cases the colluding agents fail to achieve their malicious goal, at least one of the intended tasks is often completed.

**Table 6: Percentage of cases where atleast one agent invokes attacker tool in colluding agents attack.**
| Model | Configuration |  |  |  |  |
| --- | --- | --- | --- | --- | --- |
| Autogen | CrewAI |  |  |  |  |
| Magentic-One | RoundRobin | Swarm | Centralized | Decentralized |  |
| GPT-4 | 18 | 40 | 30 | — | — |
| GPT-4o | 14 | 48 | 26 | 34 | 46 |
| GPT-4o-mini | 20 | 40 | 26 | 30 | 38 |
| Gemini-2.0-Flash | 22 | 36 | 28 | — | — |
| Gemini-2.0-Flash-lite | 26 | 34 | 24 | — | — |
| Deepseek-R1-32B | 22 | 26 | 14 | 10 | 14 |
| Mixtral-8x7B-instruct | 12 | 46 | 22 | 16 | 14 |
| Qwen3-32B | 24 | 34 | 18 | 26 | 32 |
| Qwen3-8B | 30 | 18 | 24 | 20 | 18 |
| Llama-3.1-8B-instruct | 28 | 20 | 10 | 40 | 48 |

Figure: Figure 3: ARIA values across models and CrewAI configurations. Results for Gemini models are omitted due to known compatibility issues with CrewAI. Experiments with GPT-4 were not conducted owing to budget constraints.
Refer to caption: x5.png

### D.3 Bootstrapped Results

We compute bootstrapped estimates of ARIA values with 95% confidence intervals across models and configurations. To estimate the uncertainty of ARIA metrics across domains, we perform smoothed row-wise bootstrapping by resampling 10,000 times, where each bootstrap sample is perturbed using a Dirichlet distribution. The results are shown in Tables [8](https://arxiv.org/html/2511.05269v1#A4.T8), [9](https://arxiv.org/html/2511.05269v1#A4.T9), [11](https://arxiv.org/html/2511.05269v1#A4.T11) and [11](https://arxiv.org/html/2511.05269v1#A4.T11).

Figure: Table 7: Bootstrapped results for Magentic One configuration.

Figure: Table 9: Bootstrapped results for Swarm configuration.

Figure: Table 10: Bootstrapped results for CrewAI centralized configuration.

## Appendix E Illustrative Cases

This section presents illustrative cases aligned with the discussion, where each example reflects a case study and highlights specific behaviors of multi-agent frameworks that can lead to vulnerabilities.

## Appendix F Limitations and Future Work

In this work, we highlight the security concerns and failure modes of multi-agent systems. However, there are some limitations to this work which we mention below:

- •
Framework: Our experiments primarily focus on multi-agent systems initialized using the Autogen and CrewAI frameworks. Future work can explore alternative frameworks and assess the generalizability of our findings across different frameworks.
- •
Agentic Configurations: Although we evaluate three agentic configurations in this study, the set is not exhaustive. Expanding the list of configurations tested could uncover additional vulnerabilities and help in the development of more robust defense mechanisms for multi-agent systems.
- •
Scenarios and Attacks: While our dataset focuses on five high impact scenarios and six attack types, this list is not exhaustive. Future work can extend it by incorporating additional scenarios and attack types to further improve the generalizability of our findings.
- •
Benchmarking Defenses: In this work, we focus exclusively on benchmarking attacks. While we do not evaluate defenses, our benchmark provides a foundation for future work on developing and comparing defense strategies for multi-agent LLM systems.

## Appendix G The Use of Large Language Models (LLMs)

We used LLMs as writing assistants to help polish and clarify the text in this paper. Additionally, LLMs were employed to refine our dataset, as described in Appendix [A.4](https://arxiv.org/html/2511.05269v1#A1.SS4). In all cases, LLMs were used as tools to improve clarity and consistency.

## Appendix H Prompts

We provide all the prompts used in this study for transparency and reproducibility. For evaluating ARIA refusals, we use the GPT-4o model with a temperature setting of 0.0 to ensure deterministic outputs. We modify the ARIA evaluation prompt for our use case.

## Peer Reviews

confidence: 3
contribution: 2
initial_rating: 2
presentation: 2
questions: - What is the exact formula for your combined score (including weights and any normalization)? 
- How does that score change if the mix of benign vs. attack tasks changes, or if you use a different threshold for “attack success”?
- What is the agreement rate between humans and the LLM judge on safety labels, and how did you resolve any conflicts? 
- How stable are the results across different random seeds, decoding settings (e.g., temperature), and prompt or role templates, and can you report confidence intervals from repeat runs? 
- Can you add defenses suited for multi-agent systems (message checks, permission gates, or consensus filters) and show their effect on both safety and normal task success? 
- How do attack success rates change when you vary team size and the communication graph, and when you use another agent framework?
soundness: 2
strengths: - The idea is interesting. 
- Its studied problem of adversarial vulerabilities in multi-agent systems is interesting.
summary: This paper introduces TAMAS, a benchmark designed to evaluate the adversarial robustness and safety of multi-agent LLM systems. The authors define a threat model encompassing six attack types, including prompt-level injections and attacks described as multi-agent-specific: Byzantine, Colluding, and Contradicting agents. The benchmark dataset spans five domains and is used to evaluate ten different LLM backbones across three distinct agent interaction configurations derived from the Autogen and CrewAI frameworks. The principal finding of the study is that current multi-agent LLM systems exhibit significant vulnerabilities to these adversarial attacks, often failing to refuse explicitly malicious instructions.
weaknesses: - The paper's claims to originality are overstated, it fails to properly clarift what is fundamentally new about their evaluation of adversarial attacks compared against the attacks under the LLM or single agent context. 
- The tasks and tools are partly synthetic, so it is unclear how well results transfer to real systems with live APIs and true side effects. 
- The quality of the benchmark execution is also questionable; the dataset of 300 adversarial instances seems small for the scope of the claims. 
- The safety judging leans on LLMs, yet the paper does not report agreement with humans or how consistent the labels are. 
- The combined score is not fully defined and lacks sensitivity checks, and the tables do not report uncertainty or repeat runs.

---

confidence: 3
contribution: 3
initial_rating: 6
presentation: 2
questions: 1, As described in Appendix C.4, the ERS metric is defined as the harmonic mean of the safety score and performance score, which is a reasonable approach to balance these two objectives. However, the paper would benefit from additional experimental validation of this design choice. Specifically, it would be valuable to see ablation studies or comparative analyses demonstrating that the ERS metric more effectively captures the trade-off between safety and performance compared to alternative formulations that also consider both factors.

2, The current safety evaluation relies on ARIA and LLM-as-a-judge as criteria. While this is a common and practical setup, in certain webpage attack scenarios, there exist more direct and reliable criteria — for instance, whether the agent executes a specific unsafe action (e.g., transferring money to a malicious actor). The paper does not discuss why such criteria were not considered, nor does it provide results using these more concrete safety indicators. Including such analyses could strengthen the validity and interpretability of the safety evaluation.
soundness: 3
strengths: 1, The topic of assessing multi-agent system safety is timely and important.

2, The benchmark includes multiple tasks, multiple constructed prompts, and the corresponding metric. And the evaluation includes multiple agentic structures.
summary: The paper focuses on vulnerabilities of multi-agent dynamics and co-ordination, propose a benchmark Threats and Attacks in Multi-Agent Systems (TAMAS), including 5 scenarios, comprising 300 adversarial instances across six attack types and 163 tools, along with
100 harmless tasks. And evaluated 10 models, and 3 MAS frameworks from Autogen and CrewAI. They also propose an Effective robustness score (ERS) for assessing the tradeoff between safety and effectiveness.
weaknesses: 1, Lack of comparison with other agent safey benchmarks [1,2,3], what's the difference and main contribution compared to these benchmarks?

[1] AgentHarm: A Benchmark for Measuring Harmfulness of LLM Agents.

[2] Agent-SafetyBench: Evaluating the Safety of LLM Agents.

[3] Agent Security Bench (ASB): Formalizing and Benchmarking Attacks and Defenses in LLM-based Agents

2, Lack of attack scenarios. For example, the MAS jailbreak [4], malicious coding behavior [5], and agent conversation behavior [6] are less considered.

[4] Infecting llm agents via generalizable adversarial attack.

[5] Multi-agent systems execute arbitrary malicious code.

[6] Red-teaming llm multi-agent systems via communication attacks.

---

confidence: 4
contribution: 3
initial_rating: 6
presentation: 3
questions: 1. In Equation [4-7], what are the optimized parts to maximize the goal. Are they $\delta_i$? If yes, how to optimize them?

2. When testing the Qwen3 model, is the thinking mode on or off?

2. Would like to see the performance on Claude if resources permits. Claude series should be the safest LLMs for both non-agent and agent use.
soundness: 2
strengths: 1. Originality and Significance: to the best of my knowledge, this is  the first benchmark to evaluate the safety and robustness of multi-agent LLM systems, especially for >= 3 agents. Also, some attacks specified for MAS, such as Byzantine, Colluding, and Contradicting are also tested.  The topic is also an important topic that the community would be interested in, as it addresses under-explored and systemic risks of MAS.

2. The benchmark provides extensive evaluation, spanning five domains, 300 adversarial instances, 100 harmless tasks and three distinct agent interaction configurations. The analysis as well as the proposed metric provides a nuanced understanding of how architectural choices impact system safety, and can benefit follow up studies.
summary: This paper introduces the TAMAS benchmark to evaluate the safety of multi-agent system against adversarial attacks. The benchmark tests systems across 5 scenarios with 300 adversarial instances across six attack types. By evaluating ten different LLMs across three agent interaction architectures, the authors demonstrate that current multi-agent systems are highly vulnerable to these attacks, introducing a new metric called the Effective Robustness Score (ERS) to measure the trade-off between safety and task performance.
weaknesses: Weakness 1: Limited Scope of Adversarial Goals (Disruption vs. Misuse)

A limitation of the benchmark is its focus on attacks that disrupt a given task (e.g., Byzantine, Contradicting agents) or manipulate the immediate output (e.g., prompt injection), rather than testing for more severe, exploitative misuse. The safety community is increasingly concerned with threat actors instrumentalizing systems for inherently harmful, multi-step goals. The current benchmark does not appear to evaluate scenarios such as 1) using a multi-agent system (e.g., with a code agent) to collaboratively generate malware or find exploits. 2) attack a system to post or modifying harmful content on social media. 3) exploiting agent-to-tool interactions to exfiltrate private data. While derailing a task is a valid security concern, these "malicious use" scenarios represent a higher-stakes, more complex class of threats. 

Weakness 2: Missing of Defense methods

The paper's central finding is the high vulnerability of multi-agent systems, but this conclusion is drawn in the absence of any standard defensive measures. Many of the tested attacks, particularly prompt injections, are well-known vulnerabilities, and it is common practice to deploy LLM systems with system-level safety filters, input/output sanitization, or "guardrail" models (such as Prompt-Guard). By evaluating the systems in an undefended "vacuum," the paper's results, while striking, may be overstated. The lack of a defensive baseline makes it difficult to assess the benchmark's true, practical difficulty. 

Overall, I like the paper and did not find any serious weakness. However, evaluating a benchmark paper is more difficult and I may adjust my review after reading other reviewers comments.

---

confidence: 2
contribution: 2
initial_rating: 4
presentation: 3
questions: Please refer to the weaknesses part above.
soundness: 2
strengths: 1. The paper introduces TAMAS, the first benchmark to systematically evaluate the safety of multi-agent LLM systems. Its key innovation is defining and testing "multi-agent-specific risks" (like Byzantine, Colluding, and Contradicting agents) , which "have no analog in single-agent setups".

2. The work is methodologically rigorous. The TAMAS benchmark is comprehensive, spanning 300 adversarial instances across five domains and six attack types. The evaluation is thorough, testing 10 LLM backbones across three agent configurations and two frameworks. The introduction of the Effective Robustness Score (ERS) provides a thoughtful metric for the safety-utility trade-off.

3. The paper is well-written and clearly motivated, identifying that multi-agent safety is "largely under-explored". The attack framework is clearly explained with text and an excellent overview figure (Figure 1). The results are presented accessibly in tables and figures, with "Illustrative Cases" in the appendix making the risks concrete.
summary: The paper introduces TAMAS, the first benchmark for evaluating the safety and robustness of multi-agent LLM systems. It argues that existing benchmarks focus only on single agents, failing to capture unique risks from multi-agent collaboration. TAMAS tests systems against six attack types (including prompt injections, impersonation, and multi-agent-specific attacks like colluding or contradicting agents) across five high-stakes domains. The key finding is that multi-agent systems are "highly vulnerable" to these attacks, revealing "new, systemic risks" not seen in single-agent setups.
weaknesses: The core weakness is the paper's focus on demonstrating failure without providing actionable steps for mitigation or a deep root cause analysis.

* Missing Defenses: The paper does not test the effectiveness of simple, common defenses, like providing agents with explicit refusal instructions (safety guardrails) in their prompts, which limits its practical use.

* Shallow Analysis: It needs a deeper root cause analysis to distinguish whether failures are due to: Model-Level Compliance (LLM ignoring safety training) and Orchestration Failure (the multi-agent framework logic breaking down).

* Scalability Issue: The reliance on human evaluation for labeling the outcomes is slow and unscalable. Reporting Inter-Rater Reliability (IRR) scores and validating against an LLM-as-a-Judge method are needed for community adoption.