acceptodds
Under review as a conference paper at ICLR 2027

When Agents Call Agents: Denial-of-Service Risks in Multi-Agent Systems

Abstract

One LLM agent can invoke another. It can hand off a sub-task, spawn a worker, or pass a turn in a group chat. Existing DoS-detection tools for LLM agents miss this call, as they all model resource consumption only within a single, isolated agent, leaving potential resource exhaustion undetected when one agent's action triggers, amplifies, or recursively re-invokes work in another. In this paper, we formalize multi-agent resource consumption along six independent dimensions. These are repeat count, concurrency, per-call volume, duration, release policy, and retry pacing. Composing individually bounded agents is not automatically safe. A call graph can stay unbounded even when every agent in it is bounded. This gives fourteen canonical risk patterns. Two of them require at least two independent decision-makers. Neither has a single-agent analog. We corroborate this taxonomy empirically. We built MaDScan a static-analysis-plus-LLM pipeline. It extracts resource-flow and resource-constraint graphs from source code. We applied it to 26 open-source agent systems, spanning single-agent, multi-agent, and hybrid architectures, and audited every candidate with an LLM agent. Only risk points confirmed by an executable proof-of-concept test against the real code are reported. On a benchmark of 314 resource-flow records containing 16 verified risks, MaDScan achieves 100% precision and 100% recall, vastly outperforming state-of-the-art techniques. We confirm 68 DoS risks (of which 7 have been acknowledged by project maintainers), 15 of them require genuine agent-to-agent interaction to trigger.

Primary area:
alignment, fairness, safety, privacy, and societal considerations
Keywords:
Multi-Agent Systems, Denial of Service, Agent Collaboration, Resource Exhaustion

Reviews

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

This paper focuses on the Denial-of-Service (DoS) risks during the runtime of multi-agent systems. For a single agent, if it is locally resource bounded, it can mitigate such security risks. However, their compostion may introduce previously underexplored risks of globally unbounded resource consumption due to the interactions among agents. The paper proposes 6 resource dimensions and 14 canonical DoS risk types, and conducts a detailed analysis of the existing system by implementing the MADScan tool. Ultimately, 68 confirmed DoS risk points with PoC validation were identified across 26 open-source agent systems, of which 15 required agent-to-agent interaction to trigger. MADScan achieved 100% observed precision and 100% observed recall in a benchmark consisting of 16 verified risk points.

Critical strengths

The paper investigates the Denial of Service risks in multi-agent systems and provides a detailed and convincing description of such underexplored security risks. A key insight is that the limitation of bounded local resources does not necessarily mean that global resources are bounded, and this insight has sufficient research motivation. And the types of resources and DoS risks also provide a reasonable framework for evaluating such risks.

In the evaluation, MADScan outperforms the baseline detectors on the benchmark. And identifies risk points that traditional single-agent-oriented tools largely miss. The empirical results can demonstrate that such security risks are not purely theoretical.

Critical weaknesses

The evaluation benchmark is relatively small, with only 16 validated risk points. More importantly, these risk points are obtained by manually analyzing resource-flow edges that were first extracted by MADScan itself. Therefore, risks missed during scan-scope selection or resource-flow extraction are unlikely to enter the benchmark, which limits the strength of the reported 100% precision and recall results.

I think the security impact of the threat model proposed in the paper and the risks revealed in the two cases is relatively limited. The first case appears closer to an engineering or workflow bug, while its adversarial exploitability is not clearly established. In the second case, without indirect prompt word injection, the successful triggering by the user only consumes their own resources and costs, without expanding the security issue. Therefore, the practical security consequences of these findings remain unclear.

Questions for authors

Does the benchmark construction introduce a bias in favor of MADScan, since the resource-flow edges are first extracted by MADScan itself before subsequent evaluation? Risks missed during scan-scope selection or resource-flow extraction may never enter the benchmark.

Can the authors provide a clear attack chain to illustrate how attackers affect benign users and cause actual security impact? In particular, what concrete impact or potential loss can an attacker cause beyond merely triggering the failure behavior?

4 comments
AuthorsOpenReview ↗

Response to Reviewer MJQ2

Thank you for recognizing the motivation and the empirical demonstration that these risks are not purely theoretical.

