Agent-to-Agent (A2A) Security: Discovery Is Not Authorization

Agent-to-Agent (A2A) Security: Discovery Is Not Authorization

Table of Contents

When one of your AI agents asks another agent for help, how does it know that agent is who it claims to be?

In most early deployments, it doesn’t. It found the other agent in a directory, read a description the other agent wrote about itself, and started sending it data.

That’s the trust model we’re sleepwalking into as agents start working with each other. The Agent-to-Agent (A2A) protocol gives agents a standard way to describe themselves, find each other and collaborate. It’s a genuinely useful standard. But it moves a lot of trust decisions into places where nobody is looking.

This is the fourth article in a series on securing agentic AI. The first three covered the MCP protocol, MCP gateways and the internal AI marketplace. MCP connects AI to tools. A2A connects agents to each other, and that needs its own thinking.

What is the A2A protocol? A2A in plain English

The A2A specification describes how independent agents cooperate:

  • Each agent publishes an agent card, a machine-readable profile that says who it is, what it can do (its skills), where to reach it and how callers must authenticate.
  • Other agents discover it, usually by searching a registry.
  • They then send it tasks and messages directly and get results back.

The registry is the phone book. The agent card is the business listing. The conversation happens directly between the two agents.

That last point is the one security teams need to absorb. In the registry my team built for our AI platform, as in most A2A designs, the registry handles registration and discovery, then steps out of the way. Once Agent A has found Agent B, they talk peer to peer. That’s a sound design choice for scale, but it means the registry controls who can find whom, not what happens next.

The problem in plain English

Picture a claims-processing agent that needs a fraud check. It searches the registry, finds a “fraud scoring” agent, reads its card and sends it the claim, including the customer’s personal details.

Now ask:

  1. How does the claims agent know the fraud agent is really run by your fraud team?
  2. What stops the fraud agent from doing more with that data than scoring it?
  3. When the fraud agent receives the request, whose authority is it acting under: the claims agent’s, or the customer service rep who started the process?
  4. If the fraud agent’s reply contains instructions rather than a score, does the claims agent follow them?
  5. Where is the record of that exchange?

If your answers rely on “it was in our registry”, you have a discovery system, not a trust system.

Let me paint a picture

Imagine you need a plumber. You look one up in a trade directory. The listing says “Fully qualified, 20 years’ experience, all work guaranteed.”

The directory didn’t write that. The plumber did.

When someone arrives at your door, a sensible homeowner checks some ID and confirms they’re from the company in the listing. They show them to the bathroom, not the home office. They don’t hand over the house keys and the alarm code because the directory listing looked professional.

And if the plumber says “your neighbor asked me to pick up their spare key while I’m here”, you don’t just hand it over.

Every one of those instincts applies to agents. The directory helps you find someone. It doesn’t tell you whether to trust them, or what they’re allowed to do.

Now what?

Why “it’s in our registry” isn’t enough

There’s a natural assumption that anything in the company’s own registry is trustworthy. It breaks down for two reasons.

Agent cards are self-descriptions. Name, skills, provider and capabilities are all written by whoever registered the agent. Unless something verifies them, a card is a claim, not a credential. An attacker, or just a careless team, can publish a card that sounds exactly like a trusted service.

The registry isn’t in the conversation. Because agents call each other directly, the registry’s access controls stop at discovery. Authentication, authorization and logging for the actual exchange have to be enforced by the agents themselves. If Agent B doesn’t check who’s calling, nobody does.

A2A security principles

If you only take one section of this article back to your team, take this one.

  1. Discovery is not authorization. Being able to find an agent never implies being allowed to use it. Each is a separate, explicit decision.
  2. Every agent has its own identity. Agents authenticate as themselves, with their own short-lived credentials, never with a shared or borrowed account.
  3. Verify the operator, not the description. Trust comes from verified identity and your own review process, not from what an agent says about itself.
  4. Control who can find whom. Discovery results are filtered by the caller’s permissions, and sensitive agents are visible only to the groups that need them.
  5. Every agent checks every caller. The receiving agent authenticates the caller and decides what it may do, on every request.
  6. Authorize the human behind the chain. When agents delegate to agents, decisions are made against the person or system that started the work, not the agent in the middle.
  7. Treat every inbound message as untrusted input. A message from another agent is data, never an instruction to be obeyed.

A secure agent-to-agent architecture

