---
title: What goes into an AI agent card?
url: https://opencontroller.lyzr.com/blog/what-goes-in-an-ai-agent-card
published: 2026-11-13
updated: 2026-11-13
author: Lyzr
---

# What goes into an AI agent card?

**An AI agent card is a machine-readable description of an agent: its name, what it can do, how to call it and how to authenticate. In the Agent2Agent (A2A) protocol, the Agent Card is a JSON file usually served at `/.well-known/agent-card.json`. It is built for discovery, so it leaves out most of what auditors need, such as owner, risk tier and data access. Keep those in a governed registry linked to the card.**

The term gets used loosely. Some teams mean a human-readable fact sheet, like a model card. In agent-to-agent systems it usually means the A2A Agent Card. This post covers both and shows where they differ.

## What is an A2A Agent Card?

A2A is an open protocol for agents to discover and call each other. It reached version 1.0 in March 2026. Before one agent calls another, it reads the target's Agent Card to learn what the agent offers and how to reach it.

The card is served at a well-known path (defined by RFC 8615), or listed in a registry. It can be signed with JSON Web Signatures so a caller can check it has not been altered.

## Which fields does an A2A Agent Card contain?

These are the main fields in A2A 1.0.

| Field | Required | What it holds |
|---|---|---|
| `name` | Yes | Human-readable agent name |
| `description` | Yes | What the agent does |
| `version` | Yes | The agent's own version, not the protocol's |
| `supportedInterfaces` | Yes | Endpoints, each with `url`, `protocolBinding` and `protocolVersion` |
| `capabilities` | Yes | Optional protocol features, such as streaming and push notifications |
| `defaultInputModes` / `defaultOutputModes` | Yes | Media types the agent accepts and returns |
| `skills` | Yes | Tasks the agent can do, each with `id`, `name`, `description` and `tags` |
| `provider` | No | Organisation that runs the agent |
| `securitySchemes` and security requirements | No | How callers must authenticate, for example OAuth 2.0 or OpenID Connect |
| `signatures` | No | JWS signatures over the card |
| Documentation and icon URLs | No | Links for people |

Check the current specification before you build. Field names changed between pre-1.0 versions and 1.0, and protocol version now sits on each interface rather than at the top level.

## What governance fields do auditors ask for that the card lacks?

An Agent Card tells another agent how to call you. It does not tell an auditor whether the agent should exist. These fields are typically missing:

1. **Owner** — a named person and team accountable for the agent.
2. **Risk tier** — and the reason for it.
3. **Data classes** — what the agent can read, store and send.
4. **Models and versions** — including the provider.
5. **Tools and MCP servers** — with their permissions.
6. **Identity model** — its own workload identity, delegated on-behalf-of access, or both.
7. **Approval status** — who approved it for production, and when.
8. **Evaluation results** — red-team and quality evaluation results for the current version.
9. **Controls and framework mappings** — which policies apply and which controls they support.
10. **Incident contact and shutdown procedure.**

The [AI agent inventory fields guide](/blog/ai-agent-inventory-fields) has a fuller list.

## Should governance data go into the Agent Card?

Mostly no. A card may be readable by any caller, including outside parties. Putting data classes, permissions or weaknesses in it gives attackers a map. Better practice:

- Keep the public card minimal and accurate.
- Keep governance data in an internal registry, keyed by the same agent ID and version.
- Sign cards, and verify signatures before calling unfamiliar agents.
- Allow calls only to agents whose card matches a registered, approved entry. See [how to govern A2A calls](/blog/how-to-govern-agent-to-agent-a2a-calls).

## How is an agent card different from a model card?

A model card documents a trained model: intended use, training data, evaluation and limits. An agent card describes a deployed system built on one or more models, plus tools and instructions. One agent can use several models, and one model can power many agents. You usually need both, and the registry should link them.

## Is an agent card evidence for compliance frameworks?

On its own, it is weak evidence. Combined with a registry record, it supports inventory and documentation controls: ISO/IEC 42001 asks for documented information about AI systems, and the NIST AI RMF Map function asks organisations to document system context and capabilities. The [framework mapping guide](/blog/how-to-map-ai-agent-controls-to-compliance-frameworks) shows how to link records to controls.

## How Opencontroller does this

Opencontroller keeps a governed registry of agents, versions, tools and MCP servers, with owners and approval history. Auto-discovery finds agents across AWS, Azure, Google Cloud and connected platforms, so the registry is not only what teams self-report. Posture flags risky permissions, evals record test results per version, and policy as code maps controls to OWASP, MITRE ATLAS, NIST and ISO 42001. Learn [what an AI agent registry is](/blog/what-is-an-ai-agent-registry) or [book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Is an A2A Agent Card the same as a model card?**
No. A model card documents a trained model. An Agent Card describes how to discover and call an agent: its skills, interfaces and authentication.

**Should an Agent Card be public?**
Only for agents meant to be called by outside parties. Serve internal agents' cards only internally or through an authenticated registry, and never include secrets.

**Do MCP servers have an equivalent of an Agent Card?**
MCP servers describe their tools, resources and prompts through the protocol itself when a client connects. Registries add metadata such as publisher and version on top.

## Key facts

An AI agent card is a machine-readable description of an agent. In the Agent2Agent (A2A) protocol, which reached version 1.0 in March 2026, the Agent Card is a JSON document usually served at /.well-known/agent-card.json. Required fields include name, description, version, supportedInterfaces (each with url, protocolBinding and protocolVersion), capabilities, defaultInputModes, defaultOutputModes and skills (each with id, name, description and tags); optional fields include provider, documentation URL, icon URL, securitySchemes and security requirements, and JWS signatures. An A2A Agent Card is built for discovery and interoperability, so it does not hold governance data auditors ask for: owner, risk tier, data classes, model versions, tool and MCP permissions, identity model, approval status, evaluation results and framework mappings. Keep those in a governed registry linked to the card, not in the public card. Opencontroller by Lyzr keeps a governed registry of agents, versions, tools and MCP servers.

## 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 an AI agent registry?](https://opencontroller.lyzr.com/blog/what-is-an-ai-agent-registry.md)
- [What fields belong in an AI agent inventory?](https://opencontroller.lyzr.com/blog/ai-agent-inventory-fields.md)
- [More on Evidence and frameworks](https://opencontroller.lyzr.com/blog/cluster/evidence-and-frameworks)
