Every AI agent will need
to pay and be paid.
The chain that wins agent commerce wins the next decade of blockchain adoption. Ergo already has the primitives. This document explains why — and what it means for builders.
Every AI system will need to pay and be paid. The question is not whether, but which chain.
Agents require money primitives, not payment wrappers. The chain that gets this wins the next decade of adoption.
Programmable acceptance turns payments into enforceable contracts. This is the missing layer for autonomous commerce.
Ergo already has the primitives: Notes, Reserves, Trackers, Acceptance Predicates. The gap is developer awareness.
ChainCash is live. Fleet SDK is ready. The only thing missing is builders.
Why existing rails fail agents
Stripe, PayPal, Lightning, and Ethereum were all built for humans. Agents are a different kind of economic actor entirely.
No persistent identity
Agents are ephemeral. They spin up, complete a task, and disappear. Every payment rail built for humans assumes a stable identity, a billing account, a KYC record. Agents have none of these — and they shouldn't need them.
No programmable acceptance
When an agent pays for a service, the payment should encode the terms: 'Accept only if task X is complete, before block Y, with proof Z.' Today's rails have no concept of conditional acceptance. Logic lives off-chain — fragile, gameable, slow.
Micropayments are economically broken
An agent pays $0.001 for an API call. Stripe charges more in fees than the call costs. Credit card networks require minimums. Lightning Network requires persistent channels. None of these work for ephemeral machine-to-machine commerce.
Credit has no settlement layer
Multi-agent systems need internal credit: an orchestrator issues tokens to sub-agents, sub-agents pay services, services batch-redeem. There is no protocol for programmable IOUs at machine speed. Until now.
The four primitives
Ergo implements a complete agent payment stack at the protocol level. No application layer workarounds. No trust assumptions.
Reserve
The collateral layer
A UTxO holding ERG as backing. Script rules: total notes issued ≤ reserve value. Only authorized issuers can create notes. Topped up or drawn down within rules. The source of truth for the credit system.
sigmaProp(issuedNotes <= SELF.value && PK(issuerKey))
Note
The programmable IOU
A bearer instrument referencing a Reserve. Contains: value, expiry height, optional acceptance conditions, reserve box ID. Transferred between agents as payment. Recipients redeem against Reserve at settlement.
sigmaProp(HEIGHT < expiry && noteValue >= price)
Tracker
The anti-double-spend registry
A mutable UTxO maintaining spent note IDs. Prevents double-redemption. Note redemption references Tracker — Tracker verifies note ID not in spent set, updates spent set, outputs new Tracker state.
sigmaProp(!spentSet.contains(noteId) && validUpdate)
Acceptance Predicate
The programmable trust layer
An ErgoScript condition in the receiver's spending script. 'Accept this note only if the blake2b256 hash of the task output matches TASK_HASH and the deadline hasn't passed.' Logic lives in the payment itself.
blake2b256(getVar[Coll[Byte]](0).get) == TASK_HASH
ChainCash is the production reference implementation of this stack — live on Ergo mainnet, open source, built by BetterMoneyLabs.
Read the full technical architectureWhy Ergo — not any other chain
These aren't features added to serve agents. They're protocol properties that make Ergo uniquely suited as the agent economy base layer.
eUTXO: deterministic by design
Every transaction outcome is known before submission. Agents don't get surprised. No reentrancy. No hidden global state. No MEV. What the simulation says is what happens on-chain.
ErgoScript: logic in the payment
Acceptance predicates are first-class. The payment IS the contract. No off-chain oracle needed to enforce task completion — it's encoded in the spending condition.
Babel Fees: agents don't need ERG
Pay transaction fees in any token. An agent receiving a community token doesn't need a pre-funded ERG wallet. Spin up, operate, settle — all without native token bootstrapping.
Sigma Protocols: private credentials
Zero-knowledge proofs are native. Agents prove they hold credentials or completed tasks without revealing their identity. Privacy as a protocol primitive, not an afterthought.
PoW: no governance emergency stops
Proof-of-Work has no foundation kill switch. Agent infrastructure built on Ergo won't be frozen by a validator cartel or an emergency governance vote.
Community currencies: one transaction
Deploy a Reserve, issue Notes, create community money — in one transaction. Protocol-level, not application-level. No ERC-20 wrapper, no deployment ceremony.
The stack is ready. Are you?
The primitives exist. ChainCash is live. Fleet SDK is published. The only thing missing is builders who understand what autonomous agents actually need from money.