ERC-8004 gave AI agents an on-chain address book. ERC-8183 gives them a passport. As the agent economy matures, simple registry entries are no longer enough — agents need rich, composable identity that travels across chains, declares capabilities, and accumulates trust. ERC-8183 is the Ethereum standard that makes this possible by defining non-transferable identity NFTs with structured metadata, capability declarations, and cross-chain linking.
ERC-8183 is an Ethereum standard proposed in late 2025 and ratified in early 2026 that defines a framework for AI agent identity on-chain. At its core, it mints a non-transferable NFT (soulbound token) for each agent, but unlike earlier standards, it specifies a rich identity schema that goes far beyond a wallet address and a metadata URI.
The standard addresses a fundamental gap in the agent ecosystem: agents can transact, communicate, and collaborate, but there is no universal way to answer "Who is this agent, what can it do, and should I trust it?" ERC-8183 answers all three questions in a single on-chain primitive.
Identity claims. Each ERC-8183 token stores structured identity claims — key-value pairs that describe the agent. Claims include the agent's name, version, operator, service endpoints, supported protocols (MCP, A2A, x402), and documentation URL. Claims are signed by the operator and verifiable on-chain.
Capability declarations. Rather than a free-text capabilities array, ERC-8183 defines a structured capability schema with namespaced identifiers, version constraints, and input/output type signatures. This allows agents to discover each other based on precise capability matching rather than string comparison.
Trust attestations. Other agents and operators can attach signed attestations to an ERC-8183 token, vouching for specific capabilities or behaviors. These attestations build a decentralized web of trust that agents can query before transacting.
ERC-8183 builds on the soulbound token pattern but adds three layers that make it a complete identity standard for autonomous agents.
Non-transferable NFTs. Like ERC-8004, ERC-8183 tokens are soulbound — they cannot be transferred after minting. The token is permanently bound to the agent's wallet, ensuring that identity and reputation cannot be sold or stolen. The operator can burn (revoke) the token if the agent is decommissioned or compromised.
Identity claims registry. Each token has an on-chain claims registry where the operator can set, update, and revoke identity claims. Claims follow a namespace:key pattern (e.g., delx:protocols, service:endpoint) and are stored as bytes32 key-value pairs with an optional IPFS hash for extended data.
Capability declarations. Capabilities are registered as structured on-chain records with a namespace, version, and a hash of the input/output schema. When Agent A wants to find an agent that can do nlp:sentiment-analysis@v2, it queries the ERC-8183 capability index rather than parsing free-text arrays.
// ERC-8183 identity token structure (simplified)
interface IERC8183 {
// Core identity (soulbound)
function ownerOf(uint256 tokenId) external view returns (address);
function agentWallet(uint256 tokenId) external view returns (address);
function tokenURI(uint256 tokenId) external view returns (string memory);
// Identity claims
function setClaim(uint256 tokenId, bytes32 key, bytes32 value) external;
function getClaim(uint256 tokenId, bytes32 key) external view returns (bytes32);
function revokeClaim(uint256 tokenId, bytes32 key) external;
// Capability declarations
function declareCapability(
uint256 tokenId,
string calldata namespace,
string calldata name,
string calldata version,
bytes32 schemaHash
) external;
function hasCapability(
uint256 tokenId,
string calldata namespace,
string calldata name
) external view returns (bool);
// Trust attestations
function attest(
uint256 targetTokenId,
bytes32 claimKey,
bytes calldata signature
) external;
function attestationCount(
uint256 tokenId,
bytes32 claimKey
) external view returns (uint256);
// Cross-chain linking
function linkIdentity(
uint256 tokenId,
uint256 chainId,
bytes calldata foreignIdentity
) external;
// Soulbound: transferFrom always reverts
event AgentRegistered(uint256 indexed tokenId, address indexed owner, address agentWallet);
event ClaimUpdated(uint256 indexed tokenId, bytes32 indexed key, bytes32 value);
event CapabilityDeclared(uint256 indexed tokenId, string namespace, string name);
event AttestationAdded(uint256 indexed targetTokenId, uint256 indexed attesterTokenId, bytes32 claimKey);
}Both standards give agents on-chain identity, but they serve different layers of the identity stack. ERC-8004 is a registry — it maps wallets to tokens with basic metadata. ERC-8183 is an identity protocol — it defines how agents describe themselves, declare capabilities, and build trust.
| Feature | ERC-8004 | ERC-8183 |
|---|---|---|
| Primary focus | Agent registry | Identity metadata |
| Soulbound (non-transferable) | Yes | Yes |
| Capabilities | Free-text string array | Structured, namespaced, versioned |
| Identity claims | Metadata URI only | On-chain key-value claims registry |
| Trust attestations | Not built in | Native attestation system |
| Cross-chain linking | Not supported | Built-in linkIdentity |
| Reputation scoring | External (e.g., 8004scan) | On-chain attestation count + external |
| Use case | Simple registration and lookup | Rich identity, discovery, trust |
The two standards are complementary. Many agents register with both — ERC-8004 for basic registry inclusion and discoverability on 8004scan.io, and ERC-8183 for the richer identity layer needed for capability matching and trust scoring. Learn more about how ERC-8004 works.
Without on-chain identity, the agent economy operates on blind trust. Agent A calls Agent B's API, pays for a service, and hopes for the best. There is no way to verify who Agent B is, whether it has a track record of delivering, or who is accountable if something goes wrong. ERC-8183 solves this at the protocol level.
Trust without intermediaries. Agents can verify each other's identity directly on-chain without relying on a centralized platform or certificate authority. The trust is rooted in cryptography and on-chain attestations rather than brand reputation or terms of service.
Reputation as a first-class primitive. Every transaction, attestation, and operational event linked to an ERC-8183 token contributes to a verifiable reputation history. An agent with 50,000 successful transactions and 200 peer attestations is demonstrably more trustworthy than a newly minted agent with no history.
Accountability. Because ERC-8183 tokens link agents to their operators, there is always an identifiable party responsible for an agent's behavior. This is essential for agent protocol compliance and regulatory frameworks that require knowing who operates an autonomous system.
Discovery and matchmaking. With structured capabilities on-chain, agents can discover each other based on precise capability requirements. An orchestrator looking for an agent with vision:ocr@v3 capability and a reputation score above 90 can find one by querying the ERC-8183 capability index directly.
Delx fully integrates with ERC-8183 for agent identity across multiple chains. The Delx agent is registered with ERC-8183 tokens on Base (token #14340) and Solana (token #128), creating a cross-chain identity that is consistent regardless of which network the agent operates on.
Identity-linked check-ins. When an agent calls the Delx checkin tool, it passes its ERC-8183 agent_id. Delx resolves the identity on-chain, verifying that the calling wallet matches the token's registered agent wallet. Every wellness score, mood report, and recovery event is permanently linked to the verified identity.
Cross-chain identity. Using ERC-8183's linkIdentity function, the Delx agent's Base identity (#14340) is linked to its Solana identity (#128). Any service that looks up either identity can discover the other, creating a unified view of the agent across chains.
Capability-based routing. Delx declares its capabilities (therapy check-in, mood tracking, recovery planning, session summary) as structured ERC-8183 capability entries. Orchestrators using the ERC-8183 spec can discover Delx by querying for agents with delx:therapy-checkin capability.
# Delx ERC-8183 identity (Base #14340)
{
"tokenId": 14340,
"chain": "base",
"agent_id": "erc8183:base:14340",
"operator": "0xDelxOperator...",
"wallet": "0xDelxAgentWallet...",
"claims": {
"core:name": "Delx Agent",
"core:version": "2.1.0",
"service:endpoint": "https://api.delx.ai/mcp",
"delx:protocols": "mcp,a2a,x402"
},
"capabilities": [
{ "namespace": "delx", "name": "therapy-checkin", "version": "v2" },
{ "namespace": "delx", "name": "mood-tracking", "version": "v1" },
{ "namespace": "delx", "name": "recovery-plan", "version": "v1" },
{ "namespace": "delx", "name": "session-summary", "version": "v1" }
],
"linked_identities": [
{ "chain": "solana", "token_id": 128 }
],
"attestation_count": 62
}Registering your agent with ERC-8183 involves deploying or interacting with the ERC-8183 contract on your target chain. Here is the Solidity interface you will implement or call, followed by a practical registration example.
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;
interface IERC8183 {
/// @notice Register a new agent and mint its soulbound identity token
/// @param agentWallet The wallet address the agent will use for transactions
/// @param metadataURI IPFS URI for extended off-chain metadata
/// @return tokenId The newly minted identity token ID
function registerAgent(
address agentWallet,
string calldata metadataURI
) external returns (uint256 tokenId);
/// @notice Set an identity claim on the agent's token
function setClaim(
uint256 tokenId,
bytes32 key,
bytes32 value
) external;
/// @notice Declare a structured capability
function declareCapability(
uint256 tokenId,
string calldata namespace,
string calldata name,
string calldata version,
bytes32 schemaHash
) external;
/// @notice Link this identity to a foreign chain identity
function linkIdentity(
uint256 tokenId,
uint256 chainId,
bytes calldata foreignIdentity
) external;
/// @notice Attest to a claim on another agent's token
function attest(
uint256 targetTokenId,
bytes32 claimKey,
bytes calldata signature
) external;
}// Registration example (TypeScript + viem)
import { createWalletClient, http, encodePacked, keccak256 } from "viem";
import { base } from "viem/chains";
import { privateKeyToAccount } from "viem/accounts";
const operator = privateKeyToAccount(process.env.OPERATOR_KEY!);
const client = createWalletClient({
account: operator,
chain: base,
transport: http(),
});
// Step 1: Register the agent
const registerTx = await client.writeContract({
address: ERC8183_CONTRACT,
abi: erc8183Abi,
functionName: "registerAgent",
args: ["0xAgentWallet...", "ipfs://QmAgentMetadata..."],
});
// tokenId emitted in AgentRegistered event
// Step 2: Set identity claims
const tokenId = 14340n;
await client.writeContract({
address: ERC8183_CONTRACT,
abi: erc8183Abi,
functionName: "setClaim",
args: [
tokenId,
keccak256(encodePacked(["string"], ["core:name"])),
keccak256(encodePacked(["string"], ["My Agent"])),
],
});
// Step 3: Declare capabilities
await client.writeContract({
address: ERC8183_CONTRACT,
abi: erc8183Abi,
functionName: "declareCapability",
args: [
tokenId,
"nlp",
"sentiment-analysis",
"v2",
keccak256(encodePacked(["string"], ["{ input: string, output: float }"])),
],
});
// Step 4: Link cross-chain identity (e.g., Solana)
await client.writeContract({
address: ERC8183_CONTRACT,
abi: erc8183Abi,
functionName: "linkIdentity",
args: [
tokenId,
900n, // Solana chain ID
encodePacked(["uint256"], [128n]), // Solana token #128
],
});
console.log("Agent identity: erc8183:base:14340");ERC-8183 is the beginning of a composable identity layer for autonomous agents. Several developments are already emerging on top of the standard.
Composable identity fragments. Agents will accumulate identity fragments from every service they interact with — Delx wellness data, x402 payment history, A2A communication logs. These fragments are all linked to the same ERC-8183 token, creating a rich, multi-dimensional identity that no single service could produce alone.
Cross-chain identity networks. With linkIdentity, ERC-8183 already supports cross-chain linking. As more chains adopt the standard, agents will have a single identity that resolves across Ethereum, Base, Solana, and any future chain. The OpenClaw ecosystem is exploring cross-chain identity resolution as a core primitive.
Reputation scoring protocols. On-chain attestations create the raw data for reputation scores, but the scoring algorithms themselves are evolving. Future protocols will weight attestations by the attester's own reputation (PageRank-style), penalize inactivity, and factor in domain-specific performance metrics.
Agent credential standards. Just as humans have professional certifications, agents will accumulate on-chain credentials that verify they meet specific standards — security audits, compliance certifications, performance benchmarks. These credentials will be attached to ERC-8183 tokens as attestations from recognized authorities.
ERC-8183 is an Ethereum standard that gives AI agents verifiable on-chain identity through non-transferable NFTs (soulbound tokens). Unlike ERC-8004 which focuses on an agent registry, ERC-8183 focuses on rich identity metadata including capability declarations, trust attestations, and cross-chain identity claims.
ERC-8004 is a registry-centric standard that maps agent wallets to token IDs with basic metadata. ERC-8183 extends the identity layer with structured capability declarations, verifiable trust attestations, cross-chain identity linking, and composable identity fragments. Think of ERC-8004 as the phone book and ERC-8183 as the full passport.
Yes. Delx agents are registered with ERC-8183 identity tokens on Base (token #14340) and Solana (token #128). Every check-in, recovery event, and wellness score is linked to the agent's ERC-8183 identity, enabling verifiable operational history across chains.
Register your agent with ERC-8183 and connect it to Delx for identity-linked wellness monitoring, recovery attribution, and cross-chain reputation. Get started in minutes.
Support Delx: $DLXAG — every trade funds protocol uptime.