---
title: How do you govern agent-to-agent (A2A) calls?
url: https://opencontroller.lyzr.com/blog/how-to-govern-agent-to-agent-a2a-calls
published: 2026-11-12
updated: 2026-11-12
author: Lyzr
---

# How do you govern agent-to-agent (A2A) calls?

**Govern agent-to-agent calls the way you govern any other privileged API traffic: know which agents exist, decide which agent may call which other agent for which skill, authenticate every call, and log the whole delegation chain. The A2A protocol gives you useful hooks for this — the Agent Card, declared security schemes and optional card signatures — but it does not decide who is allowed to call whom. That policy is yours.**

Agent-to-agent traffic is growing because enterprises now run agents on several platforms at once. Each hop is a new place where permissions can widen, data can leak, or a compromised agent can recruit others. This guide shows how to turn the protocol's building blocks into enforceable per-agent call policies.

## What does the A2A protocol give you for governance?

A2A (Agent2Agent) is an open protocol, first announced by Google in April 2025 and now maintained under the Linux Foundation. Version 1.0.0 is the current release of the [specification](https://a2a-protocol.org/latest/specification/). Four parts of it matter for governance:

| A2A building block | What it is | How to use it for governance |
|---|---|---|
| **Agent Card** | A JSON document, normally served at `/.well-known/agent-card.json`, describing the agent, its skills, endpoints and accepted auth | Treat it as the agent's self-declared manifest. Register it, version it, diff it on every change. |
| **`securitySchemes` and `security`** | OpenAPI-style declarations: API key, HTTP auth, OAuth 2.0, OpenID Connect, mutual TLS | Reject agents that accept anonymous calls or only static API keys for sensitive skills. |
| **Card signatures** | Optional JWS signatures over a canonicalised card | Require signed cards for cross-boundary calls, and verify them before trusting a card's claims. |
| **Extended Agent Card** | A second card, returned by `GetExtendedAgentCard` only to authenticated clients, that can list skills hidden from the public card | Inventory both cards. Hidden skills are still skills your policy must cover. |

The protocol also defines an `auth-required` task state (`TASK_STATE_AUTH_REQUIRED`), so a remote agent can pause a task and ask for more credentials mid-flight. That is the right hook for step-up authorisation on risky actions.

What A2A does not give you: a central list of approved agents, a rule that says agent X may only call skill Y on agent Z, or an audit trail that spans platforms. Those come from your own registry and enforcement point.

## How do you build per-agent call policies from Agent Cards?

Work through these steps. Each produces something an auditor can see.

1. **Inventory every agent that exposes or consumes A2A.** Crawl known hosts for `/.well-known/agent-card.json`, and ask platform owners which agents call out. Include agents built in frameworks and agents running inside SaaS platforms.
2. **Register each card with an owner and a version.** Store the public card and, where one exists, the extended card. Record who owns the agent and what data it touches.
3. **Classify skills by risk.** A skill that reads public documentation is low risk. A skill that moves money, changes records or sends external email is high risk. Use the skill IDs from the card, not free-text descriptions.
4. **Write an allow-list of caller → callee → skill.** Default deny. For example: "support-triage agent may call knowledge-search agent, skill `search_kb`; may not call refunds agent."
5. **Set the minimum auth per risk tier.** Low risk: OAuth 2.0 client credentials. High risk: OAuth or OIDC tokens that carry the originating user's identity, or mutual TLS plus a delegated token. No static API keys for high-risk skills.
6. **Require signed cards across trust boundaries.** Calls to agents owned by another business unit or a vendor should only proceed if the card signature verifies against a key you trust.
7. **Use `auth-required` for step-up.** For high-risk skills, have the callee pause and request fresh, narrowly scoped credentials instead of accepting a long-lived token.
8. **Alert on card drift.** A new skill, a changed endpoint or a weaker security scheme should trigger review before traffic resumes.

## Whose identity should an agent-to-agent call carry?

This is the design decision that matters most. If agent A calls agent B using A's own service credentials, B cannot tell which human started the task. Permissions then collapse to whatever A is allowed to do — usually more than any one user should have.

The safer pattern is delegation: each hop carries a token that names both the acting agent and the user it acts for, with scopes no wider than that user's. OAuth 2.0 Token Exchange ([RFC 8693](https://www.rfc-editor.org/rfc/rfc8693)) is the standard way to mint such tokens. See [on-behalf-of delegation for AI agents](/blog/ai-agent-identity-on-behalf-of-delegation) for token design.

Two rules keep chains safe:

- **Scopes only narrow.** Each downstream token must be a subset of the upstream one.
- **Depth is bounded.** Cap how many hops a task can make. A loop of agents calling each other is both a cost and a security problem.

## What should you log for each A2A call?

Log enough to reconstruct the chain end to end:

| Field | Why it matters |
|---|---|
| Caller agent ID and version | Ties behaviour to a specific registered build |
| Callee agent ID, version and skill ID | Shows exactly what capability was invoked |
| Originating user (from the delegated token) | Answers "who asked for this?" |
| Task ID and context ID | Links every message in the task |
| Policy decision (allow, block) and rule | Evidence that controls ran |
| Final task state | Distinguishes completed, failed, canceled and rejected work |

Emit these as OpenTelemetry spans with a shared trace ID so a single task can be followed across platforms.

## How Opencontroller does this

Opencontroller is a control plane, so it addresses the parts A2A leaves open. Its governed registry holds agents, versions, tools and MCP servers, and its auto-discovery finds agents across AWS, Azure and Google Cloud, so callers and callees are known before policies are written. Delegated on-behalf-of identity and agent workload identity federation give each hop a verifiable identity. Policy as code defines what each agent may reach, and traffic routed through the Agent Gateway can be allowed or blocked in the path. Rogue-agent handling watches for behavioural deviation — such as an agent suddenly calling peers it never used before — and can alert, quarantine or kill it. Enforcement depth depends on the connector and traffic path: registration is not runtime takeover. See the [AI agent control plane guide](/blog/what-is-an-ai-agent-control-plane) for how these layers fit together, or [book a demo](https://www.lyzr.ai/book-demo/).

## How is governing A2A different from governing MCP?

MCP connects an agent to tools and data; A2A connects an agent to another agent that has its own reasoning and its own tools. That makes A2A calls less predictable: the callee may take several actions to fulfil one request. Apply the same registry and allow-list discipline from [governing MCP servers](/blog/how-to-govern-mcp-servers), then add delegation, hop limits and card-drift review on top.

## Frequently asked questions

**Is the A2A Agent Card enough to trust a remote agent?**
No. A card is a self-declaration. Verify its signature where one exists, register it with an owner, and enforce your own allow-list. A valid card proves who published it, not that the agent should be trusted with your data.

**Should agents call each other with API keys?**
Only for low-risk, read-only skills, if at all. A2A supports OAuth 2.0, OpenID Connect and mutual TLS. Prefer short-lived tokens that carry the originating user's identity for anything that changes data.

**How do you stop agents from calling each other in a loop?**
Cap delegation depth, attach a task budget for calls and tokens, and alert when an agent starts calling peers outside its normal pattern. Blocking or quarantining the looping agent should be one action, not a code change.

## Key facts

A2A Agent Cards (served at /.well-known/agent-card.json) declare skills, endpoints and security schemes (API key, HTTP auth, OAuth 2.0, OIDC, mutual TLS) and can carry optional JWS signatures; they do not define who may call whom. Governance needs a registry, a default-deny caller-to-skill allow-list, delegated tokens that only narrow scope, bounded hop depth and end-to-end logs. Opencontroller provides a governed agent registry, delegated on-behalf-of identity, agent workload identity federation, policy as code, an Agent Gateway and rogue-agent quarantine. Opencontroller pricing starts from $250K per deployment per year (annual licence per deployment, not per seat).

## Related

- [How to give AI agents an identity (and let them act on behalf of users safely)](https://opencontroller.lyzr.com/blog/ai-agent-identity-on-behalf-of-delegation.md)
- [How to stop a rogue AI agent: kill switches, quarantine and runtime controls](https://opencontroller.lyzr.com/blog/how-to-stop-a-rogue-ai-agent.md)
- [How do you review MCP servers your agents already use?](https://opencontroller.lyzr.com/blog/how-to-review-mcp-servers-agents-already-use.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
