When Software Buys Software: Inside the Agent-to-Agent Economy

For thirty years, software charged humans. You logged in, you approved a renewal, you swiped a card. In 2026, software started charging other software. AI agents now pay search engines per query, hire coding agents to fix their own bugs, and provision their own compute, all without a human approving the transaction in real time. The shift sounds small, but it changes who buys, how they buy, and what a software product even has to look like.

We have written about the macro version of this shift in AI autopilots vs copilots: services budgets are migrating toward AI vendors who sell the finished work. The agent-to-agent layer sits one floor down. It is the plumbing that lets those autopilot vendors operate at machine speed, and it is also the plumbing that lets your own agents go shop on your behalf. If autopilots are the new services, agent-to-agent commerce is the new B2B sales motion.

What Agent-to-Agent Commerce Actually Means

Strip the term to its primitives. An AI agent has three things that a traditional API client does not. It has a budget it can spend at runtime, not just a fixed contract a human pre-paid. It has an identity that is its own, distinct from any human user, with credentials that can be scoped, revoked, and audited. And it has a decision loop that lets it pick a counterparty mid-task, including counterparties it has never used before. Combine those three and you get a buyer that can transact at machine speed.

The simplest live example is search. A research agent built on a frontier model needs fresh web context for every question. It calls an AI-native search service like Exa, pays per query out of a session budget, and continues. The interesting part is not that the agent calls an API. It is that the agent could have called any of three search providers, picked one based on price and recency, and tomorrow would pick a different one. The relationship is per-call, not per-contract. Multiply this by code execution sandboxes, image generation, document parsing, and verticalized tools, and a single agent run can touch a dozen vendors before it returns an answer.

The accounting matters. Each agent call is a tiny transaction, often well under a cent, but the volume is high and the receipts have to land somewhere. That is why a layer of agent payment rails is now showing up. Some are crypto-native (Nevermined and similar projects exposing per-call payments to AI agents), some are stripped-down billing APIs aimed specifically at agent traffic, and the cloud providers are wiring this into their own consumption meters. None of this is exotic finance. It is just the mechanical answer to a buyer who shows up unannounced and pays in fractions of cents.

The First Agent-Native Loops Are Already Running

Three loops are visible in production today, in roughly the order they crossed the line.

Self-maintaining codebases. Tools like Kilo Code Cloud Agents and the "cloud" modes of Cursor and Claude Code dispatch coding agents that read a repository, identify failing tests, draft fixes, run them in sandboxed compute they paid for, and open a pull request. The widely cited Anthropic experiment that reported "84 bugs fixed for ten cents" is the early extreme of this pattern. The agent is not a developer assistant; it is a developer who buys its own laptop time. The team running it is increasingly small, sometimes one engineer per service, because the agent purchases what it needs and submits a PR for human review at the end.

Agent-native research and retrieval. Search providers built around the LLM call (Exa, Tavily, and similar) have priced and scoped themselves around agent buyers from day one. The pricing page reads like an agent meant to negotiate it, rate limits assume bursty fan-out, and the API surface is built for chained calls inside an agent loop. Compare that to a legacy search API designed for an app developer. Same category, very different product, because the customer is a different species.

Agent-shaped vertical services. The class of AI-native firms that are productizing professional work (legal NDA drafting, medical coding, claims adjusting, tier-one IT) is starting to expose its own agent-callable surface. Their human customers buy outcomes, but their internal stacks are wired so that another agent inside a corporate workflow can request the same outcome programmatically. That is how a procurement agent ends up "hiring" a legal autopilot to draft an NDA without anyone in legal touching the email.

Why This Is Happening Now

Three forcing functions have lined up in the last twelve months. First, narrow agent reliability crossed a threshold. For a tightly scoped task with verifiable output (run this test, fetch this fact, draft this paragraph), current frontier models complete the loop with high enough success rates that the cost of a wrong call is bounded. Operators have stopped asking "will the agent finish?" and started asking "what should the agent be allowed to spend on?"

Second, usage-based AI pricing is now the default rather than the exception. Every layer in the stack, from foundation models to vector databases to verticalized tools, prices on tokens, calls, or tasks. That makes agent buyers possible. Per-seat pricing assumes a person; per-call pricing assumes a buyer that might be either. Once the pricing curve fits machine traffic, the buyer follows.

