---
description: An AI agent registry records each agent's identity, owner, skills, endpoints, auth and access. Learn the fields, discovery models and governance it needs.
title: "AI Agent Registry: How Teams Discover and Govern Internal Agents"
image: https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w1200/2026/10/ai-agent-registry-how-teams-discover-and-govern-internal-age-bifrost-1920x1080.png
---

Try Bifrost Enterprise free for 14 days. [Request access](https://www.getmaxim.ai/#enterprise-trial)

**TL;DR**

- An AI agent registry is an inventory of agents recording identity, owner, skills, endpoints, authentication, status, version and access rules for each one.
- Teams need one once they run more than a handful of agents, because discovery, duplication, ownership, access, decommissioning and audit stop working from memory.
- A2A describes three discovery models (well-known agent cards, curated registries, direct configuration) and does not define a standard registry API.
- An agent registry governs who can call an agent; an MCP registry governs which tools that agent can call. The grants are separate.
- Bifrost keeps an Agent Catalog of A2A agents registered by card URL, with per-agent virtual key grants, gateway endpoints and Agent Logs.

An AI agent registry is the system of record for the agents an organization runs: what each agent is, who owns it, what it can do, where it is reached, how callers authenticate, and who may call it. [Bifrost](https://www.getmaxim.ai/), the [open-source AI gateway for model, tool and agent traffic](https://github.com/maximhq/bifrost) built by Maxim AI, acts as a governed registry for A2A agents by putting registration, access grants and logs on the path agent calls already take. This guide covers registry fields, discovery models, the MCP registry boundary, and Bifrost's implementation.

## What Is an AI Agent Registry?

An AI agent registry is a governed inventory of agents that records each agent's identity, owner, capabilities, endpoints, authentication requirements, status and version, and decides which callers may use it.

An entry usually starts from the agent's self-description. In the [Agent2Agent (A2A) protocol](https://a2a-protocol.org/latest/topics/agent-discovery/), that is the agent card: a JSON document listing name, description, provider, service endpoint, capabilities such as streaming or push notifications, authentication schemes and skills. The card is the builder's claim; the registry adds the platform team's decisions about ownership, approval, access and retirement. Bifrost treats the [agent card as the agent's directory entry](https://docs.getbifrost.ai/features/agent-gateway/overview) and layers access and logging on top of it.

## Why Teams Need an Agent Registry Past a Handful of Agents

Teams need an agent registry once agents outgrow informal tracking, typically when they span more than one team. Past that point, nobody can say which agents exist, who owns them, who can call them, or whether they are still used. That condition is agent sprawl.

Common failure modes:

- **Discovery:** a team rebuilds an agent another team already shipped.
- **Duplication:** two agents do the same job at different costs.
- **Ownership:** the on-call engineer cannot find who built a failing agent.
- **Access:** a finance agent is reachable by anyone with its URL.
- **Decommissioning:** an agent is shut down while three applications still hold its endpoint.
- **Audit:** nobody can say which applications called the HR agent last quarter.

The wider [AI agent governance model of identity, permissions, budgets and lifecycle](https://www.getmaxim.ai/articles/ai-agent-governance-identity-permissions-budgets-and-lifecycle-in-production/) depends on this inventory, because a policy cannot target an agent nobody recorded.

## Agent Discovery Models: Well-Known Cards, Curated Registries and Private Catalogs

Agent discovery is how a client agent or application finds another agent's card. The A2A documentation describes three strategies: a well-known URI on the agent's domain, a curated registry holding approved cards, and direct configuration. Organizations often run more than one.

![A client agent reaches a remote A2A agent's card through one of three discovery paths: a well-known URI, a curated agent registry, or direct configuration](https://articles-images-cdn.t3.tigrisfiles.io/diagrams/ai-agent-registry/ai-agent-registry-discovery-models.png)

*Figure 1: Only the curated registry path gives a platform team one place to approve, scope, and retire agents.*

| Discovery model | How it works | Strength | Limitation |
| --- | --- | --- | --- |
| Well-known agent card | The agent hosts its card at `/.well-known/agent-card.json`, following the [RFC 8615 well-known URI convention](https://www.rfc-editor.org/rfc/rfc8615.html) | Standard and simple | No central list; access is only as strong as the card endpoint's auth |
| Curated registry | A central service stores cards and answers queries by skill or tag | Central approval and lifecycle | No standard A2A registry API, so each registry is its own implementation |
| Direct configuration | Card URLs live in config files or environment variables | Fine for a fixed pair of services | Every change means reconfiguring clients |
| Private catalog in a gateway | Agents are registered in the gateway, which serves its own card and endpoints | Discovery and enforcement on one path | Callers must be pointed at the gateway |

The A2A discovery page states that the current specification "does not prescribe a standard API for curated registries." A [2025 survey of AI agent registry solutions](https://arxiv.org/abs/2508.03095v1) compares A2A agent cards, MCP registry metadata and the NANDA index, each defined by its own metadata model.

For internal agents, the fourth row matters most: when the catalog lives in the gateway, callers only hold governed endpoints, so they cannot bypass the registry's access rules. The [A2A protocol gateway guide](https://www.getmaxim.ai/articles/a2a-protocol-gateway/) covers the protocol side of that path.

## What a Good Agent Registry Records: A Field Checklist

A good agent registry records enough to identify, reach, authorize, monitor and retire every agent without asking its builder. The minimum is identity, owner, skills, endpoints, authentication, access grants, status and version, plus a link to activity logs.

| Field | Why it matters | How Bifrost covers it |
| --- | --- | --- |
| Name and identity | Stable reference for policies, logs and URLs | Registration name, which becomes part of the gateway URL |
| Owner and team | Who to page, who approves changes | Not a registration field; encode it in naming or your service catalog |
| Description and skills | Helps callers pick the right agent and avoid duplicates | Read from the agent card and shown in the registration preview |
| Capabilities | Streaming, push notifications, extensions | Read from the card; supported A2A extensions are discovered automatically |
| Endpoints and transports | Where callers send work | Gateway endpoints for agent card, JSON-RPC, REST and gRPC |
| Authentication | How the registry reaches the agent | Separate card-fetch and request auth: headers, OAuth 2.0 client credentials, TLS |
| Access grants | Which callers may use the agent | Per-agent virtual key grants; access profiles and projects in Enterprise |
| Status | Whether the agent should receive traffic | Enabled flag; the agent list includes disabled agents |
| Version | Which card and skills are live | The current card is fetched on each card request, not cached |
| Activity and audit | Who called what, and what happened | Agent Logs per agent, session and task, plus telemetry export |

Ownership is the field most often missed, because the agent cannot report it. Grants in Bifrost attach to [virtual keys](https://docs.getbifrost.ai/features/governance/virtual-keys), the same governance entity used for model and tool access.

## Governing the Agent Lifecycle

Agent lifecycle management covers registration, access approval, endpoint publication, monitoring and decommissioning. A registry that stops at registration becomes a stale wiki; the value is in the grant, monitoring and retirement stages.

![An agent moves left to right through registration, access approval, endpoint publication, monitoring, and decommissioning, with logs exported to existing monitoring tools](https://articles-images-cdn.t3.tigrisfiles.io/diagrams/ai-agent-registry/ai-agent-registry-lifecycle.png)

*Figure 2: Registration is the first step, not the last: most registry value comes from the grant, monitoring, and retirement stages.*

- **Register:** record the card URL, a stable name and the owner.
- **Grant access:** default to none, then grant named callers.
- **Publish endpoint:** give callers a governed endpoint, never the agent's raw address.
- **Monitor:** follow calls per agent and per conversation.
- **Decommission:** disable first, watch for remaining callers, then remove the registration and its grants.

In Bifrost, creating, viewing and deleting agents map to separate [RBAC](https://docs.getbifrost.ai/enterprise/rbac) permissions, and Bifrost Enterprise [audit logs](https://docs.getbifrost.ai/enterprise/audit-logs) record administrative activity: who changed what, when, and on which resource.

## Agent Registry vs MCP Registry

An agent registry lists agents that applications and other agents delegate work to over A2A. An MCP registry lists MCP servers whose tools an agent can call. They govern different hops: the agent registry decides who may call an agent, and the MCP registry decides which tools that agent may use once it runs.

![An application calls a research agent over A2A through an agent grant check, and the agent then calls MCP servers through a separate tool grant check in Bifrost](https://articles-images-cdn.t3.tigrisfiles.io/diagrams/ai-agent-registry/ai-agent-registry-vs-mcp-registry.png)

*Figure 3: An agent registry decides who may call an agent; an MCP registry decides which tools that agent may call. Neither grant implies the other.*

|  | Agent registry | MCP registry |
| --- | --- | --- |
| What it lists | Agents that accept tasks | MCP servers that expose tools |
| Discovery document | A2A agent card | MCP server metadata and tool lists |
| Unit of work | Messages and stateful tasks | Individual tool calls |
| Grant question | May this caller delegate to this agent? | May this agent use this tool? |

A common mistake is assuming an agent grant also covers tools. In Bifrost, [agent access is separate from model and tool permissions](https://docs.getbifrost.ai/features/agent-gateway/access-control), so an agent grant alone does not authorize the agent's later LLM or MCP calls.

For the tool side, see [what an MCP registry is and how it governs MCP servers](https://www.getmaxim.ai/articles/what-is-an-mcp-registry-discovering-and-governing-mcp-servers/) and this [comparison of MCP registry tools](https://www.getmaxim.ai/articles/mcp-registry-tools/). Bifrost governs both hops as one gateway, as described on the [MCP gateway page](https://www.getmaxim.ai/mcp-gateway).

## How Bifrost Works as an A2A Agent Registry

[The Bifrost AI gateway](https://www.getmaxim.ai/) works as an A2A agent registry through the Agent Catalog. Each agent is registered from its agent card URL, granted to specific callers through virtual keys (and, in Enterprise, access profiles and projects), exposed through gateway endpoints, and logged per agent in Agent Logs.

![Two callers with virtual keys reach registered A2A agents through the Bifrost Agent Catalog, an anonymous call is rejected, and every operation lands in Agent Logs](https://articles-images-cdn.t3.tigrisfiles.io/diagrams/ai-agent-registry/ai-agent-registry-bifrost-catalog.png)

*Figure 4: With authentication enforcement on, callers only reach gateway endpoints, so grants apply to every call and each call is logged per agent.*

### Agent Catalog and registration by card URL

Registered agents live in **Agents → Agent Catalog**. To [register an agent](https://docs.getbifrost.ai/features/agent-gateway/registration), you name it and enter the complete card URL, such as `https://research.example.com/.well-known/agent-card.json`. The preview shows the agent's skills, interfaces, capabilities and advertised authentication, and card-fetch and request credentials are configured separately.

### Per-agent access grants

A virtual key granted `library-research` can call that agent's gateway routes and gains no access to any other registered agent. An **Allow any virtual key** toggle covers agents every valid key should reach, and authentication enforcement on the deployment rejects anonymous calls. Bifrost Enterprise adds [access profiles](https://docs.getbifrost.ai/enterprise/access-profiles), which carry agent grants for users, roles, teams, business units and customers, and [projects](https://docs.getbifrost.ai/enterprise/projects), which scope a single request through the `x-bf-project-name` header. The [access profiles walkthrough](https://www.getmaxim.ai/articles/enterprise-ai-governance-with-bifrost-access-profiles/) shows how profiles map to an org chart.

### Gateway endpoints and Agent Logs

Each registered agent has gateway endpoints for its agent card, JSON-RPC, REST and, when enabled, gRPC. Callers use the gateway's card, which is fetched live from the agent and rewritten with gateway endpoints, and [client and agent transports can differ](https://docs.getbifrost.ai/features/agent-gateway/configuration). [Agent Logs](https://docs.getbifrost.ai/features/agent-gateway/observability) filter by agent, status, task state and caller, group operations by A2A context ID, and export to connectors such as OpenTelemetry, Prometheus and Datadog.

Bifrost does not run a public directory or marketplace of third-party agents; the Agent Catalog holds only the agents your organization registers. See the [Agent Gateway launch post](https://www.getmaxim.ai/bifrost/blog/introducing-agent-gateway-in-bifrost-one-gateway-for-models-tools-and-agents).

## Setting Up a Governed Agent Catalog

A governed agent catalog takes four steps: set the gateway's public base URL, register each agent from its card, grant named callers with authentication enforcement on, and point callers at gateway endpoints. Registrations can also be declared in config.json or Helm.

- **Name agents by function and team.** The registration name is fixed and becomes the route.
- **Retire in two steps.** Disable, watch Agent Logs for remaining callers, then delete; deletion also removes the agent's virtual key grants.
- **Forward credentials only to trusted agents.** [Credential forwarding](https://docs.getbifrost.ai/features/agent-gateway/authentication) is off by default and lets the agent's model and tool calls follow the original caller's access and budgets.

For the wider decision, see [how to choose an agent gateway](https://www.getmaxim.ai/articles/how-to-choose-an-agent-gateway/) and the [governance resource page](https://www.getmaxim.ai/resources/governance).

## Frequently Asked Questions

### What is the difference between an agent registry and an agent catalog?

The terms overlap. An agent registry is the system of record with identity, ownership, access and lifecycle data; an agent catalog is the browsable list of registered agents. In Bifrost, the Agent Catalog is that list, and registry behavior comes from the grants, endpoints and logs attached to each registration.

### Does the A2A protocol define a standard agent registry?

No. A2A standardizes the agent card and describes three discovery strategies: well-known URIs, curated registries and direct configuration. The specification does not prescribe a standard curated-registry API, so each registry defines its own model; a [gateway-based approach to A2A traffic](https://www.getmaxim.ai/articles/a2a-protocol-gateway/) puts it on the call path.

### Is an agent card the same as a registry entry?

No. An agent card is published by the agent and describes its identity, endpoints, skills, capabilities and authentication. A registry entry adds organizational decisions the agent cannot make about itself: who owns it, whether it is approved, which callers may use it, and whether it is enabled. A good AI agent registry stores both.

### Do I need an agent registry if I only run a few agents?

With two or three agents owned by one team, a shared document can work. Once agents span several teams or touch sensitive data, informal tracking fails on access and decommissioning first. Register early, because callers are hard to move once they hold raw agent URLs.

### Does granting access to an agent let it use models and tools?

Not in Bifrost. Agent access is a separate grant from model and MCP tool access, so permission to call an agent does not authorize its later LLM or MCP calls. Those calls are checked against their own grants, under either the caller's forwarded credential or the agent's own virtual key, as covered in this guide to [enterprise agent gateways](https://www.getmaxim.ai/articles/enterprise-agent-gateway/).

### Does Bifrost include a public agent directory or marketplace?

No. Bifrost provides a private Agent Catalog of the A2A agents your organization registers, with per-agent access grants, gateway endpoints and Agent Logs. It does not list third-party agents. Agents meant for outside discovery can publish a well-known agent card on their own domain.

## Start Governing Your Agents with Bifrost

An AI agent registry gives every agent an identity, an owner, a governed endpoint and an audit trail, and it works best on the same path as agent traffic. The [open-source Bifrost gateway](https://www.getmaxim.ai/) combines the Agent Catalog, per-agent grants and Agent Logs with the [AI governance controls](https://www.getmaxim.ai/ai-governance) already applied to model and tool calls, inside your own infrastructure. To see how Bifrost would catalog and govern your agents, [book a demo](https://www.getmaxim.ai/book-a-demo) with the Bifrost team.

## Read next

[![Agent Communication Protocols Compared: A2A, MCP and ACP](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/10/agent-communication-protocols-compared-a2a-mcp-and-acp-bifrost-1920x1080.png) An agent communication protocol defines how AI agents talk to tools, to other agents, and to users. This guide compares MCP, A2A and ACP, explains what happened to ACP, covers AG-UI and AP2, and shows how to govern them in production.](https://www.getmaxim.ai/articles/agent-communication-protocols/)

[![A2A vs MCP: Differences, When to Use Each, and How to Run Both](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/10/a2a-vs-mcp-differences-when-to-use-each-and-how-to-run-both-bifrost-1920x1080.png) A2A vs MCP is a question of direction: MCP connects an agent to its tools and data, while A2A connects independent agents to each other. This guide compares their message models, transports, auth, discovery and task handling, and shows how to govern both at one gateway.](https://www.getmaxim.ai/articles/a2a-vs-mcp-2/)

[![AI Agent Orchestration vs Agent Gateway: Where Each Layer Fits](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/10/ai-agent-orchestration-vs-agent-gateway-where-each-layer-fit-bifrost-1920x1080.png) AI agent orchestration coordinates which agent runs, in what order and on what input, while an agent gateway governs the model, tool and agent calls that plan produces. This guide compares the two layers, the main orchestration patterns, and how Bifrost sits under any orchestrator.](https://www.getmaxim.ai/articles/ai-agent-orchestration-vs-agent-gateway/)

## More in Agent Gateway

[![Agent Communication Protocols Compared: A2A, MCP and ACP](https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w720/2026/10/agent-communication-protocols-compared-a2a-mcp-and-acp-bifrost-1920x1080.png) An agent communication protocol defines how AI agents talk to tools, to other agents, and to users. This guide compares MCP, A2A and ACP, explains what happened to ACP, covers AG-UI and AP2, and shows how to govern them in production.](https://www.getmaxim.ai/articles/agent-communication-protocols/)

```json
{
    "@context": "https://schema.org",
    "@type": "Article",
    "publisher": {
        "@type": "Organization",
        "name": "Maxim Articles",
        "url": "https://www.getmaxim.ai/articles/",
        "logo": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w256h256/2025/08/thumbnail.png",
            "width": 60,
            "height": 60
        }
    },
    "author": {
        "@type": "Person",
        "name": "Kuldeep Paul",
        "image": {
            "@type": "ImageObject",
            "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/2025/08/1727978381919.jpeg",
            "width": 800,
            "height": 800
        },
        "url": "https://www.getmaxim.ai/articles/author/kuldeep/",
        "sameAs": []
    },
    "headline": "AI Agent Registry: How Teams Discover and Govern Internal Agents",
    "url": "https://www.getmaxim.ai/articles/ai-agent-registry/",
    "datePublished": "2026-10-29T19:12:10.000Z",
    "dateModified": "2026-10-29T19:12:10.000Z",
    "image": {
        "@type": "ImageObject",
        "url": "https://storage.ghost.io/c/84/03/8403f2f6-141c-411a-8f55-a32d4291533e/content/images/size/w1200/2026/10/ai-agent-registry-how-teams-discover-and-govern-internal-age-bifrost-1920x1080.png",
        "width": 1200,
        "height": 675
    },
    "keywords": "Agent Gateway",
    "description": "An AI agent registry is the system of record for the agents a company runs, from identity and skills to endpoints, auth and who may call them. This guide covers discovery models, a field checklist, how it differs from an MCP registry, and how Bifrost governs registered A2A agents.",
    "mainEntityOfPage": "https://www.getmaxim.ai/articles/ai-agent-registry/"
}
```