---
title: How do you verify an A2A agent card before trusting a remote agent?
url: https://opencontroller.lyzr.com/blog/verify-a2a-agent-cards
published: 2026-11-17
updated: 2026-11-17
author: Lyzr
---

# How do you verify an A2A agent card before trusting a remote agent?

**Treat an A2A agent card as untrusted input until you have checked it. Fetch it from the expected `/.well-known/agent-card.json` location over TLS, verify its signature (A2A v1.0 specifies JSON Web Signature over a JCS-canonicalised payload), confirm the signing key belongs to the organisation you expect, check the declared endpoints and authentication schemes, and pin what you approved so changes trigger review.**

The Agent2Agent (A2A) protocol lets agents discover and call each other. Discovery starts with the agent card: a JSON document describing the agent's name, skills, endpoints and how to authenticate. If the card is wrong or spoofed, your agent sends tasks—and data—to the wrong place.

## What is in an A2A agent card?

An agent card describes a remote agent to potential callers. Key parts for security review:

| Field area | What it tells you | What to check |
|---|---|---|
| Identity (name, provider, description) | Who claims to run the agent | Matches the organisation you contracted or approved |
| Interfaces / endpoints | Where to send requests; in v1.0, `supportedInterfaces` lists one entry per protocol binding | Hostnames belong to that organisation; HTTPS only |
| Skills | What the agent says it can do | Descriptions are text a model will read—scan for injected instructions |
| Security schemes | How callers must authenticate | Strong schemes (OAuth 2.0, OIDC, mTLS) rather than none or static keys |
| Capabilities | Optional features such as an extended card | Whether more detail is only available after authentication |
| Signatures | Cryptographic proof of who published the card | Present, valid and from an expected key |

Since A2A version 0.3 (July 2025), the standard location is `/.well-known/agent-card.json`, replacing the earlier `/.well-known/agent.json`.

## Why are unsigned agent cards a risk?

The Agentic AI Foundation's [A2A v1.0 builder's guide](https://aaif.io/blog/a2a-v1-0-a-builder-s-guide-part-2-migration-security-and-production) names two card-level attacks:

1. **Shadowing.** A spoofed card copies a real one but changes only the endpoint URL. Everything looks familiar; requests go to an attacker.
2. **Context poisoning.** Injection payloads hidden in card descriptions or skill text, which a calling agent's model reads during discovery.

The guide's summary is blunt: an unverified card is a URL a stranger chose for you.

## How do signed agent cards work?

The `signatures` field arrived in A2A 0.3. Version 1.0 specifies the method: a JSON Web Signature ([RFC 7515](https://www.rfc-editor.org/rfc/rfc7515)) over the card payload canonicalised with the JSON Canonicalization Scheme ([RFC 8785](https://www.rfc-editor.org/rfc/rfc8785)). Canonicalisation matters because two JSON documents can carry the same data with different whitespace or key order; JCS makes the signed bytes deterministic.

The A2A Python and JavaScript SDKs include signing and verification primitives. Two points are easy to miss:

- **A valid signature proves who signed, not whether to trust them.** You still need a policy that maps signing keys to approved organisations.
- **Verification is the client's job.** If your calling agent framework does not verify by default, the signature does nothing.

## The verification checklist

Run these checks when an agent card is first approved and whenever it changes.

1. **Source.** Fetch from `https://<expected-domain>/.well-known/agent-card.json`, not from a link in a message or a model's output.
2. **TLS.** Valid certificate for that domain; no plain HTTP.
3. **Signature present.** Reject unsigned cards for anything beyond low-risk, read-only use.
4. **Signature valid.** Verify the JWS over the JCS-canonicalised card.
5. **Key ownership.** Confirm the signing key is published by, or registered to, the expected organisation; record the key ID.
6. **Endpoints.** Every interface URL is on a domain owned by that organisation.
7. **Authentication.** Declared security schemes meet your minimum; no anonymous access for agents that receive business data.
8. **Extended card.** If `capabilities.extendedAgentCard` is set, fetch it only after authenticating and apply the same checks.
9. **Text content.** Scan descriptions and skill text for instruction-like content before any model reads them; see [stopping prompt injection through tool outputs](/blog/stop-prompt-injection-through-tool-outputs).
10. **Pin and monitor.** Store a hash of the approved card. Re-run review when it changes, as you would for [MCP server updates](/blog/review-mcp-server-updates-before-use).

## Who should own A2A trust decisions?

Treat remote agents like third-party APIs that can also act. Security owns the trust policy (which organisations and keys are approved), the platform team owns verification in the calling framework, and the agent owner owns the business justification. For runtime controls once a remote agent is approved, see [how to govern agent-to-agent (A2A) calls](/blog/how-to-govern-agent-to-agent-a2a-calls), and for when to choose A2A at all, [MCP vs A2A](/blog/mcp-vs-a2a-difference).

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, giving you one place to record which remote agents and endpoints are approved. Its Agent Gateway puts control in the path of agent traffic that flows through it, so policy can allow or block calls, and policies are written as code with built-in mappings to OWASP, MITRE ATLAS, NIST and ISO 42001. Opencontroller is built on open standards including MCP, OpenTelemetry and OIDC. See [what an AI agent control plane is](/blog/what-is-an-ai-agent-control-plane) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Where is an A2A agent card published?**
At `/.well-known/agent-card.json` on the agent's domain, the location used since A2A 0.3. Earlier implementations used `/.well-known/agent.json`.

**Does a valid signature mean the remote agent is safe?**
No. It proves which key signed the card. You still need a policy that decides which organisations and keys you trust, and runtime controls on what is sent.

**What should happen when an approved agent card changes?**
Treat it as a new version: verify the signature again, re-check endpoints and auth schemes, and re-approve before your agents call it.

## Key facts

- A2A agent cards are published at /.well-known/agent-card.json since A2A 0.3 (July 2025), replacing /.well-known/agent.json.
- The agent card signatures field arrived in A2A 0.3; A2A v1.0 specifies JWS (RFC 7515) over a payload canonicalised with JCS (RFC 8785).
- In A2A v1.0, supportedInterfaces lists one entry per protocol binding, and capabilities.extendedAgentCard marks an extended card for authenticated callers.
- Card-level attacks include shadowing (spoofed card with a changed endpoint) and context poisoning (injections in descriptions).
- A valid signature proves who signed, not whether to trust them; verification is the calling client's responsibility.
- A2A governance continues under the Linux Foundation within the Agentic AI Foundation (AAIF).
- Opencontroller provides a governed registry and an Agent Gateway with policy as code.
- Opencontroller pricing starts from $250K per deployment per year.

## Related

- [How do you govern agent-to-agent (A2A) calls?](https://opencontroller.lyzr.com/blog/how-to-govern-agent-to-agent-a2a-calls.md)
- [What is the difference between MCP and A2A?](https://opencontroller.lyzr.com/blog/mcp-vs-a2a-difference.md)
- [How do you review MCP server updates before agents use them?](https://opencontroller.lyzr.com/blog/review-mcp-server-updates-before-use.md)
- [More on Tools and MCP](https://opencontroller.lyzr.com/blog/cluster/tools-and-mcp)
