Part I · the starting idea

The Machine Economy

When software stops being a tool you use, and starts being an actor that earns.

This is the starting idea, and it is not originally mine. Here it is in plain words, so the two parts that follow have somewhere to stand. Where it comes from is credited at the end.

1

The one-sentence version

Today, software is a tool. A human opens it, uses it, closes it. The money and the decisions stay with the human. The claim is that this is about to flip: software agents become economic actors in their own right. They earn, they spend, they hire each other, and they do it without a person in the loop for each step.

Once that is true, the interesting unit of the economy is no longer the human worker or the app. It is the agent, and the sheer number of small deals agents strike with each other, all day, at machine speed.

Value stops accruing to human hours. It accrues to agency that has been set loose to act.
2

Three things to take literally

There are three claims here. Each sounds abstract and is actually concrete. Read them slowly.

a

Agents become the actorsNot people using software. Software itself doing the earning and the spending.

In plain termsAn agent is a program that can take a goal and act on it: find a supplier, place an order, pay for it, check the result. When a program can do all four without a human clicking each button, it is behaving like a small business, not a feature.
Why it mattersThe economy has always been measured in human hours. If the actor is now a program, the thing that has value is not the hour, it is the agency: a capable agent, pointed at a goal, left running.
Made concreteBy 2025 the plumbing got built. Coinbase shipped x402, an open standard that revives the dormant HTTP 402 "Payment Required" status, so an agent hitting a paywalled API gets a machine-readable price and settles it in USDC over Base with no human at the checkout. The ERC-8004 draft gives agents on-chain identity and reputation so one agent can discover and vet another, while Google's A2A lets agents advertise their skills to each other and Anthropic's MCP standardises how an agent calls tools. The end-to-end loop (an agent that earns fees, then spends them to hire another agent) has been shown in demos rather than run as a widespread market yet, but every piece it needs now exists.
The strongest counterStandards existing is not the same as agents being the primary actors: nearly all real money still moves under a human principal's account, spending caps, and liability, and agent-to-agent volume in 2025-2026 is a rounding error next to human-directed commerce. What we have is better automation of human-owned budgets, not agents as independent earners.Fair, for now. But x402 and ERC-8004 remove the exact technical blockers (identity, discovery, settlement) that made even the delegated version impossible, so the human-in-each-step assumption is already breaking at the transaction level.
b

Software lives for a momentAssembled on demand for one task, then dissolved. Alive for forty minutes and never seen again.

In plain termsToday software chases product-market fit: it has to be useful to many people for a long time to be worth building. When building is nearly free and instant, software can instead be built for one person, for one afternoon, for one job, and then thrown away. This is what gets called product:moment fit.
Why it mattersIf products are temporary, nothing durable is being sold. So where does lasting value hide? Not in any product. That question is the whole hinge of this reader.
Made concreteAn agent has to reconcile two messy CSVs from a supplier, once. Instead of subscribing to a reconciliation SaaS, it uses a code-gen tool like Claude Code to write a bespoke parser in seconds, runs it, pays a sub-cent stablecoin fee for any data it pulls via x402, and deletes the code when the job is done. With emerging agent trust rails like the draft ERC-8004, the "product" lives for the two minutes of the task and never seeks a user base, a roadmap, or product-market fit at all.
The strongest counterMost software's durable value was never the code, it was the accumulated state around it: data, integrations, compliance, identity, network effects. Salesforce and Stripe are not moats because CRM logic or a payment form is hard to write, so cheap generation dissolves the throwaway glue and leaves the expensive substrate exactly where it was.Largely right, and it is a relocation, not a refutation: the glue layer collapses toward the ephemeral, while the durable moats migrate down into the data, identity, and payment protocols the disposable tools plug into. That is Part I's next claim.
c

Value moves to the plumbingNot the models, not the apps. The coordination layer every agent has to touch.

In plain termsModels get cheaper and more alike. Apps get copied. What does not commoditise is the shared plumbing: the way agents form, get paid, get trusted, and clear deals with each other. The bet is that durable value sits there, in the rails, not the traffic.
Why it mattersPlenty of people got rich owning one company. But the most durable fortunes were made owning the thing every company has to touch: the registry, the ledger, the exchange, the insurer. The toll booth outlasts the traffic, and the machine economy re-runs that pattern at the speed of a computer.
Made concreteModels are racing to zero (open weights like Llama and DeepSeek, brutal per-token price cuts, near-identical wrappers), so the durable rents sit with whoever owns how agents find each other, pay, and settle. x402 lets an agent pay per API call in USDC on Base with no account, the draft ERC-8004 sketches on-chain identity and reputation so agents can trust strangers, and Google's A2A (now stewarded by the Linux Foundation) plus its Agent Payments Protocol push cryptographically signed agent transactions. Whether any single one wins is open, but whoever becomes the Visa of agent-to-agent settlement clips a fee on every deal regardless of the model on top.
The strongest counterThe coordination layers that actually win are open, unowned protocols, precisely because neutrality is what lets rivals agree to use them. TCP/IP, HTTP, and SMTP moved trillions and captured almost none of it for their authors, so the coordination layer may commoditise harder than the models do.Partial concession: the raw spec likely earns nothing, but value concentrates in the trusted operators built on top of open rails, the way Stripe monetised HTTP and Visa monetised open card standards. The claim holds only if "coordination layer" means the settlement and trust businesses, not the standard.
3

The loop that pays the plumbing

It is best drawn as a flywheel, and the picture is the point. Compute trains models. Models become agents. Agents generate transactions. Transactions attract capital. Capital buys more compute. Round and round, faster each turn. Every revolution pays a small toll to whoever owns the plumbing.

SMALL MOST

EVERY REVOLUTION PAYS THE RING · TOLLS COLLECTED 0 ·

You do not have to own the loop to profit from it. You just have to own one point the loop cannot skip. That is the whole strategy of the machine economy, and it is where Part II picks up.

4

The claim it gestures at

Push the three claims together and a fourth falls out. If products become temporary, so do companies. When forming a company costs nothing and takes minutes, a company can be spun up to catch one opportunity and wound down before a human accountant would have opened the file.

That is the leap the rest of this reader takes. If the company is temporary and nearly free, then the company is no longer the thing worth owning. Something else is. Part II says what. Part III says how it ends.

Made concreteConsider an MEV searcher or arbitrage bot on Ethereum: it is funded through a fresh contract, captures a single block's atomic price gap, and the address is never touched again. By 2025 the rails to push this past pure trading were being laid: x402 lets an agent pay and get paid over plain HTTP in stablecoins, and the draft ERC-8004 gives it a portable identity and reputation record. In principle an agent could register, take one job, settle in USDC, and go dark before a person would open the file, though in 2025 this was mostly nascent tooling, not widespread practice.
The strongest counterLegal and liability structure does not dissolve when the code does. Contracts, taxes, and recourse still need a durable, identifiable party, and rules like beneficial-ownership reporting and KYC/AML assume a persistent human behind any entity. A wound-down shell that actually touched the real economy just leaves its counterparties with no one to sue or collect from.A genuine limit, but it mostly confines the ephemeral firm to trust-minimised, atomically-settled on-chain work where no recourse is needed, which is exactly where MEV bots and single-use vaults already operate as disposable actors today.
Credit This part is a faithful summary of Fabric VC's essay The Machine Economy, in plainer words. The flywheel, product:moment fit, and the coordination-layer thesis are theirs. Read the original at fabric.vc.