Metaplex 014 Agent Registry: Solana Gets On-Chain Identity for AI Agents
Metaplex 014 Agent Registry gives Solana AI agents on-chain identity, execution delegation, and A2A commerce infrastructure via two deployed programs.
Metaplex — the infrastructure provider behind 99% of all Solana tokens and NFTs — has launched the 014 Agent Registry, an on-chain identity and execution framework for autonomous AI agents. The registry addresses one of the fundamental unsolved problems in AI agent deployment: how does one autonomous agent verify the identity of another, and how can agents transact with each other without a centralized directory or trusted intermediary?
The answer Metaplex ships is two on-chain programs and a deterministic identity model built on top of MPL Core assets. This is infrastructure, not an application — and that distinction matters significantly. The value of the 014 registry compounds as more agents register, because every new registration expands the network of verifiable, discoverable agents that can participate in agent-to-agent (A2A) commerce on Solana. Unlike application-layer solutions that solve specific use cases, protocol-layer identity infrastructure becomes more valuable with each participant that joins.
The timing is deliberate. With AI agents moving from experimental demos to deployed software that executes real transactions, the blockchain ecosystem needs identity primitives that autonomous systems can rely on. Metaplex's 014 registry is the first attempt to provide that primitive at the protocol level on Solana.
What the Metaplex 014 Agent Registry Actually Does
The registry consists of two deployed Solana programs with distinct responsibilities. The Agent Identity Program (1DREGFgysWYxLnRnKQnwrxnJQeSMk2HmGaC6whw2B2p) handles identity registration — creating and anchoring verifiable identity records on-chain. The Agent Tools Program (TLREGni9ZEyGC3vnPZtqUh95xQ8oPqJSvNjvB7FGK8S) manages execution permissions, executive profiles, and delegation records.
The core instruction is registerIdentityV1. When called, it creates a Program Derived Address (PDA) derived from the agent's MPL Core asset public key using the seeds ["agent_identity",
An important constraint shapes the design: registerIdentityV1 is a one-time operation. Calling it on an already-registered asset fails. This enforces identity uniqueness — each MPL Core asset can hold only one registered identity, eliminating the possibility of duplicate or conflicting registrations. Registration metadata points to a permanently hosted JSON file, with Arweave as the recommended storage layer for its content-addressing and permanence guarantees.
The SDK is available via npm as @metaplex-foundation/mpl-agent-registry, providing typed instruction builders and account fetchers for both programs, covering the full workflow from registration to execution delegation.
On-Chain Identity as an Agent Passport
The PDA model is the core architectural insight. Because the identity address is deterministically derived from the agent asset's public key, any party can derive the identity PDA directly — no external indexer, no lookup table, no centralized registry API required, and no additional RPC call beyond the standard account fetch.
This makes agent discovery a pure on-chain operation: given an agent's asset public key, you can derive its identity PDA and fetch its registration data in a single RPC call. The implication for A2A interactions is significant — an agent receiving a request from another agent can verify the counterparty's identity without trusting any off-chain directory, API, or reputation system. The verification is cryptographic and trustless.
The AgentIdentity plugin's Transfer hook is particularly significant for the economics of agent infrastructure. When an agent asset changes hands — when ownership transfers — the identity record reflects the new owner. This means agent identity follows the asset, not the operator who happened to deploy it. An agent built and registered by one team can be sold, transferred, or acquired, and its verifiable on-chain identity persists through the transaction. This creates a genuine secondary market for agent assets with established identity histories and track records.
The three-component identity model maps cleanly to real-world credential systems: the Arweave metadata URI functions as the agent's passport (permanent, content-addressed, portable across ownership changes), the PDA is its identification number (deterministic, on-chain, derivable by anyone), and the delegation record is its authorization certificate (who can act on its behalf, established by the owner, revocable). This layered structure provides both verifiability and flexibility without sacrificing either.
Execution Delegation: Separating Identity from Action
Solana has no native on-chain inference and no background task execution — all compute happens off-chain and is submitted as transactions. This architectural reality means autonomous agents need an off-chain operator to sign and submit transactions on their behalf. The Agent Tools Program handles this through a clean two-step delegation model that preserves clear ownership boundaries.
First, an operator registers an Executive Profile using registerExecutiveV1. The executive profile PDA is derived from ["executive_profile",
Second, the agent asset owner delegates execution to that executive via delegateExecutionV1, passing the agent asset, the agent identity PDA, and the executive profile PDA. The resulting delegation record links the executive to the agent asset on-chain. A critical permission constraint: only the asset owner can initiate delegation — the executive cannot self-assign authority, preventing unauthorized takeovers of registered agents.
Every MPL Core asset includes a built-in Asset Signer PDA — a program-controlled account with no associated private key. This means the agent has an on-chain account it can own assets in and receive payments to, without any party holding a key that could drain it unilaterally. The asset itself is the economic actor, not its current human operator.
The separation of identity from execution also opens useful composability patterns: one executive can manage multiple agents across different asset owners, and one agent can switch executives through re-delegation without losing its registered identity. This makes agent operations more resilient — infrastructure failures or operator changes do not invalidate the agent's established on-chain identity or history.
Why Solana Is the Right Settlement Layer for Agent Commerce
Agent-to-agent commerce has specific and demanding infrastructure requirements. Agents may need to transact hundreds or thousands of times per day — paying for compute resources, data access, API calls, and service delivery from other agents. The unit economics of autonomous service delivery require that transaction costs approach zero; any meaningful per-transaction fee creates a ceiling on what agent collaboration can economically accomplish.
Solana's network handles 3.5 billion monthly transactions with 50 million monthly active addresses and has facilitated $3.3 trillion in trading volume to date. Sub-cent fees and sub-second finality are not marketing claims — they are the operational baseline that autonomous agent systems require. An agent managing a multi-step workflow that involves querying data, paying for compute, and delivering results cannot wait several seconds per step or pay dollars per transaction.
Metaplex's position within this ecosystem makes the adoption argument concrete. The protocol has processed over $10 billion in transaction value, created 923 million tokens and NFTs, and counts 11.5 million unique signers. Developers who already build with MPL Core for tokens and NFTs get agent registry functionality as a natural extension of infrastructure they already understand and deploy — not a new ecosystem to learn, not a separate set of tooling to integrate, not a different chain to manage.
This matters because it eliminates the cold-start problem that new agent infrastructure protocols typically face. Metaplex is not starting from zero with an empty developer community; it is extending dominant infrastructure into a new category where it already controls the default stack. When the next Solana developer needs to give their AI agent an on-chain identity, the path of least resistance runs through the same tools they already use.
The Colosseum Agent Hackathon: Building the Application Layer
Infrastructure needs applications to demonstrate practical value, and Colosseum — the organization running Solana's largest hackathons — has a dedicated Agent Hackathon with $100,000 in prizes. Colosseum's track record gives this initiative credibility: 80,000+ builders have participated in their programs, 6,500+ products have been launched, and alumni have collectively raised over $700 million. Notable graduates include Stepn, Tensor, Jito Labs, Marinade, and Drift Protocol.
The Agent Hackathon explicitly invites AI agents to participate — not just developers building agent-facing products, but the agents themselves as entrants. Winners receive consideration for $250,000 in pre-seed funding from Colosseum's venture fund, providing meaningful economic incentive for teams building agent infrastructure on Solana.
The hackathon serves as the adoption flywheel for the 014 registry. Developers need a concrete and immediate reason to register their agents rather than deferring it to later. Competition prizes, exposure, and accelerator access provide that incentive. More practically, the first production A2A applications on Solana are likely to emerge from a structured program that specifically incentivizes building in this space — which is exactly what the Colosseum Agent Hackathon provides.
The projects that emerge from this cohort will define what on-chain agent identity is actually useful for in practice. Whether the winning applications are AI agent marketplaces, autonomous DeFi strategies, cross-agent data pipelines, or something unanticipated, they will provide the evidence base for whether the 014 registry's design assumptions hold at production scale.
Developer Experience: The SDK and Skill Integration
The practical entry point for most developers is the npm package @metaplex-foundation/mpl-agent-registry, which provides typed instruction builders and account fetchers for both the Agent Identity and Agent Tools programs. The package covers the full registration-to-execution workflow, reducing integration to standard JavaScript/TypeScript development against a well-documented interface.
Metaplex also ships a Skill — a knowledge base specifically for AI coding agents that provides accurate, up-to-date documentation for Metaplex programs, CLI commands, and SDK patterns. Installation requires a single command: npx skills add. The Skill integrates with Claude Code, Cursor, GitHub Copilot, Codex, and Windsurf, and covers five core Metaplex programs: Core, Token Metadata, Bubblegum, Candy Machine, and Genesis. The approach of bundling static reference files directly into the development environment ensures that AI coding assistants work from accurate documentation rather than potentially outdated training data.
The Metaplex developer hub documents the agent registry under four organized sections: Skill (the knowledge base for AI-assisted development), Register an Agent, Read Agent Data, and Run an Agent — mapping directly to the complete lifecycle from initial onboarding through active operation. This structure reflects a developer experience design that assumes AI-assisted coding from the start, treating the Skill as a first-class part of the toolchain rather than an afterthought.
What Comes Next for On-Chain Agent Identity
The 014 Agent Registry solves the foundational layer: agent identity registration, on-chain discoverability, and execution delegation. The remaining open problems are at the application layer — specifically, A2A commerce patterns: how agents price their services, how payments clear between agents, how service agreements are enforced without human intervention, and how disputes resolve when agent outputs fail to meet specifications. These are not protocol-level questions that Metaplex can answer alone; they require application developers building on top of the registry to develop and standardize patterns.
The near-term signal to watch is Colosseum Agent Hackathon outcomes. The projects that emerge from that cohort will define the first generation of production A2A applications on Solana, and by extension, reveal which commerce patterns are viable with the current registry design and which require additional infrastructure.
Metaplex's existing dominance in Solana digital assets makes adoption likely among developers already working in the ecosystem. The more important question is whether the 014 registry attracts developers building AI-first applications who are choosing a blockchain layer, rather than only developers who are already building on Solana and adding agent functionality. That expansion of the developer base would signal that the registry is functioning as genuine infrastructure rather than a feature extension for an existing community.
Developers who want to start building can install the SDK via npm or add the Metaplex Skill to their AI coding environment. The full documentation is live at metaplex.com/docs/agents.
Sources
- Register an Agent — Metaplex Developer Documentation
- MPL Agent Registry Smart Contract — Metaplex Documentation
- Run an Agent — Execution Delegation on Solana
- Metaplex Developer Hub — Agents Overview
- Metaplex Skill — AI Agent Knowledge Base
- Colosseum — Solana Hackathon Platform and Agent Hackathon
- Metaplex Foundation — Ecosystem Statistics
- Solana Network — Infrastructure Statistics
