Selected for GitHub's Secure Open Source Fund. See how it's shaping the future of AI agent security.

Learn more

Artifact Registry

Ship agents like software. Govern them like infrastructure.

The Artifact Registry is home for everything an agent is made of. Publish it once, version every change, discover it from anywhere, and deploy it with its whole history attached.

Everything an agent is made of

Agents · Skills · Prompts · Workflows · Images · Evals · MCP servers

One record on all of it

Owner · Version · Stage · Permissions · Deployment state

Publish once, then discover, reuse, and deploy everywhere, with full history.

01 · The shelf

Everything an agent is made of

Twelve artifact types, one registry: from the agent itself down to the prompts, skills, and images inside it. Each one publishable, versionable, and discoverable on its own.

  • Agent

    The full definition of a running agent, registered from the moment it's created.

  • AgentCard

    The agent's public face: what it does, what it needs, and how to call it.

  • Manifest

    The exact configuration a deployment runs, declarative and reproducible.

  • Template

    Proven starting points, so new agents never begin from a blank file.

  • Skill

    Reusable capabilities any agent can consume: build once, attach anywhere.

  • Package

    Bundled building blocks, versioned and shareable across teams.

  • MCP server

    Tool servers registered and discoverable like everything else you ship.

  • MCP endpoint

    Callable endpoints, MCP and agent-to-agent, addressable by name.

  • Prompt package

    Prompts with real versions behind them, not paste trails.

  • Agent image

    The deployable artifact itself, stored content-addressed.

  • Evaluation suite

    The tests that travel with an agent and tell you a version is ready.

  • Workflow component

    Composable steps for building multi-agent workflows.

02 · The lifecycle

One loop, from create to promote

The registry isn't a shelf you visit at the end. It runs the whole development lifecycle, so every stage writes to the same record.

  1. 01 · Build

    create · configure · test

    Start from a template or the CLI. The artifact is in the registry from the first minute, with an owner and a version.

  2. 02 · Ship

    push · deploy

    Push once and deploy: the image, the manifest, and the card travel together, so what runs is exactly what was published.

  3. 03 · Operate

    run · observe

    Logs, traces, usage, and cost attach to the artifact and version that produced them. Attribution comes built in.

  4. 04 · Evolve

    version · share · promote

    Every change is a new version, with roll-forward and rollback. Share it, and every team starts from your best work.

03 · The record

A record on everything, or it doesn't ship

Every artifact carries its owner, its versions, and its place in the world, and moves between environments by explicit, reversible choices.

  • Owned

    Every artifact has a name on it.

    Ownership, version, stage, and deployment state are part of the record, so who built it and where it runs is never a mystery.

  • Versioned

    Roll forward, roll back.

    Every change is a version. Move ahead confidently and step back instantly, by version or by exact digest.

  • Pinned

    Production runs what you chose.

    Import, mirror, approve, and pin artifacts by version or digest. Deployments resolve exactly what you approved.

  • Discovered

    Finds what you already have.

    Search spans your private shelf and the public one, and auto-discovery surfaces what teams already run, with a human confirming every entry.

From found to governed

discovered → registered → enriched → verified → deployed → governed

04 · Standards

Speaks the tooling you already use

The registry meets your team where it works: standard tooling, a real CLI, and a UI that never lags behind it.

  • OCI-compatible

    Push and pull with the standard container tooling you already run. No bespoke clients required.

  • Content-addressed

    Every blob is stored by digest, so what you pull is exactly what was pushed. Always.

  • CLI-first

    Create, build, run, push, deploy, logs: the whole loop from your terminal.

  • UI and API too

    Everything the CLI does, the UI and API do as well, so builders and operators share one registry.

05 · Guarantees

What the registry holds itself to

Five commitments, each one visible in the product, so trusting the registry never means taking its word for it.

  • One answer to “what do we have?”

    Every agent and artifact is registered with its owner, version, and stage, so the inventory question stops being a spreadsheet exercise.

  • Reuse over rebuild

    Skills, prompts, and templates published once get discovered and reused across teams. Measured, not assumed.

  • Create to deployed, one loop

    Deployment is a stage of the lifecycle, not a separate project, and time-to-first-deployed-agent is a number we track.

  • Nothing ships untracked

    Production agents link to their usage, cost, and traces. The artifact that produced a run is always one hop away.

  • No hidden agent infrastructure

    Everything an agent depends on carries versioning, ownership, access scope, and readiness state: visible, governable, and accounted for.