Here’s how the pieces fit, using the registry-based model.

flowchart TB
    A["Agent A
(its own identity)"] -->|"1. Search, with A's token"| R["Agent registry"] R -->|"2. Only agents A may see:
card, endpoint, trust level"| A A -->|"3. Call directly,
with a token for B"| B["Agent B"] B --> CHK{"4. Who is calling,
on whose behalf,
and may they do this?"} CHK -->|"no"| NO["Refuse and log"] CHK -->|"yes"| DO["Do the work,
log it, return a result"] DO -->|"5. Result treated as data,
not instructions"| A

1. Identity: every agent is somebody

Agents register and discover using their own machine identities, issued by your identity provider through the standard OAuth client credentials flow, with short-lived tokens. In our platform these are managed alongside human users, with each machine client mapped to groups just like a person. That gives every agent a name you can grant permissions to, audit and revoke.

The result: “which agent did this?” always has an answer.

2. The registry: who can publish, and who can find whom

The registry should separate the actions that matter: listing agents, viewing an agent’s details, publishing new agents, modifying them and deleting them, each granted per group. Most agents only ever need permission to discover; very few should be able to publish or change entries.

Visibility should be controlled per agent (public, group-restricted or private), and discovery results must be filtered by the caller’s permissions, including semantic “find me an agent that can…” searches. This is easy to overlook. It’s natural to secure the call and forget that the directory itself reveals what exists. A marketing agent searching for “salary data” shouldn’t even learn that the HR agent exists.

New agents should also be checked on registration: their cards validated against the specification, their endpoints analyzed and their content scanned for malicious patterns, with anything that fails held back until reviewed.

The result: the directory only shows each caller the agents it’s allowed to know about.

3. Verification: from claims to credentials

Self-descriptions become trustworthy when something independent backs them up:

  • Trust levels (unverified, community, verified, trusted) should reflect your own review process, and policy can require a minimum level for sensitive work.
  • Verified identity. Newer versions of the A2A specification support digitally signed agent cards, so a card can be checked for tampering and tied to the organization that issued it. PKI-based agent identity services are emerging to prove who operates an agent and that they control its domain.

The result: callers can tell the difference between “this agent says it’s the fraud team” and “we’ve verified this is the fraud team”.

4. The call itself: enforced by the receiving agent

Because the conversation is direct, the receiving agent is the enforcement point. Every agent should:

  • Authenticate the caller using the scheme advertised in its card, typically a bearer token from your identity provider, bound to that agent as the audience.
  • Authorize the initiator, not just the caller. When work passes through several agents, carry verifiable evidence of who started it and decide against their permissions. I covered this pattern in depth in Zero Trust for AI Agents.
  • Share the minimum. Send another agent only the data its task needs, not the whole context window.
  • Log the exchange, with caller, initiator, skill used and outcome, in the same audit pipeline as everything else.

For the highest-risk interactions, it’s worth going further and routing agent-to-agent calls through a gateway, so authentication, policy and logging are enforced centrally rather than relying on every team to get it right.

5. When an assistant calls an agent through a tool

There’s a hybrid pattern worth calling out, because it’s where MCP and A2A meet. In our platform, an AI assistant can find an agent through a discovery tool and then ask a tool to invoke that agent on its behalf. It’s genuinely useful, and it raises three design questions every team should answer deliberately:

  • Where may the tool send requests? Agent URLs come from registry entries, and a URL is exactly the kind of thing an attacker would like to control. Our invocation tool only calls hosts on an explicit allowlist, and an empty allowlist blocks every call. That’s the right default: fail closed.
  • Which token does the agent receive? The easy answer is to forward the caller’s own token. The better answer is a token minted for that specific agent, with only the permissions the task needs, so a compromised agent can’t replay it elsewhere.
  • Does any credential pass through the model? If the assistant has to handle tokens itself, those tokens sit in its context window, where a prompt injection can ask for them. Keep credentials in the client’s plumbing, not in the conversation.

How this fixes the problem

Let’s go back to the plumber.

You found them in a directory that only lists trades you’re allowed to hire. The listing carries a verified badge, because someone checked their credentials. When they arrive, they show ID. They’re allowed into the bathroom and nowhere else. And when they pass on a message from your neighbor, you treat it as information, not an instruction.

For agents, that gives you:

  1. Named, accountable agents, each with its own identity.
  2. Controlled discovery, where agents only find what they’re permitted to use.
  3. Verified trust, based on identity and review rather than self-description.
  4. Enforcement at every call, including authority traced back to the human who started the work.
  5. A complete record of who asked which agent to do what.

An agent directory tells you who exists. It doesn’t tell you who to trust, or what they’re allowed to do.

What this doesn’t do

  • The registry can’t police conversations it isn’t part of. In a peer-to-peer model, each agent’s own enforcement is what protects the exchange. Build a shared library or sidecar so teams don’t each reinvent it.
  • Verification proves identity, not intent. A verified agent operated by a legitimate team can still be buggy, over-permissioned or compromised.
  • Scanning checks the card, not the behavior. An agent can present a clean profile and still behave badly at runtime. Monitoring and least privilege remain essential.
  • Cross-organization A2A is harder. Calling agents run by partners or vendors brings in their identity systems and their security posture. Treat them like any third-party integration, with contracts and due diligence.

How I’d roll it out

  1. Phase 0: Inventory. Find the agents that already call other agents. Many teams have wired this up informally.
  2. Phase 1: Register everything. Bring agents into the registry with named owners and their own machine identities. Retire shared credentials.
  3. Phase 2: Lock down publishing. Restrict who can publish or modify agents, set new agents to private and unverified by default, and turn on registration scanning.
  4. Phase 3: Enforce at the receiver. Require every agent to authenticate callers and log requests, starting with agents that handle sensitive data or take actions.
  5. Phase 4: Carry the initiator. Pass verifiable initiator context through multi-agent chains and authorize against it.
  6. Phase 5: Verify identities. Adopt verified identity or signed agent cards for high-trust agents, and require it for anything crossing an organizational boundary.

The trade-offs to watch

  • Decentralized enforcement. Peer-to-peer scales well but spreads security across every team. Provide a standard component so the secure path is the easy path.
  • Discovery versus secrecy. Semantic search is most useful when it can see everything. Filtering results by permission is the right call, even if it makes discovery feel less magical.
  • Latency in long chains. Every hop adds authentication and authorization. Keep checks local and cached so the cost stays small next to the model calls.
  • Identity sprawl. Hundreds of agents means hundreds of machine identities. Automate their lifecycle, including removing identities for retired agents.

What to ask your team on Monday

  1. Which of our agents call other agents today, and how do they authenticate?
  2. Can any agent discover every other agent, or is discovery filtered by permission?
  3. How would a calling agent tell a verified internal agent from a convincing impostor?
  4. When agents delegate to agents, whose permissions decide what happens at the end of the chain?
  5. Where is the log of what our agents asked each other to do yesterday?

Agents working together is where much of the real value of agentic AI will come from. But collaboration between strangers needs the same scaffolding it needs between people: identity, verification, clear permissions and a record of what happened.

Discovery is not authorization. Design every agent interaction as if the other side still has to prove itself.

Frequently asked questions

What is the A2A protocol?

The Agent-to-Agent (A2A) protocol is an open standard that lets independent AI agents describe themselves, discover each other and exchange tasks and messages. Each agent publishes an agent card describing its skills, endpoint and authentication requirements.

What is an agent card?

An agent card is a machine-readable profile an A2A agent publishes, listing its name, skills, endpoint and how callers must authenticate. It’s written by the agent’s owner, so it’s a claim rather than a credential unless it’s signed or independently verified.

How is A2A different from MCP?

MCP connects an AI application to tools and data. A2A connects AI agents to each other. In practice they’re complementary: an agent may use MCP to call tools and A2A to delegate work to other agents, and both need identity, authorization and audit.


If you’re connecting AI agents to each other and want to pressure-test your architecture, book a strategy session.

Share :

Related Posts

Welcome to AI Security Architects

Welcome to AI Security Architects

AI systems are moving from experiments to production faster than most security architectures can adapt. Models call tools, agents act with real credentials, and sensitive data flows through retrieval pipelines that did not exist a year ago. AI Security Architects is a place to work through what secure design looks like in that world.

Read More
Zero Trust for AI Agents: Authorize the Human, Not the Agent

Zero Trust for AI Agents: Authorize the Human, Not the Agent

A question I keep coming back to when I look at agentic platforms is this: “When an AI agent merges a pull request, who actually approved it?” The answer most teams give is “the agent did”. The honest answer is that nobody really knows.

Read More