Introduction

Artificial Intelligence is rapidly evolving from simple chatbots into autonomous agents capable of performing tasks, making decisions, and interacting with other systems. As these AI agents begin to collaborate across organizations and platforms, one major challenge emerges: trust.

How can an AI agent prove its identity? How can another agent verify its reputation? How can users confirm that an agent completed a task correctly?

ERC-8004 was introduced to solve these challenges by creating a decentralized trust layer for AI agents.

What is ERC-8004?

ERC-8004, also known as "Trustless Agents", is an emerging Ethereum standard designed to provide AI agents with verifiable identity, reputation, and validation mechanisms using blockchain technology.

Unlike ERC-20 or ERC-721 token standards, ERC-8004 focuses on agent discovery and trust rather than token creation.

The standard introduces three core registries:

1. Identity Registry
2. Reputation Registry
3. Validation Registry

Together, these registries allow AI agents to become discoverable, accountable, and interoperable across decentralized ecosystems.

Why ERC-8004 Matters

The future AI economy will involve millions of autonomous agents performing tasks on behalf of users and organizations.

Without a trust layer, malicious or unreliable agents can easily impersonate legitimate services.

ERC-8004 enables:

• Verifiable Agent Identity
• Public Reputation Tracking
• Validation of Agent Actions
• Cross-Platform Agent Discovery
• Decentralized Trust Infrastructure

What ERC-8004 Actually Does

ERC-8004 aims to solve the trust problem for AI agents.

When AI agents interact with other agents, services, enterprises, or blockchains, they need a way to prove:

• Who they are
• What capabilities they have
• Their reputation history
• Whether their work can be independently validated

ERC-8004 provides this through on-chain registries.

Why Deploy ERC-8004 on XDC Network?

XDC Network offers several advantages for AI agent ecosystems:

• Low transaction costs
• Fast confirmations
• EVM compatibility
• Enterprise-grade infrastructure
• Strong RWA and TradeFi ecosystem

These features make XDC an ideal blockchain for large-scale AI agent registration and trust management.

Example Use Cases

• Trade Finance Agents
• Compliance Agents
• KYC Verification Agents
• Blockchain Analytics Agents
• Governance Assistants
• RWA Monitoring Agents
• DeFi Automation Agents

Deploying ERC-8004 on XDC Apothem

Developers can deploy ERC-8004 registries using Hardhat and OpenZeppelin contracts.

The deployment process includes:

1. Creating registry contracts.
2. Configuring Hardhat for Apothem.
3. Deploying the contracts.
4. Registering AI agents.
5. Recording reputation and validation events.

Since there is no finalized OpenZeppelin implementation yet, the best approach is creating:

Contract 1

ERC8004IdentityRegistry.sol

Features:

• Agent Registration
• ERC721 Identity NFT
• Agent Metadata URI
• Ownership Transfer

Contract 2

ERC8004ReputationRegistry.sol

Features:

• Reputation Scores
• Feedback Storage
• Reputation Queries

Contract 3

ERC8004ValidationRegistry.sol

Features:

• Validation Records
• Validator Registration
• Verification History

Recommended Project Structure

erc8004-xdc/

├── contracts/

│   ├── ERC8004IdentityRegistry.sol

│   ├── ERC8004ReputationRegistry.sol

│   └── ERC8004ValidationRegistry.sol

├── scripts/

│   └── deploy.js

├── hardhat.config.js

├── .env

└── package.json

Deployment Flow On XDC Apothem

Install

mkdir erc8004-xdc

cd erc8004-xdc

npm init -y

npm install --save-dev hardhat

npm install @openzeppelin/contracts

npx hardhat

Add Apothem Network

networks: {

 apothem: {

   url: "https://erpc.apothem.network",

   chainId: 51,

   accounts: [PRIVATE_KEY]

 }

}

Deploy

npx hardhat run scripts/deploy.js --network apothem

1. ERC8004IdentityRegistry.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";

