Agents Will Buy Their Own Compute

Software can provision infrastructure. It still cannot become the buyer.

A person opens the account, accepts the terms, funds it and hands the software credentials. Agents are going to break that pattern.

KB

---

The workload chooses the machine

I already route work between models.

Some jobs need the best reasoning I can buy. Some need a cheap model that can read a document and return clean JSON. Some should stay on a machine I control because the data has no business leaving the building.

Right now I make most of those decisions before the work starts. I pick the provider. I set the model. I decide whether the job runs locally or in the cloud.

That will look primitive soon.

An agent can inspect a job before it runs. It knows how much context it has. It knows whether the data is sensitive. It knows if the answer is needed in two seconds or by tomorrow morning. It can see a budget and test more than one route.

The same task does not always belong on the same machine.

A legal review may justify the frontier model. Classifying ten thousand support tickets probably does not. A private document search may belong on a local model even if the answer is a little worse. A background research job can wait for cheap capacity. A customer-facing request cannot.

We keep asking which model wins.

The agent will ask which model wins this job at this price.

---

Cloud accounts were built for companies

The cloud assumes a human organization sits on both sides of the transaction.

A company signs up. Finance approves the card. Engineering provisions the machine. Security issues credentials. Procurement negotiates the contract if the bill gets large enough.

That works when the commercial relationship changes slowly, even if the machines scale quickly.

Agents can make thousands of small decisions. They spin up work, abandon bad paths, retry failures and split one goal into twenty smaller jobs. The useful unit is not a server for a year. It is enough compute to finish one piece of work.

Cloud metering got granular. The relationship did not. I can buy a few seconds of compute or a thousand tokens, but only after somebody creates an account, accepts the terms, funds it and hands the software credentials.

I learned this the expensive way. When I started running OpenClaw seriously, my Anthropic bill went from $25 a day to $800 a day. I paid for the useful work. I also paid for loops, retries, apologies and code that never worked.

I wrote about that as the Cloud Landlord problem. The landlord cashes the check whether the work is right or wrong.

An agent that can shop for compute changes the relationship.

It can reject a price. It can move a batch job. It can use local hardware when the cloud premium makes no sense. It can pay more when the deadline matters. It can stop spending when the expected value drops below the cost of another attempt.

Now the agent is buying work instead of waiting for me to pick a vendor.

---

The router becomes the product

I wrote that the model moat is dead because capable models are spreading faster than the labs can fence them in.

That does not mean every model is equal. It means there are enough good options that selection becomes its own engineering problem.

The router has to know more than a benchmark score.

It needs the price right now. It needs latency. It needs to know whether the provider logs prompts, where the work runs, how often the model fails this exact task and what happens when the endpoint disappears halfway through a job.

Then it has to verify the result.

That last part is where most of the easy stories fall apart. Cheap compute is not cheap if the output has to be redone. A fast model is not fast if an agent burns five calls repairing the first answer. A decentralized GPU is not useful because someone proved a machine existed. I need to know the job ran the way I paid for it to run.

The agent needs a memory of performance by task, not model hype.

Model A may be better at code review. Model B may be good enough for extraction at one tenth the cost. My local model may be slower but free after the hardware is paid off. A provider halfway around the world may offer cheap overnight inference and terrible latency at noon.

The winning system keeps score and routes accordingly.

This is a distributed systems problem before it is an AI problem. Scheduling, retries, verification, reputation, failure recovery and settlement matter as much as intelligence.

A router that cannot measure quality will keep buying cheap answers that need to be redone.

---

Software needs money

An agent cannot shop if every purchase ends at a checkout page.

Credit cards were built for people and businesses. They assume an account holder, a billing address, fraud rules, chargebacks and a bank willing to recognize the buyer. API keys made software access easier, but they still require a human to create the account and preload the relationship.

Machine payments remove that assumption.

HTTP has reserved status code 402 for "Payment Required" for decades. It mostly sat there unused. Now x402 and MPP are turning it into an actual payment flow. A service can quote a price. An agent can authorize the payment. The service or its payment facilitator verifies and settles it, then returns the resource.

MPP defines one-time charges and sessions for metered or streaming payments. Its documentation currently lists Tempo, Stripe and Lightning payment methods. x402 puts the payment challenge and credential into the HTTP request-response flow, so an endpoint can charge a caller it has never provisioned an API key for.

These are early protocols. I do not know which one wins. They may merge, specialize or get replaced.

