- Rating
- 2
- Confidence
- 3
- Informativeness
- 2
- Presentation
- 2
- Soundness
- 2
Read review
Paper summary
This paper introduces MASTRIA, an automated framework for threat modeling and risk analysis within multi-agent systems powered by large language models. The framework constructs a system model by analyzing source code, encompassing agents, tools, data flows, and trust boundaries. It then employs a combination of rule-based analysis and LLM-driven methods to identify and verify potential security threats. Finally, it assesses the likelihood and impact of these threats and provides corresponding mitigation recommendations. The objective is to automate threat modeling while ensuring that the analysis results remain traceable to the system's actual implementation.
Critical strengths
none
Critical weaknesses
-
The paper only compares the identified threats with human annotated ground truth, but does not test them with real attacks. It is unclear whether these threats can actually happen in real-world systems.
-
The paper lacks comparison with existing threat modeling methods or a simple LLM baseline. It is hard to know how much improvement comes from the proposed framework.
-
The paper includes risk assessment and mitigation recommendations, but the experiments mainly focus on threat identification. The accuracy of risk scores and the effectiveness of suggested mitigations are not evaluated.
Questions for authors
-
How do the authors ensure the generated DFDs are correct and complete? Since the following threat analysis are based on these diagrams, any missing or incorrect connections may affect the final results. Have the authors considered evaluating the accuracy of generated DFDs against the actual system architecture?
-
The performance drops a lot when changing the backbone model from GPT-5.5 to Kimi-2.7. Can the authors explain why there is such a large difference? Does this mean the framework is highly depend on the LLM being used?
-
The evaluated applications have relatively small number of agents. How well can MASTRIA work on larger and more complex multi-agent systems? Especially when agents and their interactions can change during runtime, will the framework still be able to identify the threats correctly?
5 comments
Thank you for the comments.
Q1: Ensure the generated DFDs are correct and complete:
The revised manuscript evaluates this directly against the source code of all seven applications (previous six applications plus the new fully evaluated LanGraph application) (presented in the Results Section 4, Table 2). MASTRIA recovered every one of the 139 components with its trust level, at perfect precision. It also recovered every one of the 355 edges with its boundary-crossing annotation, at 0.986 precision. Entry points reached 0.977 precision and 0.920 recall, and exit points 0.892 precision and 0.961 recall(presented in the Results Section 4, Table 1). These results confirm that the code-derived model is a reliable foundation for the threat analysis built on it. Correctness is also enforced by design (i) the Scanner extracts components and connections deterministically from the source code’s ASTs, (ii) elements it cannot resolve are raised as explicit handoff items rather than guessed, (iii) agentic updates are accepted only if the code and model elements they cite actually exist, and (iv) downstream, the Threat validator checks every attack-path step against a real DFD edge, so modeling errors cannot silently produce unsupported threats. The high threat recall (0.969) further suggests that the few remaining entry and exit-point omissions had limited effect on the final results.
Q2: Performance drops when changing from GPT-5.5 to Kimi-2.7:
The gap reflects the capability of the underlying LLM in the agentic stages, not a dependence on a specific model vendor. Kimi-2.7 focuses on agentic coding, whereas GPT-5.5 has strong cybersecurity capabilities. In addition, Kimi-2.7 has a limited context window (256K tokens), which constrains its reasoning over large inputs; as noted in the paper, this limitation prevented us from evaluating the RealEstate application. As a case in point, GLM-5.3, which has strong cybersecurity reasoning and a larger context window, performs similarly to GPT-5.5 on the common subset: 0.916 precision and 0.949 recall, compared with 0.944 and 0.978.
Thank you for the comments.
Q3: larger multi-agent systems:
Our initial selection of six applications was intended to cover diverse MAS domains, topologies (hierarchical, sequential, and LLM-routed loop), capabilities (local and remote MCP servers, RAG, and code execution), and effects ranging from advisory outputs to irreversible external actions. The derived system models of these applications range from 12 to 33 DFD nodes. We also believe that our evaluation which includes applications with 6-7 agents, consistent with representative multi-agent configurations. Pareek et al. (CHI 2026) identify 2-6 agents as typical ensemble sizes, while TAMAS (ACL 2026) demonstrates multi-agent security risks using only four agents. Yang et al. (2026) emphasize that multi-agent security risks arise primarily from interactions and trust boundaries rather than agent count alone. Kim et al. (Nature Machine Intelligence, 2026) show that increasing the number of agents does not necessarily improve performance and may introduce coordination overhead and error amplification. Thus, our evaluation captures representative and security-relevant multi-agent configurations, while spanning diverse architectures, interactions, and threat scenarios. Nevertheless, we acknowledge that scalability to substantially larger systems warrants further investigation. To partially address the reviewer’s comment, we extended the evaluation with 14 additional applications. During the rebuttal period, we fully annotated one of these applications, GitHub MCP application, implemented in LangGraph and computed both its precision and recall; the updated results in the paper include this application. For the remaining 13 new applications (see Table below) given the time constraints of the rebuttal period, we report only precision (94.30%). Measuring their recall requires independent manual threat modeling by the human annotators to construct the ground truth, which we have started and will be completed and included in the final version of the paper.
| App name | Framework | Source | Topology | # Agents | Tools | Precision |
|---|---|---|---|---|---|---|
| Personal Assistant (router) | CrewAI | RIFT-Bench | Router + final-checker loop (10 cycles) | 4 | 2 local MCP servers (11 tools), local writer tool | 97.1% |
| Personal Assistant (orchestrator) | CrewAI | RIFT-Bench | Orchestrator loop (10 cycles) | 4 | 2 local MCP servers (11 tools), local writer tool | 91.4% |
| Finance (orchestrator) | CrewAI | RIFT-Bench | Orchestrator loop (8 cycles) | 5 | 1 remote MCP server (market data), 3 local MCP servers (7 tools) | 97.3% |
| Travel (router) | CrewAI | RIFT-Bench | Router + final loop (10 cycles) | 6 | 4 local MCP servers (16 tools), web search, local writer tool | 81.3% |
| Code-Exec Agent | CrewAI | RIFT-Bench | Single agent, uncapped reasoning loop | 1 | Code interpreter (in-process sandbox), remote GitHub MCP (read-only), web search (local MCP) | 95.8% |
| Surprise Trip | CrewAI | GitHub (crewAI-examples) | Sequential | 3 | Web search, web scraping | 100.0% |
| Marketing Strategy | CrewAI | GitHub (crewAI-examples) | Sequential | 3 | Web search, web scraping | 100.0% |
| Recruitment | CrewAI | GitHub (crewAI-examples) | Sequential | 4 | Web search, web scraping, LinkedIn Selenium tool | 100.0% |
| Job Posting | CrewAI | GitHub (crewAI-examples) | Sequential (5 tasks) | 3 | Web search, RAG website search, file read | 97.0% |
| News Agent | CrewAI | GitHub (abdulwasea89/News-Agent) | Sequential | 4 | Web search, web scraping, file write | 100.0% |
| Lead Generator | CrewAI | GitHub (Folken2/lead-generator-ai) | Sequential | 4 | Web search, web scraping | 100.0% |
| Mutual Funds Analyser | CrewAI | GitHub (Sudhir-Dharan/Mutual-Funds-Analyser) | Sequential | 4 | Web search, web scraping | 100.0% |
| Travel (single agent) | CrewAI | RIFT-Bench | Single agent | 1 | 4 local MCP servers, web search, plan-document writer | 86.7% |
| 13 applications | 94.3% |
Regarding runtime dynamics, MASTRIA models interactions that the code permits rather than a single observed execution. A delegation that an LLM chooses only at runtime is therefore still represented as an edge, given the code allows it. LLM selected handoffs are modeled as inter-agent edges annotated as LLM-driven. Tools that a remote MCP server exposes only at runtime are modeled through an MCP client node and a tool-poisoning boundary crossing. The Finance application demonstrates both cases. Where the structure cannot be determined statically, as with dynamic dispatch or agents constructed in loops, the Scanner explicitly marks the region as incomplete. The Agentic analyzer then recovers the missing elements from the code (Appendix B.2). Components with no evidence in the code at all, such as agents registered purely from external configuration, remain a limitation that we already stated in Section 5.
Thank you for the comments.
W1: Test Real attacks:
To address this concern, we empirically validated a subset of the threats identified by MASTRIA by implementing them as concrete attacks. Specifically, for four of the evaluated applications (Trip Planner, Instagram, Email Assistant, and HalluCheck), we selected twelve high-risk threat records emitted by MASTRIA and built one attack per threat record. Each attack places an attacker payload at the entry point named in the threat record: a scraped web page, a search result, an email, a dataset row, or one of the user’s own answers, depending on the threat. All attacks rely on prompt injection and LLM manipulation techniques. Each attack was executed three times without modification to account for stochastic behavior, for a total of 36 executions. Of these, 31 succeeded, yielding an attack success rate (ASR) of 86.1%. Seven of the twelve attacks succeeded in all three executions, and the remaining five succeeded in two of three.
We note, however, that actual exploitability (i.e., successful execution of a threat) is not the evaluation target of threat modeling, whether traditional or automated as in MASTRIA. We follow NIST SP 800-30 (similar to STRIDE, PASTA,OWASP, ASTRIDE, STRIDE-AI), under which a threat is a potential adverse event against an asset, whereas exploitability is a property of a specific vulnerability in a specific deployment and is typically assessed in a subsequent red-teaming phase.
W2: Comparison with existing threat modeling methods or a simple LLM baseline:
In response to this comment, we added three baselines (updated results are presented Section 4, Table 2 of the revised paper). All baselines use GPT-5.6-sol (high reasoning):
All baselines receive the same inputs as MASTRIA (source code and asset inventory), along with the ASI taxonomy and threat-record schema. Their outputs were labeled by the same human reviewers, following the same guidelines and against the same ground truth, which was fixed before running the baselines. The baselines use a newer model (GPT-5.6-sol) than MASTRIA's backbone (GPT-5.5). The average results across seven applications, including the newly added LangGraph application, are:
The results demonstrate that MASTRIA's primary advantage is threat coverage (recall). Although the baselines achieve relatively high precision (0.812--0.910), they identify only 9--33 threats per application, compared with 36--85 for MASTRIA. The strongest baseline, Iterative LLM, achieves a recall of 0.415, compared with MASTRIA's 0.969, at a comparable total cost ($55.47 vs. $52.81). These findings indicate that neither repeated prompting nor iterative code navigation is sufficient to achieve MASTRIA's threat coverage.
W3: Evaluating risk assessment and mitigation recommendations:
In the revised paper, we provide the evaluation of the risk scoring. Three experts independently rated all 373 correctly identified threats. MASTRIA’s ratings exactly matched the reconciled expert rating for 329 of them (88.2%). Agreement between MASTRIA and the experts (κ = 0.76) is comparable to agreement among the experts themselves (κ = 0.75), and disagreements are mostly over-ratings (7.8%) rather than under-ratings (4.0%) (see the new results in the Result Section 4, Table 3). For mitigations, MASTRIA follows standard threat-modeling practice: each identified threat is linked to established countermeasures according to the threat properties; in MASTRIA we use the OWASP Agentic AI Threats and Mitigations guidance based on the Agentic Security Initiative (ASI) threat categorization. We chose community-vetted guidance over LLM-generated defenses deliberately, so that every recommendation is traceable and auditable. The correctness of this linkage depends on the ASI mapping, which we evaluate: 315 of 373 correctly identified threats (84.5%) received a complete and correct mapping, and the remaining 58 a partial one (see Table 2). To further demonstrate how mitigation can affect MASTRIA results, we hardened two applications with the attached mitigation recommendation MASTRIA attached to a same of threats, and measured the effect by running MASTRIA on the new variants (further details are in Appendix F, Applied mitigations).