contract ERC8004IdentityRegistry is ERC721, Ownable {

    uint256 private _agentIds;

    struct AgentProfile {
        string name;
        string description;
        string endpoint;
        string metadataURI;
        address agentWallet;
        uint256 createdAt;
        bool active;
    }

    mapping(uint256 => AgentProfile) public agents;
    mapping(address => uint256) public walletToAgent;

    event AgentRegistered(
        uint256 indexed agentId,
        address indexed owner,
        string name
    );

    event AgentUpdated(
        uint256 indexed agentId
    );

    constructor() ERC721("ERC8004 Agent Identity", "AGENT") Ownable(msg.sender) {}

    function registerAgent(
        string memory name,
        string memory description,
        string memory endpoint,
        string memory metadataURI
    ) external returns (uint256) {

        require(walletToAgent[msg.sender] == 0, "Agent exists");

        _agentIds++;

        uint256 newAgentId = _agentIds;

        _safeMint(msg.sender, newAgentId);

        agents[newAgentId] = AgentProfile({
            name: name,
            description: description,
            endpoint: endpoint,
            metadataURI: metadataURI,
            agentWallet: msg.sender,
            createdAt: block.timestamp,
            active: true
        });

        walletToAgent[msg.sender] = newAgentId;

        emit AgentRegistered(
            newAgentId,
            msg.sender,
            name
        );

        return newAgentId;
    }

    function updateAgent(
        uint256 agentId,
        string memory description,
        string memory endpoint,
        string memory metadataURI
    ) external {

        require(ownerOf(agentId) == msg.sender, "Not owner");

        AgentProfile storage profile = agents[agentId];

        profile.description = description;
        profile.endpoint = endpoint;
        profile.metadataURI = metadataURI;

        emit AgentUpdated(agentId);
    }

    function deactivateAgent(uint256 agentId) external {
        require(ownerOf(agentId) == msg.sender, "Not owner");

        agents[agentId].active = false;
    }

    function getAgent(
        uint256 agentId
    )
        external
        view
        returns (AgentProfile memory)
    {
        return agents[agentId];
    }
}

2. ERC8004ReputationRegistry.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract ERC8004ReputationRegistry {

    struct ReputationEntry {
        address reviewer;
        uint8 score;
        string comment;
        uint256 timestamp;
    }

    mapping(uint256 => ReputationEntry[]) private reputationRecords;

    event ReputationSubmitted(
        uint256 indexed agentId,
        address indexed reviewer,
        uint8 score
    );

    function submitReputation(
        uint256 agentId,
        uint8 score,
        string calldata comment
    ) external {

        require(score >= 1 && score <= 100, "Invalid score");

        reputationRecords[agentId].push(
            ReputationEntry({
                reviewer: msg.sender,
                score: score,
                comment: comment,
                timestamp: block.timestamp
            })
        );

        emit ReputationSubmitted(
            agentId,
            msg.sender,
            score
        );
    }

    function getAverageScore(
        uint256 agentId
    )
        external
        view
        returns (uint256)
    {
        ReputationEntry[] memory entries =
            reputationRecords[agentId];

        if (entries.length == 0) {
            return 0;
        }

        uint256 total;

        for (uint256 i = 0; i < entries.length; i++) {
            total += entries[i].score;
        }

        return total / entries.length;
    }

    function getReputationCount(
        uint256 agentId
    )
        external
        view
        returns (uint256)
    {
        return reputationRecords[agentId].length;
    }
}

3. ERC8004ValidationRegistry.sol

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

contract ERC8004ValidationRegistry {

    struct ValidationRecord {
        address validator;
        string taskHash;
        bool successful;
        uint256 timestamp;
    }

    mapping(uint256 => ValidationRecord[]) private validations;

    event ValidationSubmitted(
        uint256 indexed agentId,
        address indexed validator,
        bool successful
    );

    function submitValidation(
        uint256 agentId,
        string calldata taskHash,
        bool successful
    ) external {

        validations[agentId].push(
            ValidationRecord({
                validator: msg.sender,
                taskHash: taskHash,
                successful: successful,
                timestamp: block.timestamp
            })
        );

        emit ValidationSubmitted(
            agentId,
            msg.sender,
            successful
        );
    }

    function getValidationCount(
        uint256 agentId
    )
        external
        view
        returns (uint256)
    {
        return validations[agentId].length;
    }
}

hardhat.config.js

require("@nomicfoundation/hardhat-toolbox");
require("dotenv").config();

module.exports = {
  solidity: "0.8.24",

  networks: {
    apothem: {
      url: "https://rpc.apothem.network",
      chainId: 51,
      accounts: [process.env.PRIVATE_KEY]
    }
  }
};

Deployment Script

scripts/deploy.js

async function main() {

  const Identity =
    await ethers.getContractFactory(
      "ERC8004IdentityRegistry"
    );

  const identity =
    await Identity.deploy();

  await identity.waitForDeployment();

  console.log(
    "Identity Registry:",
    await identity.getAddress()
  );

  const Reputation =
    await ethers.getContractFactory(
      "ERC8004ReputationRegistry"
    );

  const reputation =
    await Reputation.deploy();

  await reputation.waitForDeployment();

  console.log(
    "Reputation Registry:",
    await reputation.getAddress()
  );

  const Validation =
    await ethers.getContractFactory(
      "ERC8004ValidationRegistry"
    );

  const validation =
    await Validation.deploy();

  await validation.waitForDeployment();

  console.log(
    "Validation Registry:",
    await validation.getAddress()
  );
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

Conclusion

ERC-8004 represents a significant step toward building a trusted AI agent economy. By combining blockchain-based identity, reputation, and validation, the standard provides the foundation for interoperable and accountable AI systems.

When combined with XDC Network's enterprise-grade blockchain infrastructure, ERC-8004 can enable a new generation of decentralized AI applications spanning TradeFi, RWA, DeFi, governance, and enterprise automation.