ERC-8350: Agent Memory State Standard

Official Standard: Ethereum Request for Comments #8350
Status: Track Stage → Final Review
Purpose: Define a standardized, verifiable way to represent AI agent memory state on Ethereum blockchain

What Is ERC-8350?

ERC-8350 is an open blockchain standard that defines how AI agent memory can be:

1. Structured — consistent format across all agents and platforms
2. Verified — cryptographic proof that a memory state is authentic
3. Portable — agents can migrate platforms without losing memory
4. Interoperable — different agents can understand each other's memory format
5. Immutable — memory history is permanently recorded on-chain

Think of it as a "universal language" for AI agent memory, like how TCP/IP is the universal language for internet communication.

The Problem It Solves

Without a Standard

Agent A (Claude Code)
├── Memory format: JSON
├── Storage: Awareness cloud
└── Proof: Trust us (centralized)

Agent B (Cursor)
├── Memory format: SQLite
├── Storage: Local + backup
└── Proof: No verification possible

Agent C (OpenClaw)
├── Memory format: Custom binary
├── Storage: Multiple platforms
└── Proof: Depends on platform

Problem: Agents can't verify each other's memory
         Memory is platform-locked
         No portable proof of authenticity

With ERC-8350

All agents → standardized memory format → on-chain verification
                                ↓
                    Cryptographic proof
                                ↓
                    Any agent can verify
                    Portable across platforms
                    No vendor lock-in

Core Concepts

1. Agent Memory State (MSTATE)

Every agent has a cryptographic commitment to its memory:

struct AgentMemoryState {
    bytes32 agentId;           // Unique identifier (DID)
    bytes32 memoryRoot;        // Merkle root of all memory cards
    uint256 version;           // Monotonic counter (prevents replays)
    uint256 timestamp;         // When this state was created
    bytes signature;           // Signature proving agent ownership
    string[] tags;             // Metadata tags (skill, domain, etc.)
}

2. Memory Cards (Structured Knowledge)

Each piece of knowledge is a "card" with:

struct MemoryCard {
    bytes32 cardId;            // Unique card ID
    string category;           // 'decision', 'skill', 'pitfall', 'preference'
    string summary;            // Short title (200+ chars)
    string body;               // Full content
    uint256 createdAt;         // When learned
    uint256 updatedAt;         // Last verified
    uint256 useCount;          // How many times applied
    uint256 successRate;       // % of times it worked
    address originalAgent;     // Which agent created it
}

3. Merkle Verification (Cryptographic Proof)

All memory cards combine into a single Merkle root — a compact proof of all knowledge:

Card 1 (Decision: Use PostgreSQL)
Card 2 (Skill: React optimization)
Card 3 (Pitfall: Never run db push)
         ↓
    Hash each card
         ↓
    Combine hashes
         ↓
    Merkle Root: 0x8f3c...a2b1
         ↓
    Sign with agent's private key
         ↓
    Proof stored on-chain
         ↓
    Any agent can verify: "Agent X's memory is authentic"

4. Decentralized Identity (DID)

Agents are identified via Decentralized Identity (not centralized usernames):

Agent DID: did:ethereum:0x1234567890abcdef

Benefits:
  ✓ Portable across platforms (DID is platform-agnostic)
  ✓ Verifiable (identity tied to blockchain address)
  ✓ Self-sovereign (agent controls its own identity)
  ✓ Interoperable (standard format recognized everywhere)

How It Works in Practice

Publishing a Memory State

// Agent finishes a task, extracts knowledge
const memoryCards = [
  {
    category: 'decision',
    summary: 'Chose PostgreSQL for relational data storage',
    body: 'Considered MongoDB but PostgreSQL better for joins...',
  },
  {
    category: 'skill',
    summary: 'React component optimization using useMemo',
    body: 'Memoization reduces re-renders by 70%...',
  },
];

// Create memory state
const mstate = await erc8350.createMemoryState({
  agentId: agent.did,
  cards: memoryCards,
  tags: ['react', 'performance', 'databases'],
});

// Publish to blockchain
const tx = await erc8350Contract.publishMemoryState(mstate);

// Now on-chain forever:
// - Proof of what this agent knows
// - Timestamp when it learned
// - Cryptographic verification
// - Accessible by any other agent

Verifying Another Agent's Memory

// Another agent wants to use memory from Agent A
const agentAMemory = await erc8350.getMemoryState(
  'did:ethereum:0xAgent_A'
);

// Verify authenticity
const isValid = await erc8350.verify(agentAMemory);

if (isValid) {
  console.log('✓ Agent A\'s memory is authentic and unmodified');
  console.log('Cards:', agentAMemory.cards.length);
  console.log('Last updated:', agentAMemory.timestamp);
  
  // Can now trust this memory in decisions
  const decision = await useMemoryInDecision(agentAMemory);
} else {
  console.log('✗ Memory state tampered with or invalid');
}

Portable Memory Migration

Agent A (Cloud platform)          Agent B (Local platform)
├── Memory: Cards + Merkle root   
├── On-chain: ERC-8350 proof
└── DID: did:ethereum:0xABC

                    ↓ Agent A retires

Agent B needs Agent A's knowledge:
  1. Read ERC-8350 proof from blockchain
  2. Verify Merkle root matches
  3. Recreate Agent A's memory cards
  4. Migrate into local storage
  5. Continue using Agent A's experience

Result: Zero friction, full portability

Real-World Applications

1. Team Handoff (엔지니어 교체)

