Autonomous agents are becoming economic actors.
Not legal persons. Not companies. Not humans. Economic actors.
They request data, call APIs, coordinate sub-tasks, generate outputs, consume compute, sell services and make decisions inside software systems. Today most of their economic activity is hidden behind a human account. The human pays the SaaS bill. The human holds the card. The human reconciles usage. The human signs every real economic commitment.
That will not scale.
As agents become more capable, they will need to interact economically with other agents, services and markets. They will need spending limits. They will need receipts. They will need work verification, conditional settlement and credit. They will need money that works at software speed.
This is the agent economy thesis:
Autonomous agents need programmable money, not merely payment wrappers.
Five theses
1. Many autonomous systems will need to pay and be paid
Not every chatbot needs a wallet. But agents that call paid APIs, rent compute, buy data, outsource tasks, sell outputs or coordinate workflows need economic capabilities. If the agent cannot pay, every workflow falls back to the human operator — and the human operator becomes the bottleneck of every machine.
2. Payment alone is not enough
A payment receipt says value moved. It does not say the work was completed. The agent economy needs work agreements, verification receipts and settlement receipts. The interesting unit is not the transaction. It is the contract.
3. Programmable acceptance is the missing primitive
The core question is not "can an agent send money?" It is: can the payment be redeemed only when the agreed condition is satisfied? That is the difference between a wire transfer and a contract. The agent economy needs the second one.
4. Agents need bounded credit, not unlimited wallets
A safe agent should not hold unrestricted funds. It should receive limited, expiring, purpose-bound instruments. The history of banking is the history of bounded promises. Agents need bounded promises too.
5. The winning stack will be layered
No single product will own the agent economy. Authorization, payment, work verification, credit and settlement will live in different layers — and the systems that win will be the ones that compose cleanly.
What agents require from money
Machine-readable terms
An agent cannot negotiate a vague invoice. It needs structured terms: price, asset, network, recipient, deadline, refund rule, verifier and task definition. Anything less is a human-shaped artefact dressed up for software.
Low-friction payment
An agent may call hundreds of tools per minute. Payment cannot require a manual checkout, a CAPTCHA, or a six-step OAuth dance. Friction is the enemy of automation.
Deterministic costs
Agents need to know whether a transaction is worth doing before they submit it. Unpredictable fees and gas auctions make tiny autonomous payments difficult to plan and impossible to budget.
Bounded spending
An agent should have limits — per task, per counterparty, per day, per asset, per risk category. The right default is the smallest possible authority that still gets the job done.
Work verification
The system must define what counts as acceptable work. This could be objective output, a signed verifier receipt, a cryptographic proof, a hash commitment, or a human-reviewed decision. Without a verification rule, payment becomes a tip.
Settlement receipts
Downstream systems need to know what settled. Receipts are not paperwork — they are the substrate of accounting, dispute handling, audit and reputation. A money system without good receipts cannot grow up.
Why human payment rails are not enough
Traditional payment systems are designed for persistent identities: people, businesses, bank accounts, cards, merchant accounts, chargebacks, legal recourse. That is appropriate for human commerce.
Agents are different. They may be temporary processes. They may act under delegated authority. They may need to pay for a single API call. They may operate inside a workflow where the counterparty is another agent, not a registered merchant.
This does not make traditional systems useless. They will remain important wherever a human authorizes a purchase. But the deeper layer is autonomous work settlement: an agent pays another agent or service for a task, and the system itself verifies whether the task was completed.
That layer cannot be a wrapper around a card network. It has to be money with logic inside it.
The four programmable primitives
A small vocabulary is enough to compose most agent economic flows.
Reserve
A Reserve is the backing layer. It holds collateral or defines issuance rules. When an orchestrator issues credit to sub-agents, the Reserve is the source of trust.
Note
A Note is a programmable bearer instrument. It can represent spendable budget or a claim against a Reserve. It carries value, expiry and task-specific conditions. Whoever holds the Note can attempt to redeem it — subject to the Note's own rules.
Tracker
A Tracker prevents double-redemption and records state changes. In a credit system, the difference between integrity and chaos is whether you can stop a Note from being redeemed twice.
Acceptance Predicate
An acceptance predicate is the work rule. It can require a task hash, a verifier receipt, a deadline, a signature, or any composition of these. It is the smart contract that lives inside the payment, not next to it.
Together, these primitives turn a payment instrument into a small contract for work.
Why Ergo fits this design
eUTXO makes state explicit
Every box has value, registers and a spending rule. Agents can reason about state transitions before submitting transactions. There is no hidden global state to surprise them mid-flight.
ErgoScript puts logic in the payment
The spending condition can encode the acceptance rule. The payment is not a notification to a server somewhere — it is a self-contained contract that miners enforce.
Babel Fees reduce gas-bootstrapping friction
Agents should not need a pre-funded native-token wallet just to operate. Babel Fees allow fee payment through token conversion mechanisms wherever a Babel box exists, removing one of the most awkward steps in agent onboarding.
Native tokens and Notes compose
Tokens handle ownership. Notes handle programmable credit and settlement. A single application can use both, in a single transaction, without bridging or wrapping.
PoW means no governance kill switch
A PoW base chain has a different control model from validator-governed or foundation-governed systems. Agent infrastructure needs a base layer that nobody can pause by committee. PoW gives that.
Principles for the agent economy
These are not best practices. These are the rules.
- No hidden custody. Users must always know who controls funds.
- No unlimited agents. Every agent gets explicit spending limits.
- No payment without terms. Price, task, deadline and verifier are explicit, machine-readable, and signed.
- No settlement without receipts. Payment and work verification are auditable forever.
- No production claims without audits. Demos are demos. Audits are audits. Confusing them is malpractice.
- No single-rail absolutism. The agent economy is layered and interoperable, or it is not the agent economy.
- No fake decentralization. If a server can rewrite the outcome, the README says so on the first line.
Counterarguments
What if existing payment networks solve agentic commerce?
They will solve a large part of buyer-authorized commerce — the part where a human still stands behind every purchase. That does not eliminate the need for trust-minimized work settlement, programmable Notes or agent-to-agent credit. The two layers serve different problems.
What if EVM systems are enough?
Account-model chains can implement many of these patterns. The argument is not that other systems are incapable. It is that eUTXO, ErgoScript and Notes make this design unusually direct, auditable and analysable — and that for agent infrastructure those three properties matter more than ecosystem size.
What if agents do not need credit?
Some agents will only need simple payments. But the moment agents start coordinating — orchestrators, sub-agents, delegated budgets, delayed settlement — credit instruments become necessary. The more agents cooperate, the more credit matters.
What if users do not trust autonomous payments?
They should be cautious. That is exactly why agent payments need spending limits, receipts, audit gates, human override policies and transparent risk disclosures. Trust is earned by being honest about what the system can and cannot guarantee.
What if it is too early?
The rails for the human internet were built before there were users. The rails for the agent economy are being built right now. The question is not whether software agents will need money. It is whether the money they get will be good.
The practical call to builders
Build small. Build testnet. Publish code. Show receipts. Write down failure modes. Make demos reproducible. Add tests for replay, expiry, wrong output, wrong receiver, partial work and failed settlement. Document what you don't know.
The agent economy does not need more vague claims. It needs working examples that survive scrutiny.
Build the primitives. Test them honestly. Audit them publicly. Ship them slowly. Then build the things that depend on them.
This is the work of the next decade.