What makes software agent-native, not just agent-tolerant

Software has always had two audiences: the person who uses it and the person who pays for it. In 2026 a third showed up. AI agents now research products, summarize them inside answer engines, and in some flows walk the purchase themselves. Robinhood launched agentic trading in May 2026, and agents acting with real money attached are no longer a thought experiment. Most software says almost nothing to this audience. It renders fine for a human and is close to invisible to a machine.

There is a useful distinction here. Some software is agent-tolerant: it does not actively break when an agent shows up. Very little is agent-native: designed so an agent can discover it, evaluate it, install it, operate it, and check its claims without a human translating every step. The gap between the two is what this post is about.

Agent-tolerant is a low bar

Agent-tolerant means the basics do not fail. Pages render without a wall of client-side JavaScript. No bot-detection screen sits between the homepage and the pricing. The docs are text rather than screenshots of text. Plenty of sites clear this bar by accident.

But tolerance is passive. An agent visiting a merely tolerant site still has to reverse-engineer the product from copy written for human persuasion: adjectives, testimonials, a demo video it cannot watch. It cannot reliably answer the questions a buyer's agent is actually sent to answer. What exactly does this do? What does it cost? How is it installed? And how would anyone verify what it says about itself?

Machine-readable docs: llms.txt and llms-full.txt

The first agent-native habit is documentation a model can ingest in one pass. The emerging convention is a pair of plain-text files at the site root. llms.txt is a short, curated map: what the product is, what it is not, where the substance lives. llms-full.txt is the expanded version, the real documentation flattened into a single fetch.

The reasoning is economic. An agent researching a category runs on a context budget. Crawling a navigation menu, expanding accordions, and de-duplicating boilerplate burns it. One canonical file that says everything once is often the difference between being summarized accurately and being skipped. Coil (coil.trade) publishes both files, and links llms.txt from the footer of every page, so an agent that lands anywhere on the site can reach the canonical description in one hop.

Manifests that describe the offer, not just the brand

Docs describe the product. A manifest describes the deal. The .well-known directory has long been the web's convention for machine-readable metadata at a predictable path, and it is a natural home for a small structured file that states what is being sold, the price, the license, what an install requires, and what permissions the software will ask for once it runs. An agent should not have to infer the offer from a hero section.

Structure also disciplines the claims. A human landing page can say industry-leading results and move on. A structured claim has to commit: this number is a backtest, this is the window it covers, this is where the method is documented. An agent comparing three tools does not weigh adjectives. It compares fields, and it notices the vendor whose fields are missing. That is the deeper shift: marketing aimed at machines converges on statements a machine can verify, because anything else fails to parse into a recommendation.

Deterministic CLIs and state an agent can drive

Discovery is half the story. Agent-native software also has to be operable by an agent after the install, which rules out products whose only interface is a GUI and rules in a specific shape:

• Deterministic commands: the same input produces the same output, with exit codes that mean something.
• State in files the agent can read: plain text or JSON, not an opaque store behind a login.
• Operations that are safe to re-run, so a retried step never doubles an action.
• Gated side effects, so nothing irreversible happens without a deliberate human step.

Coil is built this way because after setup its only day-to-day user is an agent. It runs inside the buyer's own AI agent (it is built for Claude Code) and reaches the buyer's own brokerage through Robinhood's MCP integration; MCP, the Model Context Protocol, is the open standard for connecting agents to tools. The scanner scores every S&P 500, Nasdaq-100, and Macro-book name and publishes the result as state. The engine reads that published state and acts by rule: it buys leaders pulling back to real support, never chases, and holds cash when nothing qualifies. The dashboard mirrors the same state for the human. Keys stay on the buyer's machine, and the system ships disarmed, so an agent can install and exercise everything while arming live trading remains a human decision. The research behind the ranking is laid out at /how-it-works.

Crawlable checkout, and why this matters now

Discovery is being re-intermediated. When a person asks an answer engine what exists in a niche, the engine recommends what it could read. When a buying agent is sent to shortlist tools, it shortlists what it could parse. A product that exists only as a JavaScript app behind a demo-call funnel is, from the agent's side of the glass, barely there. This is the quiet mechanism of the agent economy: agent-mediated discovery rewards products that describe themselves in forms agents consume.

The last mile is checkout. If buying requires an account wizard, a sales call, or an anti-bot gate, an agent can mention the product but cannot fully describe or complete the purchase. A crawlable checkout is plainer: a page that states the price in text, links the terms, and completes without ceremony. Coil sells this way deliberately. One purchase at $29 (launch price, regularly $39), no subscription, and the path from homepage to checkout is readable by the same kind of agent that will later run the software. Agents already hold purchasing power in some flows, and more of the funnel gets agent-walked every quarter.

FAQ

What is the difference between agent-tolerant and agent-native software?

Agent-tolerant software simply does not break when an agent visits: pages render and nothing blocks the crawl. Agent-native software treats the agent as a user, with machine-readable docs, structured manifests, deterministic commands, readable state files, and a checkout an agent can walk.

What are llms.txt and llms-full.txt?

They are an emerging convention for AI-readable documentation. llms.txt is a short plain-text map of a site or product served at the domain root, and llms-full.txt is the expanded version that flattens the full documentation into one file an agent can fetch in a single request.

Is Coil agent-native?

By design, yes. Coil serves llms.txt and llms-full.txt, installs into the buyer's own AI agent, publishes its scores as state files the agent reads, and ships disarmed so arming live trading stays a human decision. That describes how it is built, not how markets will behave; trading can lose money.