W1 / Q1 -- Does constructing the benchmark from MADScan's own extracted edges bias it in MADScan's favor? This was a fair concern, and we have removed the circularity. The new ground truth is built independently of MADScan: two experts independently annotated every DoS risk in the full source code of 10 randomly sampled systems (48 person-hours each; a third expert resolved disagreements). Because the annotation covers the entire code base rather than MADScan's resource-flow edges, a risk missed during scope selection or extraction can enter the ground truth. On the resulting 25 risk points, MADScan attains 100% precision and 100% recall. AgentFuzz and AgentDoS reach 28.0% and 60.0% recall.

W2 / Q2 -- A clear attack chain, and concrete impact on benign users beyond self-consumption.

Case I (GraphFlow) is a developer-configuration failure that requires no attacker input; it demonstrates that the D-X mechanism exists in a widely used framework. Case II (AutoGPT) is a per-user cost cap bypassed by a single user’s concurrency, so the loss is borne by the operator rather than by other users.

For the attacker-controlled chain with cross-party impact the reviewer asks for, we add an end-to-end case (Case III, Section 5 and Appendix E). The attacker plants content in material the system retrieves, an indirect prompt injection in a background note. A benign operator then runs a multi-agent debate over that content with a live model (gpt-4.1-mini): the injected instructions make a debate agent emit extra data-request tags, and a downstream search analyst dispatches them concurrently with no cap. The amplified requests are paid from the operator’s search budget, not the attacker’s, so attacker and victim are distinct. Across three trials the injection roughly doubles the requests a debate emits (mean 4.3 to 9.3) and raises peak concurrent searches from 2 to 4.

Dear Reviewer,

As the deadline for the final author response approaches, we would like to kindly ask whether you have any remaining questions or suggestions for further revisions. If you feel that our responses have adequately addressed your concerns, we would greatly appreciate it if you could reconsider your score accordingly.

Thank you again for your time and valuable feedback!

Best regards,

The Authors

I appreciate the authors’ detailed response. Unfortunately, I am going to keep my score as is. Two concerns still prevent me from raising it: 1. The new independent benchmark still contains only 25 risks from 10 systems. 2. The new end-to-end case strengthens the exploitability argument, but the demonstrated security impact remains relatively limited and does not yet show severe service disruption in realistic deployments.

Thank you for the careful reading and for engaging with our response. We understand both remaining concerns.

On the benchmark, we will state clearly in the final version that 25 risk points from 10 systems support estimates on a small sample.

On security impact, the end-to-end case demonstrates exploitability rather than severe service disruption in a production deployment, and we will frame the impact claims accordingly.

Thank you again for your time and constructive feedback.

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

This paper studies denial-of-service (DoS) risks in LLM-based multi-agent systems (MAS), including how resource use can grow across agent interactions. It defines a resource model with six dimensions and a taxonomy of 14 risk types. Two types concern coordination between agents.

The authors use this taxonomy to build MADScan. The scanner combines static code analysis with LLM-assisted extraction of resource flows and limits. It then identifies possible risks and checks them with executable proof-of-concept (PoC) tests.

Across 26 open-source agent systems, MADScan reports 68 PoC-validated findings, including 15 involving inter-agent interactions and 7 acknowledged by maintainers. It achieves 100% observed precision and recall on a manually checked benchmark with 16 positive risk points, exceeding the reported results of AgentFuzz and AgentDoS.

Critical strengths
  • The study examines practical risks across open-source agent systems. The study covers 26 open-source systems and reports 68 PoC-validated findings, with 7 maintainer acknowledgments. Executable tests check whether a limit missing from one code region is enforced elsewhere in the execution path. Appendix D gives examples where external timeouts, limits on parallel calls, and loop guards rule out suspected risks. These cases explain why source review alone can produce false positives.

  • The resource model provides a systematic way to examine resource limits. The six-dimensional model covers repetition, concurrency, volume, duration, release, and retry pacing. MADScan connects these categories to resource flows and limits in the code. This helps developers check whether limits on individual operations also constrain the whole workflow.

