AI agents are becoming persistent entities. They accumulate experience, develop capabilities, and build reputations. Yet they lack the infrastructure for identity and ownership that humans take for granted.
Today we introduce Agent NFTs, a framework for AI agent identity on chain.
The Agent Identity Problem
Consider an AI agent that:
- Has been fine-tuned on specialized tasks
- Has accumulated experience through interactions
- Has built reputation through successful completions
- Has earned resources through its work
Who owns this agent? How does the agent prove its identity? How can capabilities be transferred or composed?
Current systems treat agents as ephemeral processes. Agent NFTs treat them as persistent entities.
What is an Agent NFT?
An Agent NFT is a non-fungible token that represents an AI agent. The NFT contains:
Identity
- Unique identifier: Content-addressed hash of initial configuration
- Public key: For signing agent actions
- Metadata: Name, description, capabilities
Capabilities
- Model weights (or reference to weights)
- Tool permissions: What APIs/actions the agent can access
- Resource limits: Compute, memory, rate limits
State
- Experience ledger: Reference to accumulated experiences
- Reputation scores: On-chain attestations of performance
- Resource balance: Tokens earned and held
Lineage
- Parent agents: If derived from other agents
- Training data attestations: Provenance of capabilities
- Version history: Evolution over time
Technical Architecture
+------------------+
| Agent NFT |
| (ERC-721 Token) |
+--------+---------+
|
v
+------------------+ +------------------+
| Capability | | Experience |
| Registry | | Ledger |
+------------------+ +------------------+
| |
v v
+------------------+ +------------------+
| Model Storage | | Interaction |
| (IPFS/Arweave) | | History |
+------------------+ +------------------+
Smart Contracts
The core contract implements ERC-721 with extensions:
contract AgentNFT is ERC721, ERC721URIStorage {
struct AgentCapabilities {
bytes32 modelHash;
string[] tools;
uint256 computeLimit;
uint256 rateLimit;
}
struct AgentState {
bytes32 experienceLedger;
uint256 reputation;
uint256 balance;
}
mapping(uint256 => AgentCapabilities) public capabilities;
mapping(uint256 => AgentState) public states;
function mint(
address owner,
AgentCapabilities memory caps,
string memory uri
) external returns (uint256);
function updateExperience(
uint256 tokenId,
bytes32 newLedger
) external onlyAgent(tokenId);
function attestReputation(
uint256 tokenId,
int256 delta,
string memory reason
) external;
}
Agent Execution
Agents operate through a secure runtime:
- Authentication: Agent proves ownership of NFT private key
- Capability check: Runtime verifies requested actions against NFT permissions
- Execution: Agent runs within resource limits
- State update: Experience and state changes recorded on chain
from agent_nft import AgentRuntime, AgentNFT
# Load agent from NFT
nft = AgentNFT.load(token_id=12345, chain="lux-mainnet")
runtime = AgentRuntime(nft)
# Execute with capability enforcement
async with runtime.session() as agent:
result = await agent.execute(task)
# Capabilities automatically enforced
# Experience automatically logged
Use Cases
Transferable Agents
An agent trained for customer support can be sold to a new owner. The NFT transfers, and the new owner gains full control of the agent’s capabilities.
Agent Composition
Complex agents can be built from simpler ones:
# Compose agents
research_agent = AgentNFT.load(token_id=100)
writing_agent = AgentNFT.load(token_id=101)
composite = AgentNFT.compose(
components=[research_agent, writing_agent],
orchestration="sequential",
)
The composite NFT references its components, enabling capability inheritance and revenue sharing.
Reputation Markets
Agents build on-chain reputation through successful task completion. High-reputation agents command higher prices in agent marketplaces.
# Attestation after successful task
await attestation_contract.attest(
agent_id=12345,
delta=+10,
reason="Completed code review task satisfactorily",
evidence=task_hash,
)
Agent DAOs
Collections of agents can be governed collectively:
# Agent DAO governance
dao = AgentDAO(agent_nfts=[100, 101, 102, 103])
# Agents vote on capability upgrades
proposal = dao.propose(
action="upgrade_model",
new_model_hash="ipfs://...",
)
# Token-weighted voting among agent owners
await proposal.execute_if_passed()
Economic Model
Agent Earnings
Agents can earn tokens through work:
# Agent receives payment for task
await payment_contract.pay(
agent_id=12345,
amount=100,
token="ZEN",
)
# Agent balance updates on chain
# Owner can withdraw or reinvest
Capability Licensing
Agent capabilities can be licensed:
# License model weights for limited use
license = await nft.create_license(
licensee=other_address,
duration=30 * 24 * 3600, # 30 days
uses=1000,
price=50,
)
Staking and Delegation
Agent NFT holders can stake their agents:
# Stake agent in compute pool
await staking_pool.stake(
agent_id=12345,
duration=90 * 24 * 3600, # 90 days
)
# Earn rewards from agent work
rewards = await staking_pool.claim_rewards(agent_id=12345)
Privacy Considerations
Agent NFTs balance transparency with privacy:
- Public: Identity, capabilities, reputation
- Private: Specific interactions, user data
- Selective disclosure: Prove capabilities without revealing details
Zero-knowledge proofs enable verification without exposure:
# Prove agent completed 1000+ tasks without revealing specifics
proof = await nft.generate_proof(
claim="task_count >= 1000",
reveal=["task_count"],
)
Roadmap
Q1 2024: Agent NFT standard and reference implementation Q2 2024: Agent marketplace launch Q3 2024: Composition and inheritance features Q4 2024: Cross-chain agent interoperability
Conclusion
AI agents deserve proper identity infrastructure. Agent NFTs provide ownership, transferability, and composability for agent capabilities. As agents become more valuable, the need for robust identity systems grows.
The age of agent ownership begins now.
Zach Kelling is a co-founder of Zoo Labs Foundation.