The building block economy

Software gets sold in containers sized for people: the app, the dashboard, the workflow, the subscription. An agent doesn't need most of that packaging. Give it a clear contract, a permission boundary, a price, and some evidence of the result, and it will happily assemble an outcome from parts no person would ever sit down and browse one by one.

Which changes what's worth selling. Once integration is cheap, you don't have to ship a whole product anymore — a small capability that reliably does one thing can be the product.

The package gets smaller#

Applications bundle search, comparison, verification, payment, and support because nobody wants to stitch five vendors together by hand. A lot of what you pay for in a bundle is coordination — shared state, navigation, translating data between systems, recovering when something fails halfway through. An agent can redo that integration on the fly, per task.

The Model Context Protocol standardizes how AI applications discover tools and resources. The A2A protocol lets agents advertise skills in JSON Agent Cards and delegate work without exposing their internals. Stripe's Agentic Commerce Protocol adds shared language between agents and sellers. All of this is early, and some of it probably won't survive, but the pieces point the same way: capabilities described in a form machines can read and compare.

A contract agents can buy#

A machine can call an API without knowing whether it should. For a market to work, inputs and outputs aren't enough — the agent needs metadata it can compare offers on: price, latency, how fresh the data is, what permissions the block demands, where the answer came from, what happens on failure, and who is responsible when the result is wrong.

A purchasable capability might publish something like this:

{  "name": "verify_supplier",  "accepts": "supplier_record",  "returns": "risk_report",  "price": { "currency": "USD", "maximum": 0.03 },  "service": { "p95_ms": 400, "uptime": 0.999 },  "evidence": ["sources", "checked_at"],  "permissions": ["read:supplier_record"]}

The highlighted fields are what make this an offer rather than a function signature. With them, an agent can pick a slower verified supplier for payroll, a cheaper one for a rough draft, or a local fallback when the data can't leave the building.

Where value settles#

Pricing shrinks along with the unit. Subscriptions make sense for a person who keeps coming back to a product they know by name; an agent can buy per result, per minute, or on success, and route the next job somewhere else without a trace of loyalty. The bill ends up attached to whichever block did the work.

This is bad news for the integration moat. If a company wins by owning the screen and gluing commodity services together, an agent that can reproduce the glue on demand takes most of that protection away. The interface still matters — but more and more as the place where a person states intent, grants authority, and reviews what happened.

What's left to defend is whatever can't be recomposed cheaply: exclusive data, legal rights, physical fulfillment, low latency, reputation, distribution. Orchestrators keep leverage too, since they hold identity, memory, and payment, and they decide which blocks even get seen. I suspect the marketplace itself ends up being the largest block of all.

If you're building for this economy, the move is a smaller promise, kept where other machines can check it: publish the contract, honor the numbers, log the evidence. The product a person sees may still look like one calm application. Underneath it, a temporary supply chain forms for each request and dissolves once the outcome is delivered.