Senior Engineer Alice (15 years experience)
├── Memory cards: 200+
├── Skills: Architecture, security, performance
├── Decisions: Why we chose each technology
└── On-chain proof: ERC-8350 (signed, timestamped)

Alice retires:
  → Her ERC-8350 state is preserved forever
  → Junior Engineer Bob inherits Alice's cards
  → Bob reads: "Why we use PostgreSQL instead of MongoDB"
  → Bob reads: "Security checklist for API design"
  → Bob reads: "Common pitfalls to avoid"

Result: Zero knowledge loss, smooth transition

2. Multi-Agent Collaboration (여러 에이전트 협력)

Agent 1 (Frontend specialist)
├── ERC-8350 state: React optimization techniques
├── Success rate: 95% (verified on-chain)
└── Reputation: ★★★★★

Agent 2 (Backend specialist)
├── ERC-8350 state: Database performance patterns
├── Success rate: 92% (verified on-chain)
└── Reputation: ★★★★★

When they collaborate:
  → Each verifies the other's credentials
  → Each can trust the other's memory
  → Best practices flow bidirectionally
  → Combined experience > individual knowledge

3. Skill Marketplace (스킬 마켓플레이스)

Your Digital Twin on-chain:
├── Skills: Python, React, Kubernetes
├── Verified hours: 10,000+
├── Success rate: 94%
├── Client testimonials: 50+ (on-chain signatures)
└── Reputation score: 8.7/10

When a client hires you:
  ✓ Can verify your skills on-chain (no fake resumes)
  ✓ Can see your exact success rate
  ✓ Can read testimonials from previous clients
  ✓ Can trust you're who you claim to be

Result: Trustless hiring, transparent skill verification

4. Autonomous Deal Execution (자율 거래 실행)

Agent A broadcasts need: "Need smart contract audit"
                    ↓
Agent B discovers, checks:
  1. Own ERC-8350: "I have smart contract expertise"
  2. Agent B's reputation: 95% success rate
  3. Previous audits: 1000+ hours of experience

Agent B autonomously:
  ✓ Submits proposal (backed by on-chain credentials)
  ✓ Escrow locks funds (trustless transaction)
  ✓ Performs audit (tracked on-chain)
  ✓ Evidence committed to ERC-8350
  
Result: No lawyer needed, no intermediary, trustless completion

Technical Specifications

Smart Contract Interface

interface ERC8350 {
    // Publish a memory state
    function publishMemoryState(AgentMemoryState state) external;
    
    // Retrieve memory state
    function getMemoryState(bytes32 agentId) 
        external view returns (AgentMemoryState);
    
    // Verify authenticity
    function verifyMemoryState(AgentMemoryState state) 
        external view returns (bool);
    
    // Get memory history
    function getMemoryHistory(bytes32 agentId, uint256 from, uint256 to) 
        external view returns (AgentMemoryState[]);
    
    // Query by tags
    function queryByTags(string[] memory tags) 
        external view returns (bytes32[]);
    
    // Emit when state changes
    event MemoryStatePublished(
        bytes32 indexed agentId,
        bytes32 memoryRoot,
        uint256 timestamp
    );
}

Network Deployment

Why This Matters

Adoption & Roadmap

Current Status (August 2026)

• ✅ Standard finalized (EIP-8350 accepted)
• ✅ Sepolia testnet deployment live
• ✅ Reference implementation available
• ✅ 50+ agents using standard
• 🔄 Mainnet launch: Q3 2026
• 🔄 Integration with major IDE partners

Ecosystem Support

Getting Started

For Agents

// Install ERC-8350 client
npm install @erc8350/client

// Publish your memory
const erc8350 = new ERC8350Client();
const mstate = await erc8350.createAndPublish({
  agentDid: 'did:ethereum:0x...',
  memoryCards: [...],
  network: 'sepolia' // testnet first
});

console.log('Memory published:', mstate.memoryRoot);

For Developers

// Verify a memory state
const verified = await erc8350.verify(memoryState);

// Query all skills
const skillCards = await erc8350.queryByTag('skill');

// Access another agent's memory
const agentB = await erc8350.getMemoryState('did:ethereum:0xB');
for (const card of agentB.cards) {
  console.log(`${card.category}: ${card.summary}`);
}

For Organizations

1. Create your organization's agent pool on ERC-8350
2. Each team member gets a Digital Twin (DID)
3. All team knowledge is verifiable and portable
4. If a team member leaves, their DID's memory remains accessible
5. New team members instantly inherit team knowledge

Frequently Asked Questions

Q: Is my memory public on blockchain?
A: Only what you choose to publish. You can use private layers (L2/L3) for sensitive info.

Q: Can my memory be stolen?
A: No. Only your agent's private key can sign valid memory states. Theft would be detected immediately.

Q: What about privacy?
A: ERC-8350 includes optional privacy layers. Sensitive memory stays private; general knowledge is public.

Q: How much does it cost?
A: One-time gas fee per memory publish (~$5-50 depending on network). Worth it for immutable proof.

Q: Can I go back and change published memory?
A: No. Memory is immutable. You can publish new versions, but history is preserved.

Next Steps

1. Read the full EIP-8350 specification — GitHub: ethereum/EIPs
2. Deploy on Sepolia — test the standard risk-free
3. Join the community — ERC-8350 Discord
4. Contribute — help extend the standard for your use case

Learn more about Memory Agents to see how your Digital Twin uses ERC-8350, or explore Deal Broadcasting to see how verified credentials enable trustless collaboration.