← back to blog
AI & LLMs · Topic 34

Attacking Multi-Agent Systems: A Field Map of A2A Trust Boundaries

Attacking multi-agent systems and the A2A protocol: coordination patterns, trust boundaries and the agent card

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.

Single agent versus multi-agent attack surface: adding agents adds the trust between them as a new attack surface over the network
One agent exposes user input and tools. A team of agents also exposes the trust between them.

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 vs multi-agent attack surface
 Single agentMulti-agent
Exposed toUser input, external toolsUser input, external tools, other agents
How parts talkInternal function callsNetwork requests between separate agents
New risksnoneAuth gaps, serialisation flaws, implicit trust
Attacker goalAbuse the one agentBreak one, move laterally to others
One agent exposes user input and tools. A team also exposes the trust between the agents.

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.

Orchestrator (hub and spoke)

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.

Peer to peer (mesh)

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.

Hierarchical (tree)

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.

Pipeline (chain)

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.

Four patterns, four weak spots. In a pipeline, write the payload so it survives being summarised at each hop.

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, what to go after, and its weak spot
FrameworkGo afterWeak spot
LangGraphSaved state, checkpoints, routingCheckpoints in SQLite, Postgres or Redis hold past conversations and state
AutoGenCode-execution agent, group chatCode execution on the host is RCE on the server; any chat member can hijack it
CrewAIRole prompts, memory, delegationRoles live in prompts and can be overridden; bad content persists through memory
OpenAI SwarmHandoffs, context variablesLittle security checking; context variables carry injection between agents
Google A2AAgent discovery, message parsingOne flaw hits every compliant build; discovery allows impersonation
Fingerprint the framework first, then go straight for its known weak spot.

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.

01
You

Control the input to a low-privilege agent.

▸
02
Low-priv agent

Produces output you shaped.

▸
03
High-priv agent

Trusts that output and does the action.

You inherit the agent's access, not your own. That's the whole value of the jump.

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_read the same as code_execution ignores 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.

The attack surface in four stages
StagePointsAttacks
InputPrompts, files, URLs, API responses, inter-agent messages, webhooksDirect and indirect injection, document injection, callback injection
ProcessingPrompt building, tool selection, parameters, state, memory retrievalTemplate injection, tool confusion, parameter injection, state manipulation
OutputResponses, tool calls, state changes, external actions, handoffsSSRF and SQLi through tools, state corruption, handoff hijacking
PersistenceShared memory, chat history, config, logs, cachesMemory persistence, history injection, config backdoors, cache poisoning
Write down every point per agent; that list is your test plan.

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.json first.
  • 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

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.