Critical weaknesses
  • The reported detection accuracy rests on a narrow benchmark. The benchmark samples 314 of the 1,570 resource-flow edges extracted by MADScan and contains only 16 positive risk points. It cannot reveal flows missed by the initial extraction. Appendix B acknowledges this limitation, so the reported recall applies only to flows that MADScan has already identified. The validation results also need clarification: Table 4 reports three PoC rejections, while Table 7 reports 12 false positives when validation is removed. Different filtering steps or runs might explain this difference, but the paper does not specify them. It also needs to explain how findings were labeled independently and whether the baselines used comparable inference budgets.

  • The case studies do not show attacks that require multiple agents. Of the 68 findings, 53 concern single-agent mechanisms. Seven of the eight cases classified as MAS-exclusive concern shared budgets. The AutoGen PoC uses a preconfigured cycle and agents with fixed outputs. The AutoGPT PoC uses simulated turns and an in-memory Redis substitute to test the original budget functions (Appendices E.1 and E.2). These tests show configuration and concurrency failures, but do not show how an attacker's prompts or messages trigger them through the full systems. The paper also needs to explain which failures require agent collaboration rather than ordinary concurrent requests.

Questions for authors
  • Why does Table 4 report three PoC rejections while Table 7 reports twelve false positives without validation?

  • What independent code audit checks for resource flows missed by MADScan?

  • How were findings independently labeled and inference budgets matched when comparing MADScan with AgentFuzz and AgentDoS?

  • Which of the 15 inter-agent findings require agent collaboration rather than ordinary concurrent requests?

  • Which attacker-controlled inputs trigger the failures in the full AutoGen and AutoGPT systems, and how do they affect resource use or service availability?

6 comments
AuthorsOpenReview ↗

Response to Reviewer xGP7 (Part 1/2): W1, Q1, Q2

Thank you for the detailed reading, including the appendices.

W1 / Q2 -- The benchmark cannot reveal flows missed by extraction; what independent audit checks for them? You are right that the original 16 positives were drawn from edges MADScan first extracted, so the reported recall was conditional on extraction and scope. We address this directly with an independent ground truth: two experts independently annotated the entire source code of 10 randomly sampled systems (48 person-hours each; a third expert resolved disagreements), rather than only sampled edges. The resulting 25 risk points can include flows MADScan did not extract. On this set MADScan still reaches 100% precision and 100% recall, i.e., on these 10 systems the experts found no DoS risk that MADScan missed.

Q1 -- Why 3 PoC rejections in Table 4 but 12 false positives in Table 7? They measure different stages on different benchmarks; the old label was ambiguous. Table 4 (now Table 3) is the full 46-system run: source review retains 110 of 271 candidates, and the PoC stage rejects 12 of those 110. The ablation row removed both source review and PoC on the separate 16-point extraction benchmark, so its 12 false positives are candidates that review and PoC together filter on the 16-point benchmark; this is distinct from the 12 the PoC stage rejects on the full run. In the revision we relabel that row "w/o Review + PoC validation" and show the funnel (271 -> 110 -> 98) explicitly, so the two numbers are no longer confused.

AuthorsOpenReview ↗

Response to Reviewer xGP7 (Part 2/2): Q3, W2, Q4

Q3 -- Independent labeling and comparable inference budgets? (i) Labeling: the ground truth is double-annotated -- two experts label independently and a third resolves disagreements -- so it does not depend on a single author's judgment or on MADScan's output. (ii) Budgets: we add a per-tool cost column to the comparison table (Table 3). Per system, MADScan uses 0.80M tokens (gpt-4.1-mini), AgentFuzz 0.71M (GPT-4o), and AgentDoS 9.48M (GPT-4.1). MADScan's budget is comparable to AgentFuzz's and about 12x smaller than AgentDoS's. We run both baselines under their released configurations and say so.

W2 / Q4 -- Which inter-agent findings require agent collaboration rather than ordinary concurrent requests? All 15 are genuinely multi-agent findings; within the multi-agent setting they split into two mechanisms, and we report both counts. 5 are collaboration-dependent. The risk is realized only through feedback or hand-offs passing between distinct agents: the AutoGen Swarm and CAMEL Workforce hand-off/decomposition loops, GPT-Researcher’s planner->editor fan-out, OWL’s role-playing message growth, and the AutoGen GraphFlow circular wait. 10 are architecture-level. The vulnerable state lives in the multi-agent system’s shared coordination layer, not in any single agent. The 7 N-X findings race on a budget the MAS enforces once for the whole team; a single isolated agent with its own private limit would not expose them. The 3 N-M group-chat loops are driven by a team-level round counter that defaults to unbounded, which the orchestration layer maintains. These are triggered by concurrency, but the shared state they exploit is an artifact of the multi-agent architecture, not of one agent servicing concurrent requests.

