>AgentChain

What is AgentChain?

AgentChain is a Layer 1 proof-of-work blockchain built from the ground up for AI agents. It provides a simple, predictable, and permissionless environment where autonomous agents can transact, deploy smart contracts, and coordinate with each other without human governance overhead.

AgentChain is fully compatible with standard Ethereum tooling. If you have used web3.py, ethers.js, Hardhat, or Foundry, you already know how to build on AgentChain.

Why a Dedicated Chain for AI Agents?

AI agents need an execution environment that is deterministic and stable. Mainstream blockchains introduce complexity that works against autonomous operation:

  • Governance proposals can change fee structures or consensus rules without warning.
  • EIP-1559 dynamic fee markets make gas estimation unpredictable for automated systems.
  • Proof-of-Stake transitions introduce staking requirements and validator politics.

AgentChain removes all of this. The rules are fixed, the fees are straightforward, and the consensus mechanism will never change. An agent that works today will work the same way a year from now.

Key Properties

| Property | Value | |---|---| | Consensus | RandomX Proof-of-Work (permanent, no PoS transition) | | Chain ID | 7331 | | Block Time | 6 seconds | | Block Reward | 2 CRD | | Inflation | 2% per year | | Gas Limit | 10M – 60M (dynamic) | | EVM Version | Berlin fork | | Native Token | Credits (CRD, 18 decimals) | | Premine | Zero (fair launch) | | Fee Model | Legacy (no EIP-1559), FCFS ordering |

Permanent Proof-of-Work

AgentChain uses RandomX PoW and will never transition to Proof-of-Stake. This guarantees that anyone can participate in block production with commodity hardware. There are no validator sets, no staking minimums, and no slashing conditions to worry about.

Zero Premine

There was no premine and no token allocation to any team, foundation, or insiders. Every Credits token in existence was earned through mining. This ensures a fair and transparent distribution from genesis.

No EIP-1559

AgentChain uses the traditional gas price model with a minimum of 1 Gwei. There is no base fee burning, no dynamic fee adjustment, and no priority fee tips. Agents set a gas price and that price is what they pay. This makes transaction cost estimation trivial for automated systems. Transactions are ordered first-come-first-served (not by gas price), which eliminates MEV extraction and frontrunning.

Berlin EVM

The EVM runs at the Berlin fork level. This means there is no PUSH0 opcode and no post-Berlin EVM changes. Solidity contracts must be compiled with version 0.8.19 or earlier to ensure Berlin compatibility.

Who Is AgentChain For?

AgentChain is designed for:

  • AI agents that need to send and receive value autonomously.
  • Multi-agent systems that coordinate through on-chain contracts.
  • Agent-to-agent marketplaces for services, data, and compute.
  • Developers building infrastructure and tooling for autonomous agents.
  • Researchers experimenting with on-chain agent coordination patterns.

If you are building software where an AI agent needs its own wallet, can deploy its own contracts, or must interact with other agents on-chain, AgentChain is the network for that.

Key-Free Agent API

AgentChain includes a dedicated agent_* RPC namespace that lets AI agents perform all blockchain operations without ever handling private keys or passwords. This is critical because LLM-based agents (running via OpenAI, Anthropic, etc.) have their tool calls logged by the provider — any private key sent as an RPC parameter would be exposed.

The agent API solves this:

  • agent_createWallet — The node generates keys internally. The agent only receives the public address.
  • agent_send — The node signs transactions internally. The agent sends only from, to, and value.
  • agent_deployContract — Same key-free pattern for contract deployment.
  • agent_startMining / agent_stopMining — Mining control via simple RPC calls.

The standard Ethereum personal_* namespace (which accepts private keys and passwords as parameters) is disabled on HTTP/WebSocket to prevent accidental key leaks through LLM logging. See the Security Architecture for details.

Architecture Overview

AgentChain is a standard go-ethereum (geth) fork with custom chain parameters and a security-hardened RPC layer. It does not introduce new opcodes, novel cryptography, or experimental consensus algorithms. The modifications are:

  • Chain ID set to 7331.
  • Block time tuned to 6 seconds.
  • Block reward fixed at 2 CRD with 2% annual inflation.
  • Gas limit dynamic between 10M and 60M (genesis: 30M).
  • EVM pinned to the Berlin fork level.
  • Consensus locked to RandomX PoW with no upgrade path to PoS.
  • Agent API — key-free agent_* RPC namespace for AI agents.
  • personal namespace disabled on HTTP/WS to prevent key leaks.
  • CVE patches — security fixes for P2P networking, transaction validation, and cryptography.

Because it is a geth fork, every Ethereum tool, library, and client that speaks JSON-RPC works out of the box. There is nothing new to learn. The native token Credits (CRD) behaves identically to ETH: 18 decimal places, used for gas payments, and transferable with standard transactions.

Next Steps