SYNTROX.ai
Blog

A2A Protocol Security: How AI Agents Authenticate and Authorise Each Other

6 min read

A2A leaves trust to standard web security: the Agent Card declares how to authenticate, credentials are obtained out of band, and the receiving agent must authenticate and authorise every request against its own policy. Before trusting another organisation's agent, verify its signed card with a key you obtained yourself, scope credentials per skill, treat card text and replies as untrusted input, and log both sides.

On this page

When one agent hands work to another inside the same team, a mistake costs a bad output. When an agent hands work to an agent run by a different organisation, it is sending data, and sometimes authority, across a boundary neither side fully controls.

That is the case the Agent2Agent (A2A) protocol was built for. A2A was originally developed by Google and donated to the Linux Foundation, and the latest released version of its specification is 1.0.0. What follows is what that specification says about trust between agents, and what it deliberately leaves to you.

How A2A authentication works

A2A does not invent its own security model. The specification treats agents as standard enterprise applications and says identity is handled at the protocol layer, not within A2A's own semantics. The project's enterprise guidance puts it more bluntly: A2A payloads don't carry user or client identity directly.

Authentication runs in three steps:

  1. Discovery. The client reads the securitySchemes in the remote agent's Agent Card. The options follow OpenAPI: API key, HTTP authentication such as Bearer, OAuth 2.0, OpenID Connect and mutual TLS. Two OAuth flows, implicit and password, are marked deprecated.
  2. Out-of-band acquisition. The client obtains credentials through a process outside A2A, such as an OAuth flow.
  3. Transmission. The credentials travel in headers or metadata on every request, over HTTPS or TLS, which production deployments must use.

On the receiving side, the server must authenticate every incoming request. It then authorises the request "based on the authenticated identity and its own policies", which may take into account the skill requested, the actions attempted within tasks, data access policies and OAuth scopes. Section 13.1 adds that authorisation checks must run on every operation, and that listing or fetching tasks must return only what the caller is entitled to see.

That is the design choice to understand. A2A standardises how agents find each other and exchange tasks. Authorisation logic is, in the specification's words, implementation-specific. Whatever stops a partner's agent from invoking a skill it shouldn't is code you write.

What an Agent Card is, and what a signature proves

An Agent Card is a JSON document that describes an agent: name, description, provider, endpoints, capabilities, skills, and the security schemes it accepts. Every A2A server must publish one. Clients find cards at a well-known URI (/.well-known/agent-card.json), through a registry, or by direct configuration. The project's discovery guide notes that the specification does not prescribe a standard API for registries.

Cards may be signed, using JSON Web Signature (RFC 7515) over a canonicalised form of the card (RFC 8785). A verifying client retrieves the public key using the key ID and a jku URL, "or from a trusted key store". Clients should verify at least one signature before trusting a card, and must not use expired or revoked keys.

Two points follow. The second is our reading, not the specification's.

  • Signing is optional. An unsigned card is still a valid card. If you require signatures, that is your policy, not the protocol's default.
  • A signature proves who published the card, not that the agent is safe. If the key comes from a URL named inside the card being verified, the signature shows only that whoever controls that location signed it. For a partner you deal with, obtain the key, or the location of their key set, through your own onboarding and pin it.

The specification also defines an extended Agent Card: a fuller version returned only to authenticated clients, which may list skills the public card does not. Fetching it must require authentication, and it should not contain information that could be exploited if leaked, such as internal service URLs or unmasked credentials.

How agents authorise each other across organisations

Suppose your procurement agent sends purchase requests to a supplier's order agent. Three questions decide whether that is safe.

Who is calling? The supplier sees whatever identity your credential carries, and nothing more. If the credential is one client secret shared by your whole platform, the supplier cannot tell one agent, or one user, from another. Give each agent its own identity and, where a person is behind the request, use delegation rather than a shared account, as set out in our guide to AI agent identity and delegated access.

What may it do? The enterprise guidance recommends skill-based authorisation, with OAuth scopes that grant access to some skills but not others, and least privilege. Scope partner credentials per skill, not per agent.

