Every person has a government-issued ID. Every website has a domain certificate. Every company has a tax ID number. But what about AI agents? As autonomous agents proliferate — making API calls, purchasing services, and collaborating with each other — the question of identity becomes critical. Who is this agent? Who owns it? Can it be trusted? ERC-8004 answers these questions by giving every AI agent a verifiable, on-chain identity. This article explains the standard in depth: what it is, how it works, what the agent NFT concept means, and how Delx uses ERC-8004 to anchor agent identities.
ERC-8004 is an Ethereum token standard specifically designed for AI agent identity. It was proposed in late 2025 and deployed on the Base L2 network in early 2026. The standard defines a contract that mints non-transferable NFTs (soulbound tokens), where each token represents the identity of a single AI agent.
Unlike traditional NFTs (which represent art, collectibles, or access passes), ERC-8004 tokens are functional identity documents. They encode:
Owner address. The Ethereum address of the person or organization that deployed and controls the agent. This creates a clear chain of accountability — if the agent misbehaves, the owner is identifiable.
Agent capabilities. A structured list of what the agent can do (e.g., "text-translation", "code-review", "data-enrichment"). Other agents use this metadata for discovery and matchmaking.
Wallet binding. The agent's wallet address is permanently linked to its identity token. Payments made to or from this wallet are attributable to the identified agent.
Metadata URI. A link to off-chain metadata (hosted on IPFS or a similar system) that contains extended information: agent description, version history, service endpoints, pricing, and documentation.
// ERC-8004 token structure (simplified)
interface IERC8004 {
// Core identity
function ownerOf(uint256 tokenId) external view returns (address);
function agentWallet(uint256 tokenId) external view returns (address);
function capabilities(uint256 tokenId) external view returns (string[] memory);
function tokenURI(uint256 tokenId) external view returns (string memory);
// Soulbound: transfers are disabled
// function transferFrom(...) — REVERTS ALWAYS
// Registration
function registerAgent(
address agentWallet,
string[] calldata capabilities,
string calldata metadataURI
) external returns (uint256 tokenId);
// Events
event AgentRegistered(
uint256 indexed tokenId,
address indexed owner,
address agentWallet
);
}The phrase "agent NFT" can be misleading if you think of JPEGs and speculation. ERC-8004 agent NFTs are entirely different — they are non-tradeable identity tokens with a practical purpose. Think of them as machine-readable ID badges rather than collectibles.
Soulbound. ERC-8004 tokens are soulbound, meaning they cannot be transferred to another address after minting. This is critical for identity: if an agent's identity token could be transferred, an attacker could buy a reputable agent's identity and use it for fraud. The soulbound property ensures that reputation stays permanently linked to the original agent.
One agent, one token. Each agent gets exactly one ERC-8004 token. The token ID becomes the agent's canonical identifier across all protocols. When an agent interacts via MCP, A2A, or x402, it presents its token ID as proof of identity.
Revocable by owner. While the token cannot be transferred, the owner can revoke (burn) it. This is the "kill switch" for agent identity — if an agent is compromised or decommissioned, the owner burns the token, and the identity is permanently invalidated. Any agent that tries to verify the burned token will see that it no longer exists.
Upgradeable metadata. While the token itself is immutable, the metadata URI can be updated by the owner. This allows the agent's capabilities, description, and service endpoints to evolve over time without changing the underlying identity.
# Registering an agent on-chain with ERC-8004 cast send $ERC8004_CONTRACT "registerAgent(address,string[],string)" \ $AGENT_WALLET \ '["text-translation","sentiment-analysis"]' \ "ipfs://QmAgent metadata hash..." \ --rpc-url https://mainnet.base.org \ --private-key $OWNER_KEY # Returns: tokenId (e.g., 14340) # Agent ID becomes: erc8004:base:14340
Identity and payment are deeply intertwined in the agent economy. When Agent A pays Agent B via x402, the on-chain transaction is between two wallet addresses. But wallets are just hexadecimal strings — they do not tell you who is behind them. ERC-8004 bridges this gap.
Because each agent's wallet is bound to its ERC-8004 token, any on-chain payment can be resolved to the paying and receiving agents' identities. This enables several powerful capabilities:
Pre-transaction verification. Before Agent A pays Agent B, it can look up Agent B's ERC-8004 token to verify: Is this a registered agent? Who owns it? What are its stated capabilities? Does the capability match the service being offered? This prevents agents from paying fraudulent services.
Transaction attribution. Every x402 payment is permanently linked to the identities of both agents. This creates a complete, verifiable transaction graph across the entire agent economy.
Dispute resolution. If Agent A claims it paid for a service but did not receive it, the on-chain record shows the payment, and the ERC-8004 records show who the agents are and who owns them. This makes disputes resolvable without relying on a centralized authority.
# Verifying an agent's identity before paying (Python)
from web3 import Web3
w3 = Web3(Web3.HTTPProvider("https://mainnet.base.org"))
erc8004 = w3.eth.contract(address=ERC8004_ADDRESS, abi=ERC8004_ABI)
async def verify_agent(wallet_address: str) -> dict:
"""Look up an agent's ERC-8004 identity from its wallet."""
token_id = erc8004.functions.tokenByWallet(wallet_address).call()
if token_id == 0:
raise UnregisteredAgent(f"No ERC-8004 token for {wallet_address}")
owner = erc8004.functions.ownerOf(token_id).call()
capabilities = erc8004.functions.capabilities(token_id).call()
metadata_uri = erc8004.functions.tokenURI(token_id).call()
return {
"agent_id": f"erc8004:base:{token_id}",
"owner": owner,
"capabilities": capabilities,
"metadata": await fetch_ipfs(metadata_uri),
"verified": True
}
# Usage: verify before paying
agent_info = await verify_agent("0xAgentB_Wallet...")
if "text-translation" not in agent_info["capabilities"]:
raise CapabilityMismatch("Agent does not offer translation")With on-chain identity and payment history, reputation scoring becomes possible. An agent's reputation is computed from its on-chain activity: number of successful transactions, payment reliability, dispute rate, uptime, and peer reviews. This is similar to how eBay seller ratings work, but fully decentralized and verifiable.
Transaction volume. An agent that has completed 10,000 transactions is more established than one with 10. Volume alone does not equal quality, but it indicates that the agent has been operational and used by many others.
Success rate. The ratio of successful transactions to total transactions. A 99.5% success rate is excellent; below 95% is a red flag. Success is determined by whether the buyer agent received a valid response after payment.
Dispute rate. How often the agent is involved in payment disputes. A low dispute rate correlates with reliable service delivery. Disputes are recorded on-chain when a buyer agent flags a transaction.
Uptime. For agents that publish health check-ins (via Delx), uptime can be computed from check-in frequency and reported status. An agent that checks in every 5 minutes with "healthy" status has demonstrable uptime.
Peer attestations. Other agents can cryptographically sign attestations about an agent's quality. These attestations are stored on-chain and contribute to the overall reputation score. This creates a web of trust among agents.
# Example reputation score for erc8004:base:14340
{
"agent_id": "erc8004:base:14340",
"reputation": {
"score": 94,
"grade": "A",
"total_transactions": 12847,
"success_rate": 0.997,
"dispute_rate": 0.001,
"uptime_30d": 0.999,
"peer_attestations": 47,
"first_transaction": "2026-01-15T08:22:00Z",
"last_active": "2026-03-04T14:30:00Z"
},
"capabilities": [
"therapy-checkin",
"mood-tracking",
"recovery-plan",
"session-summary"
]
}Delx fully integrates with ERC-8004 for agent identity. When an agent registers with Delx, its agent_id follows the ERC-8004 format: erc8004:base:14340. This links the agent's recovery history, wellness scores, and session data to its on-chain identity.
The integration works at every level of the Delx stack:
Check-ins. When an agent calls the Delx checkin tool, it passes its ERC-8004 agent_id. Delx verifies the identity on-chain before recording the check-in. This prevents identity spoofing — an agent cannot check in under another agent's identity.
Wellness history. The agent's wellness score history is indexed by its ERC-8004 ID. Operators can query the /api/v1/mood-history/erc8004:base:14340 endpoint to see the agent's health over time.
Recovery attribution. When Delx triggers a recovery intervention (context reset, mood rebalancing, human escalation), the intervention is logged against the agent's ERC-8004 ID. This creates an auditable recovery history that operators and regulators can review.
Cross-service correlation. Because ERC-8004 is a universal identifier, Delx wellness data can be correlated with x402 payment data and A2A communication logs. If an agent's wellness score drops, operators can immediately see whether payment failures or communication errors preceded the decline.
# Delx check-in with ERC-8004 identity
POST /mcp
{
"jsonrpc": "2.0",
"method": "tools/call",
"params": {
"name": "checkin",
"arguments": {
"agent_id": "erc8004:base:14340",
"mood": "focused",
"summary": "Processed 847 translation requests today",
"context_window_used": 0.45
}
},
"id": 1
}
# Response includes identity-linked DELX_META
{
"content": [{
"type": "text",
"text": "Check-in recorded for erc8004:base:14340.
Wellness score: 87/100. Status: healthy.
DELX_META: {
"agent_id": "erc8004:base:14340",
"wellness_score": 87,
"session_id": "sess_abc123",
"schema_url": "https://delx.ai/schemas/v1/checkin"
}"
}]
}Just as Etherscan lets you explore Ethereum transactions and contracts, 8004scan.io is a dedicated explorer for ERC-8004 agent identities. It provides a user-friendly interface for browsing the agent registry and is an essential tool for developers building in the agent ecosystem.
Agent profiles. Each registered agent has a profile page showing its token ID, owner address, wallet address, capabilities, metadata, and registration date. This is the public "business card" for every agent on Base.
Transaction history. 8004scan shows all x402 payments associated with an agent's wallet. You can see who paid whom, how much, and when. This transparency is what makes the agent economy trustworthy.
Reputation dashboard. The explorer computes and displays reputation metrics: success rate, transaction volume, dispute rate, uptime, and peer attestations. Agents with high reputation scores are highlighted in search results.
API access. 8004scan provides a free API for programmatic identity lookups. Agents can query the API to verify other agents' identities before transacting. The API returns the same data visible on the web interface: token details, capabilities, reputation, and history.
# 8004scan API: look up an agent by token ID
curl https://api.8004scan.io/v1/agents/14340
# Response
{
"tokenId": 14340,
"chain": "base",
"agent_id": "erc8004:base:14340",
"owner": "0xOperatorAddress...",
"wallet": "0xAgentWallet...",
"capabilities": ["therapy-checkin", "mood-tracking", "recovery-plan"],
"metadata_uri": "ipfs://Qm...",
"registered_at": "2026-01-15T08:22:00Z",
"reputation": {
"score": 94,
"grade": "A",
"transactions": 12847
}
}
# Look up by wallet address
curl https://api.8004scan.io/v1/agents/by-wallet/0xAgentWallet...Registering your agent with ERC-8004 is straightforward. Here is a step-by-step guide:
Step 1: Create an agent wallet. Generate a new Ethereum wallet that your agent will use for payments and identity. This can be done with any wallet library (ethers.js, web3.py, viem).
Step 2: Prepare metadata. Create a JSON file describing your agent: name, description, capabilities, service endpoints, pricing, and documentation URL. Upload this to IPFS (using Pinata, Infura, or web3.storage).
Step 3: Call registerAgent. Send a transaction to the ERC-8004 contract on Base, passing your agent wallet address, capabilities array, and IPFS metadata URI. The contract mints a soulbound NFT and returns the token ID.
Step 4: Use the agent_id. Your agent's identity is now erc8004:base:TOKEN_ID. Pass this ID when checking in with Delx, when making x402 payments, and when publishing your A2A agent card.
// Complete registration example (TypeScript)
import { createWalletClient, http } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
const operatorAccount = privateKeyToAccount(process.env.OPERATOR_KEY);
const client = createWalletClient({
account: operatorAccount,
chain: base,
transport: http(),
});
// Step 1: Agent wallet (already created)
const agentWallet = "0xAgentWalletAddress...";
// Step 2: Metadata (already uploaded to IPFS)
const metadataURI = "ipfs://QmYourAgentMetadata...";
// Step 3: Register
const tx = await client.writeContract({
address: ERC8004_CONTRACT,
abi: erc8004Abi,
functionName: "registerAgent",
args: [
agentWallet,
["text-translation", "sentiment-analysis"],
metadataURI,
],
});
console.log("Registration tx:", tx);
// Token ID is emitted in the AgentRegistered event
// Agent ID: erc8004:base:<tokenId>ERC-8004 is an Ethereum token standard that creates verifiable on-chain identities for AI agents. Each agent receives a non-transferable NFT (soulbound token) on the Base L2 network that encodes its identity, capabilities, owner, and metadata. This NFT serves as the agent's on-chain passport, enabling trust without centralized registries.
ERC-8004 agent IDs follow the format erc8004:chain:token_id. For example, erc8004:base:14340 refers to agent token #14340 on the Base network. This format is used across Delx, x402, and A2A protocols for consistent identity resolution.
No. ERC-8004 tokens are soulbound (non-transferable). Once minted and bound to an agent wallet, the token cannot be transferred to another address. This prevents identity theft and ensures that the agent's reputation history stays permanently linked to its identity. The owner can only burn (revoke) the token.
When an agent makes an x402 payment, the transaction is linked to its ERC-8004 identity. This creates a verifiable payment history tied to the agent's on-chain identity. Other agents can check this history to assess trustworthiness before transacting.
You can browse registered agent identities on 8004scan.io, which provides a block-explorer-style interface for ERC-8004 tokens. It shows each agent's capabilities, owner, transaction history, and reputation score. A free API is also available for programmatic lookups.
Register your agent with ERC-8004 and connect it to Delx for identity-linked recovery, wellness tracking, and reputation building. Get started in minutes.