
A multi-agent system is several specialised agents working one task, each with its own role, tools and access, instead of 1 model doing everything. There are 4 common ways they're wired together, and each one has a weak spot. This is the map: the 4 patterns, the 5 frameworks, where trust breaks, and the 1 recon step that starts it all.
By the end you'll be able to name a deployment's coordination pattern and where it breaks, fingerprint the framework, one of 5 common ones (LangGraph, AutoGen, CrewAI, Swarm or Google A2A), and its attack angle, pull an A2A agent's card to enumerate it, and map the whole attack surface across its 4 stages: input, processing, output and persistence. If you're starting to test agentic systems, keep this one open while you draw the diagram.
Why multi-agent changes the game
In a single agent, the parts talk by internal function calls. In a multi-agent system they talk over the network, so a call that used to be safe is now a request that can be weak, unauthenticated or blindly trusted. The trust between agents is the new attack vector, and your goal shifts from abusing 1 agent to breaking 1 and moving laterally to the rest.
| Single agent | Multi-agent | |
|---|---|---|
| Exposed to | User input, external tools | User input, external tools, other agents |
| How parts talk | Internal function calls | Network requests between separate agents |
| New risks | none | Auth gaps, serialisation flaws, implicit trust |
| Attacker goal | Abuse the one agent | Break one, move laterally to others |
Four coordination patterns and where each breaks
These 4 topologies come from distributed systems, and A2A agents get deployed in them. Real systems mix them, so map the actual flow rather than assuming. MITRE ATLAS tracks poisoning a sub-agent's output to steer the orchestrator as `AML.T0080`. A quick trick: ask the agent you're talking to who it hands work to or gets work from, and it often tells you the layout.
One central agent hands tasks to sub-agents. Own the orchestrator, own the system. Target it, or poison a sub-agent's output to steer its decisions.
Agents talk straight to each other, no boss. One bad agent influences all its peers. Target the discovery or registration process to add a rogue agent.
Layers, higher agents supervise lower ones. Vertical privilege escalation through crafted lower-agent output. Target how a lower agent proves who's sending commands, then fake a supervisor.
Each agent's output feeds the next. Capability jumping: inject at a low-privilege stage and it runs at a high-privilege stage later. Target the first stage and whatever the last stage can do.
Fingerprint the framework, then hit its weak spot
Knowing the framework points you at bugs specific to it. Look for hints in error messages, response headers, OpenAPI specs and Python tracebacks, which often name the library outright. LangGraph, for one, stores its checkpoints in SQLite, Postgres or Redis, so if you reach the database you read past conversations and state.
| Framework | Go after | Weak spot |
|---|---|---|
| LangGraph | Saved state, checkpoints, routing | Checkpoints in SQLite, Postgres or Redis hold past conversations and state |
| AutoGen | Code-execution agent, group chat | Code execution on the host is RCE on the server; any chat member can hijack it |
| CrewAI | Role prompts, memory, delegation | Roles live in prompts and can be overridden; bad content persists through memory |
| OpenAI Swarm | Handoffs, context variables | Little security checking; context variables carry injection between agents |
| Google A2A | Agent discovery, message parsing | One flaw hits every compliant build; discovery allows impersonation |
On an A2A target, the Agent Card is your first move. Each agent publishes one describing its name, skills and endpoint, usually at /.well-known/agent.json, with newer builds using agent-card.json. That's the discovery mechanism, and the same thing that makes impersonation possible:
curl -s http://TARGET/.well-known/agent.json | python3 -m json.tool
2 quick wins while you're here. OpenAI labels Swarm experimental and for learning, so finding it in production is a finding by itself. And for AutoGen, ask whether code execution runs in Docker or straight on the host; on the host means RCE on the server. All of this maps to OWASP `LLM01:2025` and the OWASP Multi-Agentic System guide v1.0.
The confused deputy: where trust breaks down
A trust boundary is anywhere data or control crosses between parts with different privilege. The classic bug there is the confused deputy: a trusted agent is tricked into using its own authority for you. You influence a low-privilege agent's output, and a high-privilege agent trusts it blindly and acts. You never hold those privileges yourself, you borrow them.
Control the input to a low-privilege agent.
Produces output you shaped.
Trusts that output and does the action.
Trust breaks in 3 places. Watch for each:
- Inter-agent trust. An agent assumes upstream already cleaned the data, acts on a peer's recommendation without checking, or treats another agent's output as instructions rather than untrusted text. This is prompt injection with an agent as the delivery channel.
- Tool trust. Tool output trusted completely gives injection through what a tool returns. Parameters built from attacker-influenced context give parameter injection. And treating
file_readthe same ascode_executionignores that the risk is miles apart. - System trust. The agent runs with more OS or service access than the user it serves. Elevated API keys, a wide service account, a database user with extra rights: whatever the agent holds, you inherit when you steer it.
Map the attack surface in 4 stages
Write down every entry, processing and exit point, because that list is your test plan. Persistence is the 4th stage people miss, and it's how you keep access or shape future interactions through memory poisoning.
| Stage | Points | Attacks |
|---|---|---|
| Input | Prompts, files, URLs, API responses, inter-agent messages, webhooks | Direct and indirect injection, document injection, callback injection |
| Processing | Prompt building, tool selection, parameters, state, memory retrieval | Template injection, tool confusion, parameter injection, state manipulation |
| Output | Responses, tool calls, state changes, external actions, handoffs | SSRF and SQLi through tools, state corruption, handoff hijacking |
| Persistence | Shared memory, chat history, config, logs, caches | Memory persistence, history injection, config backdoors, cache poisoning |
Common mistakes mapping multi-agent systems
- Assuming the diagram. Systems mix patterns, like an orchestrator that kicks off a pipeline. Map the real flow before you pick a target.
- Skipping the boring tools. A tool that takes a URL is an SSRF candidate; a tool that builds a query is an SQLi candidate. Test them like normal web bugs, just through the agent.
- Forgetting logs and caches count. If one agent writes your input to a log that another agent reads later, that's another injection path, and it's easy to miss.
- No table. Without a per-agent list of tools, creds, inputs, outputs and who it talks to, you lose the chain. That table is also what makes the report land with the client.
Quick recap
- In a multi-agent system the trust between agents is the new attack surface: a safe internal call becomes a network request that can be weak or unauthenticated.
- 4 patterns, 4 weak spots: orchestrator (own the hub), mesh (abuse discovery), tree (fake a supervisor), pipeline (capability jumping from a low to a high stage).
- Fingerprint the framework from errors, headers and tracebacks; on A2A, pull the Agent Card at
/.well-known/agent.jsonfirst. - The confused deputy is the core move: steer a low-privilege agent so a high-privilege one acts with authority you never held.
- Map the 4 stages (input, processing, output, persistence) per agent, and note what each can reach versus who can influence its input.
Next step
This is the map. The next step is driving it: pulling an Agent Card and spoofing a rogue agent into the mesh, hijacking a handoff between 2 agents, and chaining a confused-deputy jump up to the orchestrator. That's the hands-on A2A work, and it's the lab I'm building toward next in this track. I keep the per-engagement checklist for all of it in my AI pentest notes.
If you're testing an agentic system in your own lab, or designing one and want it mapped honestly, I'd be glad to compare notes on LinkedIn, especially on where the trust between agents is weakest.
References
- OWASP Multi-Agentic System Threat Modeling Guide v1.0
- MITRE ATLAS, AML.T0080 AI Agent Context Poisoning
- OWASP Top 10 for LLM Applications, LLM01:2025 Prompt Injection
FAQ
What makes a multi-agent system different to attack?
The trust between agents. In a single agent, parts talk by internal function calls. In a multi-agent system, agents talk over the network, so a call that used to be safe is now a request that can be weak, unauthenticated or blindly trusted. You break one agent, then move laterally to the others.
What is an A2A Agent Card and why check it first?
An A2A agent publishes an Agent Card at /.well-known/agent.json (newer builds may use agent-card.json) that lists its name, skills and endpoint. It's the discovery mechanism, so it's your first recon step and the thing that makes impersonation possible on a target you're authorised to test.
What is the confused deputy in multi-agent systems?
A trusted agent is tricked into using its own authority for you. You influence a low-privilege agent's output, a high-privilege agent trusts that output blindly and acts on it, so you borrow the second agent's permissions without ever holding them yourself.
Which agent should I target first?
The one with the most access, reached through the weakest agent that feeds it. Map who can influence each agent's input and what each agent can reach. The gap between those two is where a confused-deputy jump pays off, usually ending at the orchestrator or a high-privilege executor.
Related reading
- AI Agent Attack Surface (the single-agent loop these are built from)
- Agent Memory Attacks (the persistence stage, in depth)
- Indirect Prompt Injection: Two Harmless Files (injection across a trust boundary)
- Browse the whole AI & LLMs track