AuthorsOpenReview ↗

Response to Reviewer xGP7: Q5

Q5 -- Which attacker-controlled inputs trigger the failures in the full systems, and how do they affect resource use or availability? We answer each case plainly and add a full-system experiment.

AutoGen GraphFlow (Case I, D-X). No attacker input is required: the trigger is the developer-defined graph plus the default activation settings. After the start node runs, two nodes each wait for the other's activation and the scheduler reports completion, so the requested work is silently dropped -- an availability failure (premature termination), not resource exhaustion. We now state explicitly that this case demonstrates that D-X exists in a widely used framework; it is a configuration-induced failure, not an adversarial chain.

AutoGPT (Case II, N-X). The attacker is an authenticated user issuing concurrent turns. Under a $1.00 daily cost cap, ten concurrent turns costing $0.30 each all pass admission and record $3.00, three times the cap. The overspend is billed to the operator, whose cap exists precisely to bound this cost, so the failure is a denial-of-wallet against the operator. The same check-then-record pattern recurs in AutoGPT's per-user execution cap, where ten concurrent runs are admitted under a cap of three (Appendix E).

FinnewsHunter (Case III, end-to-end). To show attacker input propagating through a full system under a live model, we run the real, unmodified FinnewsHunter debate orchestrator with gpt-4.1-mini driving the debate agents. The attacker content is planted in the retrieved background material as an indirect prompt injection. A debate agent reads that material and emits data-request tags, which a separate search analyst then dispatches concurrently with no code-level cap. Across three trials, the injected note roughly doubles the search requests a debate emits, from a mean of 4.3 to 9.3, and raises peak concurrent downstream searches from 2 to 4, breaching the prompt’s soft “one to two searches” guideline in every injected run. The attacker never pays: the operator’s search budget absorbs the amplification, a denial-of-wallet effect.

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

This paper studies denial‑of‑service (DoS) risks induced by cross‑agent invocations in LLM‑based multi‑agent systems (MAS). Existing agent DoS detection tools only analyse resource exhaustion within individual agents and ignore risk propagation across agent call graphs, even when every constituent agent enforces local resource bounds, the composite MAS can still suffer unbounded resource consumption.

The authors first formalise MAS resource consumption across six independent resource dimensions: repeat count, concurrency fan‑out, per‑call data volume, duration, resource‑release policy, and retry pacing. Based on this formal model, they build a comprehensive taxonomy with canonical DoS risk patterns. They implement MADScan, a hybrid detection pipeline combining static source‑code traversal, LLM‑powered semantic extraction for resource flows and constraints, taxonomy‑guided risk analysis, and executable proof‑of‑concept (PoC) validation to filter false positives.

Critical strengths
  • Strength 1: Problem formulation and the 14‑pattern multi‑agent DoS taxonomy The paper identifies a critical under‑studied security gap: local per‑agent resource safeguards do not guarantee global safety for composed multi‑agent systems. The six‑dimensional resource model and resulting 14‑risk taxonomy offer structured conceptual tools to reason about cross‑agent resource‑exhaustion failures, including two novel MAS‑exclusive coordination bugs. This taxonomy contributes conceptual foundations for future MAS security research, and directly guides the downstream detection pipeline.
  • Strength 2: Rigorous PoC‑grounded validation methodology for vulnerability detection Unlike many LLM‑assisted static‑analysis works which stop at static or LLM‑based judgement, MADScan mandates executable PoC testing against unmodified original code before reporting any risk.