An agent finds a data source it has never used. The source charges two cents. The agent checks the budget, pays, gets the data and records the receipt. No monthly subscription. No sales call. No person creating another account that will be forgotten in six weeks.

Now replace data with compute.

A provider can quote a price for an inference job. Another provider can undercut it. Hardware that is already paid for can enter at a low marginal cost, although electricity, wear and unavailable capacity still count. A specialized chip can win on speed. A decentralized network can fill demand when the big clouds are expensive or unavailable.

Software can compare the offers and buy the job.

DeFi has spent years building programmable settlement before most people had a reason to care. Agents may be the reason.

---

The market will be messy

I am bullish on this direction. I am not pretending it works cleanly today.

Paying an unknown machine is easy compared with trusting it.

Did the provider run the model it claimed? Did it keep a copy of the prompt? Did it return a cached answer from somebody else's job? Did it stop early and charge for the full run? Can it prove that private data was deleted? What happens when the result is wrong but technically complete?

Decentralized compute makes the supply side wider. It also makes the trust problem worse.

Blockchains can prove payment. They cannot prove useful work by themselves. A signed receipt tells me money moved. It does not tell me the inference was good.

The market needs more than wallets. It needs reputation tied to specific workloads. It needs challenge jobs, reproducible outputs where possible and trusted execution for the work that cannot be public. It needs spending limits, escrow, refunds and a clean way to dispute a result without putting private data onchain.

Agents also need hard boundaries.

A wallet with no policy is just a new way to lose money faster. The agent needs a per-job budget, a daily ceiling, approved categories and a point where a person has to say yes. Retries need idempotency so one network error does not buy the same job five times.

The system also has to explain what it is about to do.

"Spend $0.14" is not enough. Spend $0.14 on what model, with what data, under what retention policy, for what expected improvement over the cheaper route?

Faster buying needs tighter permissions, not looser ones.

---

Local compute joins the market

I used to think about local AI as the opposite of cloud AI.

Rent versus own. Landlord versus sovereignty. API versus a box under the desk.

I still believe ownership matters. I also think the boundary gets more interesting once an agent can route work.

Your local machine does not have to replace the cloud. It can participate beside it.

The Mac sitting idle overnight can handle private document work. A gaming PC can clear a batch queue while nobody is using it. A small business can keep routine jobs on hardware it already owns and burst into rented capacity when demand spikes.

I do not have to choose local or cloud once and live with it.

I made the case for sovereign AI because a useful local model gives you a floor. Nobody can reprice it, revoke it or change the rules. Dynamic routing gives that floor a market role.

Local compute becomes the first bid.

If it can finish the job within the deadline, use it. If not, buy outside capacity. If the data cannot leave, pay the latency cost. If the job has high value and low tolerance for failure, pay the frontier premium.

The agent makes the trade instead of following one infrastructure decision forever.

---

Who gets to build

The current AI stack rewards companies that can commit early.

They reserve GPUs. They negotiate API contracts. They hire infrastructure teams. They can afford to learn which models fail by spending money on the failures.

Everyone else pays retail.

A real compute market changes who gets access.

A small team does not need to own the cluster if it can buy exactly the job it needs. It does not need one provider to approve the business if workloads can move. It does not need to predict next year's model winner before shipping this year's product.

This is the part I care about.

I keep a scoreboard on whether AI abundance reaches people or gets fenced. Cheap models help. Local hardware helps. Open weights help. None of them finishes the job alone.

Access becomes real when a builder can move across the stack without asking one landlord for permission.

Machine payments give the agent a way to buy. Distributed compute gives it somewhere else to go. Local hardware gives it the ability to say no.

The combination matters more than any one network or protocol.

---

The next cloud

The cloud is not going away.

Amazon, Microsoft and Google are very good at running machines. Frontier labs will keep charging a premium for the best models. Most businesses will keep renting more than they own because renting is easier.

But the relationship can still change.

Today we choose a cloud, deploy the software and live inside the bill.

Tomorrow the software will carry a budget, inspect the job and assemble its own stack for the next five minutes. Local model for the private context. Cheap open model for the bulk work. Frontier model for the hard decision. A paid data call from a service it found thirty seconds ago. A receipt for every step.

The infrastructure becomes temporary.

The policy and the workflow remain.

That is the part builders should own. The task definition. The routing logic. The evaluation history. The permissions. The ability to leave.

I do not think the next cloud is another place where we deploy software.

It is a market our software shops in.