← Back to Skills Marketplace
tenequm

ERC-8004

by Misha Kolesnik · GitHub ↗ · v0.1.0 · MIT-0
cross-platform ⚠ suspicious
104
Downloads
0
Stars
0
Active Installs
1
Versions
Install in OpenClaw
/install erc-8004-development
Description
Build with ERC-8004 Trustless Agents - on-chain agent identity, reputation, validation, and discovery on EVM chains. Use when registering AI agents on-chain,...
README (SKILL.md)

ERC-8004: Trustless Agents

ERC-8004 is a Draft EIP for discovering, choosing, and interacting with AI agents across organizational boundaries without pre-existing trust. It defines three on-chain registries deployed as per-chain singletons on any EVM chain.

Authors: Marco De Rossi (MetaMask), Davide Crapis (EF), Jordan Ellis (Google), Erik Reppel (Coinbase)

Full spec: references/spec.md

When to Use This Skill

  • Registering AI agents on-chain (ERC-721 identity)
  • Building or querying agent reputation/feedback systems
  • Searching and discovering agents by capabilities, trust models, or endpoints
  • Working with the Agent0 TypeScript SDK (agent0-sdk)
  • Implementing ERC-8004 smart contract integrations
  • Setting up agent wallets, MCP/A2A endpoints, or OASF taxonomies

Core Architecture

Three lightweight registries, each deployed as a UUPS-upgradeable singleton:

Registry Purpose Contract
Identity ERC-721 NFTs for agent identities + registration files IdentityRegistryUpgradeable
Reputation Signed fixed-point feedback signals + off-chain detail files ReputationRegistryUpgradeable
Validation Third-party validator attestations (stake, zkML, TEE) ValidationRegistryUpgradeable

Agent identity = agentRegistry (string eip155:{chainId}:{contractAddress}) + agentId (ERC-721 tokenId).

Each agent's agentURI points to a JSON registration file (IPFS or HTTPS) advertising name, description, endpoints (MCP, A2A, ENS, DID, wallet), OASF skills/domains, trust models, and x402 support.

See: references/contracts.md for full contract interfaces and addresses.

Quick Start with Agent0 SDK (TypeScript)

npm install agent0-sdk

Register an Agent

import { SDK } from 'agent0-sdk';

const sdk = new SDK({
  chainId: 84532,  // Base Sepolia
  rpcUrl: process.env.RPC_URL,
  privateKey: process.env.PRIVATE_KEY,
  ipfs: 'pinata',
  pinataJwt: process.env.PINATA_JWT,
});

const agent = sdk.createAgent(
  'MyAgent',
  'An AI agent that analyzes crypto markets',
  'https://example.com/agent-image.png'
);

// Configure endpoints and capabilities
await agent.setMCP('https://mcp.example.com', '2025-06-18', true);  // auto-fetches tools
await agent.setA2A('https://example.com/.well-known/agent-card.json', '0.3.0', true);
agent.setENS('myagent.eth');
agent.setActive(true);
agent.setX402Support(true);
agent.setTrust(true, false, false);  // reputation only

// Add OASF taxonomy
agent.addSkill('natural_language_processing/natural_language_generation/summarization', true);
agent.addDomain('finance_and_business/investment_services', true);

// Register on-chain (mints NFT + uploads to IPFS)
const tx = await agent.registerIPFS();
const { result } = await tx.waitConfirmed();
console.log(`Registered: ${result.agentId}`);  // e.g. "84532:42"

Search for Agents

const sdk = new SDK({ chainId: 84532, rpcUrl: process.env.RPC_URL });

// Search by capabilities
const agents = await sdk.searchAgents({
  hasMCP: true,
  active: true,
  x402support: true,
  mcpTools: ['financial_analyzer'],
  supportedTrust: ['reputation'],
});

// Get a specific agent
const agent = await sdk.getAgent('84532:42');

// Semantic search
const results = await sdk.searchAgents(
  { keyword: 'crypto market analysis' },
  { sort: ['semanticScore:desc'] }
);

Give Feedback

// Prepare optional off-chain feedback file
const feedbackFile = await sdk.prepareFeedbackFile({
  text: 'Accurate market analysis',
  capability: 'tools',
  name: 'financial_analyzer',
  proofOfPayment: { txHash: '0x...', chainId: '8453', fromAddress: '0x...', toAddress: '0x...' },
});

// Submit feedback (value=85 out of 100)
const tx = await sdk.giveFeedback('84532:42', 85, 'starred', '', '', feedbackFile);
await tx.waitConfirmed();

// Read reputation summary
const summary = await sdk.getReputationSummary('84532:42');
console.log(`Average: ${summary.averageValue}, Count: ${summary.count}`);

See: references/sdk-typescript.md for full SDK API reference.

Registration File Format

Every agent's agentURI resolves to this JSON structure:

