AI agents with purchasing power: how software gets bought in 2026

If you sell software in 2026, some of your visitors are not people. They are agents sent by people. Someone tells their assistant to find a tool for a specific job, and the agent searches, reads product pages, compares alternatives, and reports back with a recommendation and a link. Sometimes it gets as far as the buy button. So the question, can AI agents buy software, has a real answer right now, and it is more useful than a plain yes or no.

The short version: agents can discover software, evaluate it, and stage a checkout on their own. The payment itself still belongs to a human, partly for technical reasons and partly because the people who build agent frameworks decided it should. Here is the pipeline step by step, what an honest agent-purchasable label means, and where the standards are heading.

Discovery already works

An agent shopping for software behaves like a fast, literal researcher. It opens pages and reads HTML, which puts weight back on things web teams stopped thinking about years ago. Three surfaces matter most:

• Crawlable product pages. If pricing only renders after a JavaScript app boots, or a firewall answers non-browser traffic with a 403, the agent reports that it could not verify the price and moves on to a competitor it could read. Plain HTML with real text and visible prices wins by default.
• llms.txt. A plain-text file at the site root that tells a language model what the site is, what the product does, what it costs, and where the important pages live. Borrowed in spirit from robots.txt, but inverted: robots.txt says keep out, llms.txt says here is the map.
• Machine-readable manifests. A JSON file, often under a /.well-known/ path, stating the product facts in structured form: name, price, license, checkout URL. An agent that finds one does not have to guess from prose.

None of these are ratified standards, just conventions that spread because they work. When a buyer's agent compares five tools, the vendor publishing structured facts gets summarized accurately. The vendor behind a bot wall gets summarized as inaccessible, which reads like hiding something even when it is not.

Checkout is where the human takes over

Once an agent settles on a product, it hits three walls in quick succession. All three are there on purpose.

Card entry. A well-built agent framework refuses to type card numbers, and that is the right design. A card number in an agent's context is a card number in transcripts, logs, and error traces. The safe pattern is that the agent drives to checkout and the human enters payment, or a card already on file is used only after the human confirms in chat.

Bot detection. Payment pages sit behind CAPTCHAs and fraud tooling built to catch card-testing attacks, and an automated visitor at a payment form looks exactly like what those systems exist to stop. Agents should not bypass CAPTCHAs, and mainstream frameworks will not.

Consent. Buying software means accepting terms, and agreeing to a contract is the kind of act frameworks route back to the human, the same way they treat sending email or posting publicly.

This is why merchant-of-record checkouts matter for agentic commerce. Platforms like Gumroad, Paddle, and Lemon Squeezy present a consistent, well-known checkout surface, so an agent that has walked one has effectively walked them all. It can tell its human exactly what happens after handoff: the price, the currency, what arrives by email, who handles the tax. In practice some of these checkouts are more readable to non-browser traffic than others, so a vendor should test what their own funnel looks like to an agent rather than assume.

A live example: Coil

Coil (coil.trade) is a useful test case because it is agent-native at both ends. The product is a long-only trading system, a scanner, a dashboard, and a rules-driven engine, that runs inside the buyer's own AI agent, built for Claude Code and for the MCP interface Robinhood shipped when it launched agentic trading in May 2026. Software that assumes an agent will operate it should not assume only humans will shop for it.

So coil.trade publishes an llms.txt and a machine-readable manifest. An agent can confirm, without parsing marketing copy, that Coil is bought once for $29 with no subscription, that one purchase covers the scanner, dashboard, and engine, that the system never shorts, and that it ships disarmed, with arming as a deliberate human step and keys staying on the buyer's machine. The checkout runs through a merchant of record and is readable by an agent up to the payment step. A buyer's agent can do everything except pay: verify, summarize, and hand its human a link with an accurate account of what is on the other side.

One caveat belongs here because Coil is trading software. It runs with your own brokerage credentials and your own capital, and markets can lose money. That warning sits in the same machine-readable surfaces the agent reads, deliberately, so an agent summarizing the product summarizes the risk with it. What agent-native means for the software side is covered in agent-native software, and the full setup is walked through in our Claude and Robinhood guide. The research behind the ranking itself is laid out at how it works.

What comes next: payment built for delegation

The missing piece is visible once you see the pipeline: a way for a human to grant an agent bounded spending authority in advance, so the last step does not need a live handoff. The plausible shape is a scoped payment credential, authorized by the human for a ceiling amount or a named merchant, accepted by checkout endpoints in place of a typed card, and wrapped in a signed record that makes an agent purchase auditable and disputable afterward. MCP, the Model Context Protocol, already gives this a natural surface, since it is an open standard for connecting agents to tools and its clients can require human confirmation before a tool fires. We cover how those connections work in MCP explained for traders.

Until something like that ships broadly, agentic commerce runs on a human-at-the-till model, and that is fine. Discovery and evaluation were always the expensive parts of buying software. The card takes thirty seconds. If agents make the first two parts honest and fast, keeping the third one human is a small cost, and probably the right default anyway. For the wider picture, see the agent economy.

FAQ

Can an AI agent buy software by itself in 2026?

Mostly no. An agent can discover a product, verify its price, compare alternatives, and open the checkout. The payment step still needs a human, because responsible agent frameworks refuse to handle card numbers, checkout pages run bot detection, and accepting terms is treated as a human decision. Purchases with a card already on file still require explicit human confirmation.

What is llms.txt?

A plain-text file at a site's root that summarizes the site for language models: what the product is, what it costs, and where the key pages live. It is a convention rather than an enforced standard, similar in spirit to robots.txt but additive instead of restrictive. Coil publishes one at coil.trade/llms.txt.

Is Coil agent-purchasable?

In the honest, current meaning of the term, yes. An agent can read the llms.txt and manifest at coil.trade, verify the one-time $29 price, and walk the checkout up to the payment step, where a human enters the card and confirms the purchase. Coil is trading software you run with your own capital, so it is not a purchase to delegate blindly, and markets can lose money.