Critical weaknesses
  • Weakness 1: Limited size and statistical representativeness of evaluation benchmark The core benchmark only contains 16 manually‑ground‑truth verified risk points, sampled from a 20% subset of extracted resource‑flow edges. This result comes from a very small ground‑truth set and cannot reliably generalise to broader unseen MAS codebases.
  • Weakness 2: Practical coverage limitations of MADScan are substantial and only briefly discussed MADScan depends on manually‑defined scan scopes, regex‑and‑AST candidate spotting, and LLM semantic interpretation. It lacks full inter‑procedural analysis and may fail on unfamiliar agent‑framework idioms. Additionally, LLM interpretation can produce incorrect source locations or misinterpret framework semantics, relying heavily on human source review as a corrective step.
Questions for authors

None

2 comments
AuthorsOpenReview ↗

Response to Reviewer jNjU

We thank you for the positive assessment and for highlighting the taxonomy and the PoC-grounded methodology.

W1 (benchmark size and representativeness). We have substantially strengthened the evaluation. (i) The dataset grows from 26 to 46 systems, yielding 98 PoC-confirmed findings. (ii) We replace the extraction-derived benchmark with an independent, expert-annotated ground truth: two experts annotated the full source of 10 randomly sampled systems (48 person-hours each; a third resolved disagreements), producing 25 verified risk points that are not restricted to what MADScan extracts. MADScan attains 100% precision/recall on it, and we report baseline recall on the same set (AgentFuzz 28.0%, AgentDoS 60.0%).

W2 (coverage limitations under-discussed). We agree. RQ1 now reports the full detection funnel: of 271 candidates, source review retains 110 and PoC validation confirms 98, rejecting 12 whose cited code omits effective bounds elsewhere (Appendix D). Accuracy is measured separately, on the expert-annotated ground truth (25 risk points, 100% precision and recall). The limitations of manual scan scopes, regex-plus-AST matching, and LLM judgments are stated in RQ2 and detailed in Appendix B. MADScan is an extensible framework rather than a fixed analyzer: it supports (i) new agent frameworks at low cost, adding one needs only a scan-scope entry and a short paradigm hint, not pipeline changes; (ii) the regex-plus-AST localizer and the LLM extractor can each be swapped for inter-procedural/taint analysis or a larger model without touching the downstream stages.

Dear Reviewer,

As the deadline for the final author response approaches, we would like to kindly ask whether you have any remaining questions or suggestions for further revisions. If you feel that our responses have adequately addressed your concerns, we would greatly appreciate it if you could reconsider your score accordingly.

Thank you again for your time and valuable feedback!

Best regards,

The Authors

Comments on the paper

1 comment
AuthorsOpenReview ↗

General Response to All Reviewers

We thank all reviewers for the careful reading. Three concerns recur, and we address each with additional experiments and tighter claims in the revision.

(1) The benchmark was small and drawn from edges MADScan itself extracted (R1-W1, R2-W1/Q2, R3-W1/Q1). We agree this was a real limitation. We built a new ground truth that is independent of MADScan: we randomly sampled 10 of the 46 systems, and two experts independently annotated every DoS risk in the full source code of each system (48 person-hours each), with a third expert resolving disagreements. Because the experts read the whole code base rather than MADScan's extracted edges, the ground truth can contain risks MADScan misses. On these 25 expert-verified risk points, MADScan still achieves 100% precision and 100% recall, versus 28.0% (AgentFuzz) and 60.0% (AgentDoS).

(2) Evaluation protocol and budgets (R2-W1, Q1, Q3). We now show the full funnel (271 candidates -> 110 after source review -> 98 after PoC), relabel the ablation row as "w/o Review + PoC validation" so it is no longer confused with PoC-only rejections, and add a per-tool cost column (Table 3): MADScan 0.80M tokens/system, AgentFuzz 0.71M, AgentDoS 9.48M.

(3) Which findings need multiple agents, and what the security impact is (R2-W2/Q4/Q5; R3-W2/Q2). We add a table of representative inter-agent findings, all of which require a multi-agent architecture to trigger, and explain which arise through inter-agent collaboration and which through shared coordination state (Appendix F). We add an end-to-end case in which attacker-controlled content drives a confirmed fan-out finding through the full multi-agent system (Case III in Section 5, details in Appendix E).

Scale. The revision also expands the evaluation from 26 to 46 open-source systems and from 68 to 98 PoC-confirmed findings, more than twice the 20 systems that AgentFuzz and AgentDoS each evaluate in their own papers.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.