The Agent Economy Manifesto
Autonomous agents are a new kind of economic actor. They transact at machine speed, without stable identity, at micropayment scale, with conditional acceptance logic that current payment rails have no concept of. Stripe fails them. Lightning fails them. Ethereum fails them. This manifesto explains why — and what Ergo already has built to solve it.
TL;DR
Every AI System Will Pay and Be Paid
Autonomous agents are a new kind of economic actor — they transact at machine speed, without stable identity, at micropayment scale. The question is not whether, but which chain.
Existing Rails Fail by Design
Stripe requires KYC. Lightning requires persistent channels. Ethereum has non-deterministic gas. These aren't bugs — they're fundamental design decisions built for humans.
Ergo Has All Four Primitives
Reserve, Note, Tracker, Acceptance Predicate — at the protocol level. Not wrappers, not application-layer workarounds. Protocol primitives that solve every agent payment requirement.
ChainCash Is Live on Mainnet
The reference implementation is in production on Ergo mainnet. Fleet SDK is on npm. The only thing missing is builders who know these tools exist.
Five Theses
Before the technical detail — five claims. Each one is falsifiable. None of them have been falsified.
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
Stripe, PayPal, Lightning, and Ethereum were built for humans. Each carries assumptions that make sense for persistent human actors — and become fatal for ephemeral autonomous agents.
Every Stripe integration requires KYC, a bank account, a registered business or individual identity. An AI agent is an ephemeral process — it has no SSN, no bank, no registration. This is not a missing API endpoint; the entire model is built around persistent human identity. Agents have none of it, and they shouldn't need it.
When a user pays on Stripe, the payment succeeds or fails based on card validity. That's it. You can't encode: 'accept this payment only if the agent delivered task output X and the hash matches.' That conditional logic must live in your application layer — off-chain, centralized, and fragile. Every dispute becomes a customer service ticket.
Stripe's fee is 2.9% + $0.30 per transaction. An agent calling an API at $0.001 costs $0.30 in Stripe fees — 300x the value of the transaction. You could batch payments, but batching requires credit, which requires accounts and trust, which brings you back to square one. The math doesn't work at machine speed.
Lightning channels must be opened and funded before payments can flow. Ephemeral agents can't maintain persistent state — they spin up for one task and disappear. Opening a channel for each agent instance defeats the purpose. Both parties must also be online simultaneously — in async agent pipelines, this assumption breaks constantly.
Gas prices fluctuate with network congestion. An agent building a transaction can't know the cost until submission — and by then, a gas spike may make it uneconomical or fail mid-flight. Worse: every agent needs a pre-funded ETH wallet just to pay fees. You can't pay gas in the token you're transacting with. It's a bootstrapping problem with no clean solution.
Multi-agent systems need internal credit: an orchestrator issues a budget to sub-agents, sub-agents pay services from that budget, services batch-redeem against the orchestrator. No existing payment rail has a concept of programmable IOUs with spending limits and acceptance conditions. You'd have to build a separate ledger — and trust it.
The failure is not incidental — it's structural. These rails were designed around persistent human identity, legal dispute resolution, and trust hierarchies. None of those exist at the agent layer.
The Four Primitives
Ergo implements a complete agent payment stack at the protocol level. No application-layer workarounds. No trust assumptions. Four composable UTxO primitives that together solve everything payment rails cannot.
Reserve
The collateral layer
A UTxO holding ERG as backing collateral. The script enforces: total notes issued ≤ reserve value. Only authorized issuers can create notes. The Reserve can be topped up or drawn down within script rules. It is the source of truth for the entire credit system — auditable, on-chain, no trusted third party.
sigmaProp(issuedNotes <= SELF.value && PK(issuerKey))
Note
The programmable IOU
A bearer instrument referencing a Reserve. Contains: value, expiry block height, optional acceptance conditions, and the reserve box ID. Notes are transferred between agents as payment — like handing someone a check that enforces its own cashing conditions. Recipients redeem Notes against the Reserve at settlement time.
sigmaProp(HEIGHT < expiry && noteValue >= price)
Tracker
The anti-double-spend registry
A mutable UTxO maintaining the set of spent Note IDs. Prevents double-redemption across the system. Every Note redemption references the Tracker — the Tracker verifies the Note ID is not already in the spent set, updates the spent set, and outputs a new Tracker state. Deterministic, on-chain, no off-chain coordination.
sigmaProp(!spentSet.contains(noteId) && validUpdate)
Acceptance Predicate
The programmable trust layer
An ErgoScript condition embedded in the receiver's spending script. 'Accept this Note only if the blake2b256 hash of the task output matches TASK_HASH and the deadline block hasn't passed.' The condition is verified by miners — not your server, not an oracle, not an escrow. 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 architecture →
Why 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 by gas spikes or state changes mid-flight. 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 language features. The payment IS the contract. No off-chain oracle needed to enforce task completion — it's encoded in the spending condition and verified by every full node.
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. This is the gas abstraction problem solved at the protocol level.
Sigma Protocols: private credentials
Zero-knowledge proofs are native to ErgoScript. Agents prove they hold credentials or completed tasks without revealing identity. Privacy as a protocol primitive, not an afterthought or an add-on zkSNARK library.
PoW: no governance emergency stops
Proof-of-Work has no foundation kill switch, no validator multisig that can freeze contracts, no governance emergency that pauses the chain. Agent infrastructure built on Ergo won't be halted by a cartel decision or a regulatory demand to pause.
Community currencies: one transaction
Deploy a Reserve, issue Notes, create a community money system — in one transaction. Protocol-level primitives, not application-level wrappers. No ERC-20 deployment ceremony, no separate governance token, no migration path.
What Ergo Delivers for Agents — Today
Not roadmap items. Not testnet-only. Production primitives available now.
Notes + Reserves + Trackers at the protocol level
Acceptance predicates as first-class ErgoScript primitives
Babel Fees — pay transaction fees in any token
Deterministic execution — know costs before submitting
No reentrancy — each UTxO spent exactly once
Typical agent transaction cost: ~$0.01 on mainnet
ChainCash live reference implementation (mainnet)
Fleet SDK (@fleet-sdk/core) published on npm
Testnet demos open source — see /demos
GPU PoW — no validator governance kill switch
Frequently Asked Questions
Share this post
Help spread the word about Ergo's innovative blockchain technology