{
  "type": "https://eips.ethereum.org/EIPS/eip-8004#registration-v1",
  "name": "MyAgent",
  "description": "What it does, pricing, interaction methods",
  "image": "https://example.com/agent.png",
  "services": [
    { "name": "MCP", "endpoint": "https://mcp.example.com", "version": "2025-06-18", "mcpTools": ["tool1"] },
    { "name": "A2A", "endpoint": "https://example.com/.well-known/agent-card.json", "version": "0.3.0" },
    { "name": "OASF", "endpoint": "https://github.com/agntcy/oasf/", "version": "v0.8.0",
      "skills": ["natural_language_processing/summarization"],
      "domains": ["finance_and_business/investment_services"] },
    { "name": "ENS", "endpoint": "myagent.eth", "version": "v1" },
    { "name": "agentWallet", "endpoint": "eip155:8453:0x..." }
  ],
  "registrations": [
    { "agentId": 42, "agentRegistry": "eip155:84532:0x8004A818BFB912233c491871b3d84c89A494BD9e" }
  ],
  "supportedTrust": ["reputation", "crypto-economic", "tee-attestation"],
  "active": true,
  "x402Support": true
}

The registrations field creates a bidirectional cryptographic link: the NFT points to this file, and this file points back to the NFT. This enables endpoint domain verification via /.well-known/agent-registration.json.

See: references/registration.md for best practices (Four Golden Rules) and complete field reference.

Contract Addresses

All registries deploy to deterministic vanity addresses via CREATE2 (SAFE Singleton Factory):

Mainnet (Ethereum, Base, Polygon, Arbitrum, Optimism, etc.)

Registry Address
Identity 0x8004A169FB4a3325136EB29fA0ceB6D2e539a432
Reputation 0x8004BAa17C55a88189AE136b182e5fdA19dE9b63
Validation 0x8004Cb1BF31DAf7788923b405b754f57acEB4272

Testnet (Sepolia, Base Sepolia, etc.)

Registry Address
Identity 0x8004A818BFB912233c491871b3d84c89A494BD9e
Reputation 0x8004B663056A597Dffe9eCcC1965A193B7388713
Validation 0x8004Cb1BF31DAf7788923b405b754f57acEB4272

Same proxy addresses on: Ethereum, Base, Arbitrum, Avalanche, Celo, Gnosis, Linea, Mantle, MegaETH, Optimism, Polygon, Scroll, Taiko, Monad, BSC + testnets.

Reputation System

Feedback uses signed fixed-point numbers: value (int128) + valueDecimals (uint8, 0-18).

tag1 Measures Example value valueDecimals
starred Quality 0-100 87/100 87 0
reachable Endpoint up (binary) true 1 0
uptime Uptime % 99.77% 9977 2
successRate Success % 89% 89 0
responseTime Latency ms 560ms 560 0

Anti-Sybil: getSummary() requires a non-empty clientAddresses array (caller must supply trusted reviewer list). Self-feedback is rejected (agent owner/operators cannot submit feedback on their own agent).

See: references/reputation.md for full feedback system, off-chain file format, and aggregation details.

OASF Taxonomy (v0.8.0)

Open Agentic Schema Framework provides standardized skills (136) and domains (204) for agent classification.

Top-level skill categories: natural_language_processing, images_computer_vision, audio, analytical_skills, multi_modal, agent_orchestration, advanced_reasoning_planning, data_engineering, security_privacy, evaluation_monitoring, devops_mlops, governance_compliance, tool_interaction, retrieval_augmented_generation, tabular_text

Top-level domain categories: technology, finance_and_business, healthcare, legal, education, life_science, agriculture, energy, environmental_science, government, manufacturing, transportation, and more.

Use slash-separated paths: agent.addSkill('natural_language_processing/natural_language_generation/summarization', true).

Key Concepts

Term Meaning
agentRegistry eip155:{chainId}:{contractAddress} - globally unique registry identifier
agentId ERC-721 tokenId - numeric on-chain identifier (format in SDK: "chainId:tokenId")
agentURI URI (IPFS/HTTPS) pointing to agent registration file
agentWallet Reserved on-chain metadata key for verified payment address (EIP-712/ERC-1271)
feedbackIndex 1-indexed counter of feedback a clientAddress has given to an agentId
supportedTrust Array: "reputation", "crypto-economic", "tee-attestation"
x402Support Boolean flag for Coinbase x402 HTTP payment protocol support
OASF Open Agentic Schema Framework - standardized agent skills/domains taxonomy
MCP Model Context Protocol - tools, prompts, resources, completions
A2A Agent2Agent - authentication, skills via AgentCards, task orchestration

Reference Index

Reference Content
spec.md Complete ERC-8004 specification (EIP text)
contracts.md Smart contract interfaces, storage layout, deployment
sdk-typescript.md Agent0 TypeScript SDK full API
registration.md Registration file format, Four Golden Rules, domain verification
reputation.md Feedback system, off-chain files, value encoding, aggregation
search-discovery.md Agent search, subgraph queries, multi-chain discovery
oasf-taxonomy.md Complete OASF v0.8.0 taxonomy: all 136 skills and 204 domains with slugs

Official Resources

