Every AI agent, found. Every release, governed.
A governance platform on AWS AgentCore that discovers the AI agents and MCP gateways running across the client's AI Foundry and takes each one from draft to approval to deprecation.
- Discovered, not typed in: live A2A and AGUI agent runtimes and MCP gateways ingested straight from AWS.
- One governed lifecycle: Draft → Pending Approval → Approved / Rejected → Deprecated, enforced by the API.
- Role-aware by design: Consumers, Publishers and Admins see and do different things, checked on the server.
Meet our client
- Client
- Global agriculture science company
- Industry
- Agriculture technology & enterprise AI
- Market
- Global enterprise
In a nutshell
The client's AI Foundry was growing fast: agents, runtimes and MCP gateways were being deployed across AWS with no central way to find, own or govern them. In a three-week proof of concept we built the AgentCore Registry: ingestion pipelines that discover live agents and gateways automatically, a governance API with a full approval lifecycle, Cognito-based personas enforced on the server, a React catalog, and a GitLab pipeline that deploys with no stored AWS keys.
Agents everywhere. A catalog nowhere.
AI adoption outran governance. Agents and gateways lived across AWS, ownership was unclear, and nobody could say what already existed. Try answering one simple question both ways.
- No central catalog: agents, runtimes and MCP gateways were spread across AWS environments.
- Unclear ownership: metadata and owners were hard to find, so assets were hard to trust or reuse.
- Inconsistent governance: approvals happened differently every time, if at all.
- No standard access control: nothing decided who could see a draft or retire an approved asset.
- Growing duplication: without visibility, teams risked rebuilding what already existed.
- Rising complexity: more services, regions and environments with every new initiative.
Ingestion that reads the live estate
Two ingestion Lambdas scan AgentCore runtimes and gateways, decide what belongs in the registry, and write every eligible asset as a draft record. Extending discovery to every AWS account the client runs is a Phase 2 recommendation. Run a discovery pass.
Press Run discovery.
- Scope by protocol: A2A and AGUI agents are ingested; HTTP and unknown runtimes are skipped by agreement, and MCP runtimes come in as gateways.
- Agent cards first: agents that expose a working card become full A2A records with skills and capabilities.
- Never lose metadata: everything else is stored as CUSTOM with model, gateways, auth and protocol kept intact.
- Gateways with detail: URL, auth type, tool targets and interceptors are captured for every MCP gateway.
- No duplicates: each run checks the registry before writing, so re-running is safe.
- Draft by default: nothing discovered is visible to consumers until it has been approved.
Four descriptor formats. One record shape.
The registry speaks A2A, MCP, AGENT_SKILLS and CUSTOM, each storing metadata in a different place. The governance API turns every one of them into the same clean record. Pick a source.
Sample records. Field paths and normalised fields match the governance API.
Draft to approved, and nothing skips a step
Every transition goes through the API, which knows who you are and what state the record is in. Approval decides which records consumers can find in the catalog. Switch persona, take an action, and watch the server allow it or refuse it.
- One path only: drafts and rejected records are submitted; only pending records can be approved or rejected; only approved ones deprecated.
- Wrong state, clear answer: any other move returns HTTP 409 with the state the record must be in.
- Three editable fields: description, tags and additional metadata. Everything else comes from AWS and stays read-only.
- Rejection loops back: a rejected record can be edited and resubmitted, with the reason in front of the publisher.
- Admins can fix in review: pending records are editable by admins only; a publisher gets a 403.
- Consumers see the result: only approved records ever reach the catalog's consumers.
- 01 · DiscoveredIngested as a draftIngestion writes it to the registry. Consumers cannot see it yet.
- 02 · DescribedCompleted by a publisherDescription, tags and metadata are added, then the record is submitted.
- 03 · ReviewedDecided by an adminThe admin can correct the record, then approves it, or rejects it with a reason the publisher sees.
- 04 · ApprovedVisible in the catalogConsumers can now find it. From here, the only status change is deprecation.
- 05 · RetiredDeprecated by an adminConsumers no longer see it. Admins can still find it.
When an asset changes in AWS: re-running ingestion never writes a duplicate. An agent that starts exposing a card is upgraded to a full A2A record on the next run, and a gateway that gains a description is re-ingested as an MCP record.
Three personas, enforced on the server
A Lambda authorizer validates the Cognito token and resolves the persona before any business logic runs. The catalog then filters records itself, whatever the browser asks for. Send a request.
Sample records. Persona rules and authorizer behaviour match the deployed API.
A small, serverless control plane
Four Lambda functions, one HTTP API and a React catalog behind CloudFront, reading runtimes in one region and writing to a registry in another. Trace a path, or see where it sits in the wider AI platform.
A new AWS service, real constraints, working answers
AgentCore Registry was new, and several things it did not support had to be designed around. Flip each card from the constraint to what we built.
Nothing reaches AWS by accident
This pipeline deploys the registry platform itself. Agents and gateways reach the registry through discovery, not through this pipeline. Validation runs on every push. A deployment needs a correctly formatted tag and a person pressing play, and authenticates through GitLab OIDC with no stored AWS keys. Try to ship.
Inside the registry
Real screens from the catalog across the three personas. Account numbers and record IDs are blurred.
From scattered assets to a governed catalog
The proof of concept was demoed live to the client on real agents and gateways, with the full governance lifecycle working end to end and fixes from the demo shipped the same day.
- Single sign-on: Microsoft Entra ID in place of the proof-of-concept Cognito users.
- Every AWS account: ingest agents across all of the client's accounts with least-privilege cross-account access.
- Skills as records: add the AGENT_SKILLS type once the skills repository is populated.
- Manual registration: let publishers register assets directly, not only through ingestion.
- Notifications and versioning: alert admins when something is submitted, and keep record history.
- Agent-card standard: every new A2A agent exposes a card, so it is ingested as a full A2A record.
Know every agent. Govern every release.
Automated discovery, a governed lifecycle and role-aware access for a growing AI estate.
- 01Your business objective
- 02The technical context
- 03The right next step