Third, the infrastructure underneath has shipped. The very large compute commitments of the last year (Anthropic's multi-billion-dollar Google Cloud commitment and parallel Amazon agreement, OpenAI's networking and orchestration work, NVIDIA's optical-connectivity push with Corning) are not just AI hype. They are the substrate that lets agent traffic fan out cheaply, and they are why the cost per agent call keeps falling in the same year that agent volume is exploding. The macro and the micro are tied: cheaper compute makes more agent calls economic, which makes more vendors agent-callable, which pulls more traffic onto the substrate. We covered the velocity side of this in The AI Velocity Divide, and the production hardening question in running agents as host processes.

What This Breaks for Buyers and Sellers

Five concrete things break in the move from human-buyer SaaS to agent-buyer SaaS.

Per-seat pricing. An agent is not a seat. It can fan out into thousands of parallel tasks, or it can sit idle for days. Charging per agent identity is roughly as useful as charging per browser tab. Vendors who do not have a credible per-call or per-outcome SKU are about to look unaffordable for agent traffic, even if their per-seat list price is fine.

Free tiers. Free tiers were rate-limited by human attention. An agent has none. Whatever fraud and abuse vectors a free tier had before, multiply by a thousand. Most products will need to require authenticated agent identity to access free quotas, with stricter scoping than the human-user flow.

Procurement and vendor-risk. The classical model assumes a human signed an MSA before any spend. Agents discover and use services mid-task. Operators are responding with policy budgets (an agent has a wallet capped at, say, $50 per task), allow-lists of pre-approved vendors, and just-in-time vendor-risk gates that the agent must clear before it can settle a transaction with a new counterparty. None of this exists out of the box in most procurement suites yet.

Audit trails. Logs were built around user ids. Now they need to record the agent id, the policy that authorized the call, the prompt and tool inputs that produced the action, the model and version, the cost, and the outcome. If a regulator or a customer asks why a particular call happened, the answer involves an LLM and a policy file, not a person. Most logging stacks are several quarters away from this being clean.

The contract-of-record question. When an agent commits to a paid action that has consequences (a refund issued, an order placed, a contract drafted), who is on the hook? Today the working answer is "a single corporate principal owns the agent and inherits its commitments," but the case law is thin and the indemnity language in most vendor contracts predates this pattern. Expect this to be a real legal area in the next eighteen months.

A Short Playbook for Operators

Three moves cover most of what a small or mid-sized operator should do this year, regardless of whether you sell software or just consume it.

Move one: instrument your product for agent buyers, even if no agents are buying yet. Publish machine-readable pricing (a clean JSON or YAML version of your price book that an agent can fetch). Expose capability metadata so an agent can answer "does this product do X under constraint Y" without scraping. Offer scoped, revocable credentials with per-call rate limits, distinct from your human-user OAuth flow. Emit a per-call observability record (request id, cost, output, model). None of this is glamorous, and all of it pays back when the first agent shows up at your endpoint.

Move two: redesign your internal stack so your own agents can procure. Decide on policy budgets for each class of agent task. Build an allow-list of pre-approved vendors that meet your data and security bar, and an exception path for new ones. Wire your finance and audit logs to capture agent transactions cleanly, alongside human ones. We cover the implementation patterns for this in our agentic workflow guide for SMEs, and the production-isolation question in the host-process post.

Move three: decide explicitly whether you sell to humans, to agents, or to both. "Both" is a real answer, but it is not a free one. The packaging, the support model, the fraud surface, the docs, and the success metrics all change for agent buyers. A product that tries to be both without acknowledging the split usually ends up being good at neither. Pick a primary buyer and make the other one work, rather than averaging.

The Short Version

The buyer of software is changing species. Agents have wallets, identities, and the ability to pick a vendor at runtime. The first commercial loops are running today in code, search, and verticalized professional services. The substrate for cheap agent traffic is being poured at the macro level, and the unit of sale is moving from the seat to the call. Operators who instrument and price for agent buyers in 2026 will look obvious in 2028. Operators who wait will spend most of 2027 retrofitting per-seat products onto a per-call world. The originating digest for this brief is AlignedNews's AI page, and the broader thesis sits one layer above in services as the new software.

Frequently Asked Questions