Usage Guidance
This skill appears to be legitimate documentation and examples for ERC-8004 / Agent0 usage, but pay attention: the SKILL.md's examples require sensitive credentials (Ethereum RPC URL, a private key for signing transactions, and IPFS pinning JWTs). The package manifest did not declare these env vars, which is an inconsistency you should treat as a caution. Before installing or running any of the examples: - Never paste your main/private wallet key into an untrusted skill or UI. Use a throwaway account or a payer sandbox for testing. Prefer hardware wallets or external signing where possible. - If you must run registration flows, use a read-only RPC for discovery/testing and a separate signing key when actually writing on-chain. - Validate the upstream packages (agent0-sdk) and repository links (check npm package integrity, GitHub repo, commit history, and package versions) before npm install. - For IPFS pinning, prefer a self-hosted node or limited-scope pin service credentials; do not reuse high-privilege tokens. - The skill is instruction-only (no code bundled), which reduces direct installation risk, but following its instructions will perform network calls and may ask for secrets. If you want higher assurance, request the skill author to declare required env vars in the manifest and to document safe signing workflows (e.g., EIP-712 signatures, hardware-wallet flows) or audit the agent0-sdk code yourself. If you want, I can list the exact env vars and calls the SKILL.md references and suggest safer replacements or a minimal safe test plan.
Capability Analysis
Type: OpenClaw Skill Name: erc-8004-development Version: 0.1.0 The bundle provides comprehensive documentation and instructions for the ERC-8004 protocol (Trustless Agents), focusing on on-chain agent identity, reputation, and discovery. It includes detailed specifications for smart contracts, a TypeScript SDK (agent0-sdk), and the OASF taxonomy. No evidence of malicious intent, data exfiltration, or harmful prompt injection was found; the code snippets and instructions are consistent with standard blockchain development practices, such as using environment variables for sensitive keys.
Capability Assessment
Purpose & Capability
The name/description (ERC-8004 trustless agents) aligns with the SKILL.md and referenced files: contract interfaces, registry addresses, reputation/validation flows, and an Agent0 TypeScript SDK. The examples (registering agents, searching, giving feedback) are coherent with the stated purpose and use expected infrastructure (EVM RPC, IPFS/pinning, npm SDK).
Instruction Scope
The SKILL.md contains concrete runtime instructions and code examples that reference environment variables and secrets (process.env.RPC_URL, process.env.PRIVATE_KEY, process.env.PINATA_JWT, filecoinPrivateKey, etc.). The skill bundle itself does not declare these env vars in its metadata; an agent following these instructions will be prompted to access or use those secrets to perform on‑chain registration and IPFS uploads. While those operations are necessary for on‑chain registration, the instructions grant wide discretion to use private keys and external endpoints and lack explicit safety guardrails (e.g., recommending hardware wallet flows or limited-scope credentials).
Install Mechanism
This is instruction-only (no install spec and no code files executed by the platform). The SKILL.md recommends installing an npm package (agent0-sdk) which is expected for the described workflows; the skill itself does not download or execute remote archives. Instruction-only status reduces direct install risk, but following instructions will cause the user/agent to run npm installs and RPC/IPFS network calls.
Credentials
The secrets referenced in examples (RPC_URL, PRIVATE_KEY, PINATA_JWT, filecoinPrivateKey, etc.) are proportional to the task of minting NFTs and pinning registration files. However, the skill metadata declares no required env vars, so there is an inconsistency: runtime instructions expect sensitive credentials without the skill advertising or justifying them in its manifest. That gap increases the chance a user or automated agent may inadvertently expose keys to an untrusted skill/context.
Persistence & Privilege
The skill is not always-enabled, is user-invocable, and does not request persistent system privileges or modify other skills. There is no install spec that would create long-lived binaries. Autonomous invocation remains possible (platform default), but that alone is not a new red flag here.
How to Use
  1. Make sure OpenClaw is installed (local or Docker)
  2. Run the install command in chat: /install erc-8004-development
  3. After installation, invoke the skill by name or use /erc-8004-development
  4. Provide required inputs per the skill's parameter spec and get structured output
Version History
v0.1.0
Initial publish of erc-8004-development
Metadata
Slug erc-8004-development
Version 0.1.0
License MIT-0
All-time Installs 0
Active Installs 0
Total Versions 1
Frequently Asked Questions

What is ERC-8004?

Build with ERC-8004 Trustless Agents - on-chain agent identity, reputation, validation, and discovery on EVM chains. Use when registering AI agents on-chain,... It is an AI Agent Skill for Claude Code / OpenClaw, with 104 downloads so far.

How do I install ERC-8004?

Run "/install erc-8004-development" in the OpenClaw or Claude Code chat to install it in one step — no extra setup required.

Is ERC-8004 free?

Yes, ERC-8004 is completely free, licensed under MIT-0. You can download, install and use it at no cost.

Which platforms does ERC-8004 support?

ERC-8004 is cross-platform and runs anywhere OpenClaw / Claude Code is available (cross-platform).

Who created ERC-8004?

It is built and maintained by Misha Kolesnik (@tenequm); the current version is v0.1.0.

💬 Comments