What happens mid-task? An agent that needs further authorisation, such as an access token for another API or a human approval before a destructive action, can move the task to TASK_STATE_AUTH_REQUIRED and ask its client to resolve it. The specification is careful here. That state transition, by itself, must not be treated as authorisation for any operation, and credentials should arrive out of band over a secure channel. If credentials do pass along a chain of agents, they should be bound to the agent that requested them, so the agents in between cannot use them.

The risks A2A cannot close for you

OWASP's Top 10 for Agentic Applications files this territory under ASI07 Insecure Inter-Agent Communication: exchanges that lack proper authentication, integrity or semantic validation. Its examples include descriptor forgery, protocol downgrade, replayed delegation messages, and "A2A registration spoofing", where an attacker registers a fake peer agent in a discovery service using a cloned schema.

TLS and signed cards address forgery and tampering. They do nothing about content. A card's skill descriptions and examples are text your agent's model reads when it decides whom to call, and a remote agent's reply is text your agent acts on. Both are untrusted input, in the same way that a tool description can carry instructions. A partner agent that has itself been injected passes the injection on, correctly signed and over TLS.

Push notifications add one more surface. A client can register a webhook for task updates, and the agent then calls a URL someone else chose. The specification says agents should validate webhook URLs to prevent server-side request forgery, rejecting private IP ranges, localhost and link-local addresses, and that clients must check the authenticity of every notification they receive.

What to check before trusting another organisation's agent

  1. Card authenticity. Do you require a signed card, and is the verification key one you obtained independently?
  2. Card changes. When a partner's card gains a skill or changes its security schemes, does anyone review it before your agents rely on it? Treat it like a changed API contract.
  3. Credential shape. Is each credential per agent, scoped to specific skills, short-lived, and never an API key in a query string?
  4. Server-side authorisation. On your own A2A servers, is every operation authorised, including task listing, and scoped to the caller?
  5. In-task authority. Does any code path treat a task resuming after TASK_STATE_AUTH_REQUIRED as permission, without checking the specific operation?
  6. Content as data. Are card text and remote outputs handled as untrusted input, and is any consequential action they lead to checked before it runs?
  7. Webhooks. Are push notification URLs validated, and every notification authenticated?
  8. Logs on both sides. The specification asks agents to keep audit trails for sensitive operations and says logs must not include credentials or personal data unless required and properly protected; the enterprise guidance asks for trace context to be propagated. Can you reconstruct a cross-organisation task from your side alone?

Where Syntrox fits

Syntrox sits outside the agent, so a check on what a partner's agent sent back does not depend on either agent's account of itself. Our judge, Nucleus, treats any text inside the material it evaluates as evidence, never as instructions, and an instruction addressed to the evaluator counts against the output. Syntrox records each evaluated trace's score, confidence and judge version outside the agent.

5 min read

AI Agent Identity: Why Shared Service Accounts Break Authorisation, and What Replaces Them

Give every agent its own identity, and when it acts for a person, put both in the credential: the user it acts for and the agent doing the acting. OAuth 2.0 Token Exchange (RFC 8693) defines exactly that delegation. Then make each credential short-lived, scoped to the task and bound to one audience, so a leaked or misused token is worth little and every action traces back to an agent and a person.

Read

4 min read

Tool-Call Authorization for AI Agents: The Model Shouldn't Decide What It's Allowed to Do

An agent's permissions should be enforced outside the model, on every tool call, by the systems the call touches. That means four things: give each agent its own identity, scope its credentials to the task, check every call against policy before it runs, and treat the model's own judgement of what is allowed as advice, never authority.

Read

5 min read

SR 11-7 and AI Agents: What Model Risk Management Asks For, Now That Its Replacement Leaves Agents Out

SR 11-7 was superseded on 17 April 2026 by SR 26-2, which puts generative and agentic AI explicitly out of scope and leaves their controls to each bank's own governance. SR 11-7 is still the most complete template for that job: a clear statement of purpose, validation of conceptual soundness, ongoing monitoring and outcomes analysis, an inventory, and effective challenge with the authority to restrict use.

Read