AI Agents Are Your New Customer

A widely quoted 2026 forecast put a number on the panic: up to 234 billion dollars of enterprise software spend is now “at risk” from agentic AI, roughly a fifth of the market, because one agent can work across a dozen tools and quietly make most of them invisible. Almost everyone read that as a pricing story. Seat-based software is in trouble, margins compress, vendors scramble.

That reading misses the bigger shift. The number is not really about money. It is about who is on the other side of the screen. For thirty years you built software for a human being who would look at it, judge it, and decide to buy. That human is stepping back. In their place sits an agent that reads your product instead of looking at it, compares you against ten others in half a second, and never once sees your homepage.

Your customer is changing species. And most founders are still building for the old one.

I run two companies where AI already handles a large share of the daily work, and I have watched this flip happen from both sides. The tools my agents pick are not the ones with the best design. They are the ones my agents can actually read and trust. That is the whole game now, and it rewrites how you build, how you get discovered, and what a moat even means. Here is the map.

The Customer Is Changing Species

Start with what is already measurable, because this is not a prediction anymore. It is buyer behavior you can see today.

When business software buyers go looking for a tool, most of them now open an AI chatbot before they open Google. In G2’s 2026 research, 51 percent of B2B software buyers said they start their research inside an AI assistant more often than a search engine, up from 29 percent a year earlier. Ninety-four percent used AI somewhere in their most recent purchase. That alone would be a big shift. The part that should stop you cold is what the AI does to the shortlist.

Asked what most influences which vendors make their list, buyers ranked AI chatbots first, at 54 percent. That is ahead of software review sites, ahead of vendor websites, ahead of peer recommendations, and far ahead of salespeople, who came in last at 18 percent. Sixty-nine percent said they ended up choosing a different vendor than they had planned to, because of what the AI told them. One in three bought from a company they had never heard of before the AI named it.

Sit with that last number. A third of buyers handed the decision to a system that does not care about your brand, has never seen your ad, and will not be charmed by your founder story. It cared about one thing: could it read you, and could it trust what it read.

Now zoom out past software buying into commerce itself. Gartner’s work on what it calls machine customers, sometimes nicknamed custobots, projects that by 2030 machines will influence or make purchases worth around 30 trillion dollars, and that a fifth of all “consumers” will not be people at all. The analysts describe three stages: bound agents that follow rules a human sets, adaptable agents that make some calls on their own, and autonomous agents that just decide. We are somewhere in the first two stages and moving up fast.

So the 234 billion dollar headline is the small version of the story. The large version is that a new kind of buyer is arriving, in both B2B software and consumer commerce, and it evaluates the world through an API instead of an interface. If you only take one idea from this piece, take this one: you are no longer selling to the person. You are selling to the thing the person delegated to.

The Customer Inversion

Here is the shift in one picture. For decades the path from your product to a buying decision ran through a screen a person looked at. You spent your effort on that screen: the landing page, the onboarding flow, the demo, the pixel polish. The interface was where you won or lost the customer, because the interface was what the customer touched.

An agent flips that path. The product still exists, but the layer that reads it, weighs it, and decides is a machine. The human is still there, but they have moved up a level. They no longer evaluate products. They evaluate the agent, hand it a goal, and let it shop. The interface you obsessed over is now furniture the buyer walks past.

Call it the customer inversion. The human used to be the buyer and the agent did not exist. Now the agent is the buyer and the human is the agent’s boss. This is not a metaphor. When a purchasing agent queries five vendors’ APIs, pulls their structured pricing, checks their machine-readable specs, and returns one recommendation, it has performed every step a human buyer used to perform. It discovered, it compared, it decided. The human approved a result they mostly did not inspect.

Two things follow from the inversion, and both are uncomfortable if you have spent years building for people.

The first is that your surface area moved. The thing a buyer interacts with is no longer your interface. It is your data and your endpoints. A gorgeous product with no clean way for a machine to read it is, to an agent, a locked door with a nice paint job. The agent will not knock. It will pick the vendor next to you that answered in clean JSON.

The second is that loyalty as you knew it thins out. A human builds habits, learns your keyboard shortcuts, gets comfortable, stays. An agent has no comfort to lose. It re-evaluates the field on every task. If a cleaner, cheaper, more legible option has appeared since the last time it checked, the agent switches without a pang. You do not earn the customer once. You re-earn the pick on every single call.

That is the bad news and the opportunity in the same sentence. Incumbents built giant moats out of human habit and switching cost. Agents dissolve exactly those moats. A small, sharp, deeply legible product can win a machine’s recommendation against a household name, because the machine does not know the household name is a household name. It only knows who answered the question best.

Your Real User Is a Parser, Not a Person

Once you accept that an agent is doing the buying, a lot of received wisdom about “user experience” needs re-examining. Not because experience stopped mattering, but because the user changed, and the new user has completely different senses.

A person scans a page in a rough Z pattern, reacts to color and whitespace, feels trust or distrust in a few hundred milliseconds, and forgives a messy backend if the front end feels good. An agent does none of that. It does not render your CSS. It does not feel your brand. It requests a resource, parses what comes back, and moves on. Ambiguity that a human glides past, an agent trips over. A price buried in an image is invisible to it. A spec written as marketing prose is noise. A capability that only exists as a button a human clicks might as well not exist, because the agent has no hand.

The practical translation: the agent judges you on legibility, completeness, and reliability, in that order. Can it read you at all? Is the thing it needs actually present in a form it can extract? And when it acts through you, does the same input reliably produce the same result, or does your service behave differently on Tuesday? A human calls that last one “a bug I will report.” An agent calls it a reason to stop choosing you.

This is why the winning move is so counterintuitive that most teams are running the other way. The reflex, when everyone is talking about AI, is to bolt a chat box onto your product so your human user can talk to it. That makes your product talk better to the person. It does nothing for the buyer that is a machine. The move that matters is almost the opposite: make your product shut up and expose itself cleanly to something that will never look at your interface at all.

The prettiest app loses to the most parseable API. I know how that sounds to anyone who has poured years into craft. Craft still wins the human’s heart at the top of the funnel, where a person decides which agent to trust and which brands to seed. But the transaction itself, the moment of getting chosen for the task, is increasingly decided one layer down, in a conversation between machines that has no pixels in it.

How a Machine Actually Chooses

To build for a buyer, you have to know how it decides. A human decision is a messy blend of logic, emotion, habit, and whoever sounded most confident on the sales call. A machine decision is a short, repeatable pipeline. That is good news, because a pipeline is something you can reverse engineer and win.

Here is the loop an agent runs when it shops on someone’s behalf. Every step is a place you can be chosen or skipped.

Look at where the decision is actually made. Discovery asks a blunt question: of everyone who could serve this need, who is even readable by a machine? If your product only exists as a website a person clicks through, you are often out before evaluation starts. You did not lose on merit. You lost on visibility to a reader that does not have eyes.

Evaluation is where founders assume their advantages live, and where most of those advantages quietly stop counting. The agent compares structured facts: capabilities, prices, latency, documented reliability, and reviews it can actually parse. Your beautiful marketing copy is not a fact it can weigh. Your reputation among humans is not in the payload. The comparison is brutally literal.

Verification is the step almost nobody designs for, and it is becoming the one that decides everything, so it gets its own section below. For now, hold the summary: an agent will not commit to an option it cannot check. If it cannot confirm your price is real, your item is in stock, or your action did what you said it did, a cautious agent routes around you to something it can confirm.

Put the two buyers side by side and the change in what wins is stark.

The bottom row is the whole thing. For a human, marketing and design carry the day. For a machine, legibility and reliability do. If your entire competitive advantage lives in the left column, an agent-mediated market erases it. If you can move even part of it into the right column, you can beat companies ten times your size in the only comparison that now runs.

The Agent-Readiness Ladder

“Be more legible to machines” is a direction, not a plan. So here is a ladder that turns it into rungs you can actually climb, from a product an agent cannot see at all to a product an agent trusts enough to pick by default. Most software today sits on the bottom two rungs. The gap between the bottom and the top is where the next decade of quiet market share moves.

Rung zero is where a shocking amount of good software still lives. It works, humans love it, and to an agent it does not exist, because the only way in is a screen. Rung one is the cheapest, highest-return climb most teams can make: publish a discovery file and put your real specs, prices, and availability into structured data instead of prose and images. That single step moves you from invisible to comparable.

Rung two is a documented, stable API, so an agent can pull what it needs and take limited action. Then comes the wall in the middle of the ladder, the dashed line between read and act. Plenty of products let an agent read them. Far fewer let an agent do the actual job through them. Crossing that line is rung three: exposing your core capability as a callable tool, so the agent does not just learn about you, it works through you and completes the task. The fast-spreading way to do this is the Model Context Protocol, an open standard for handing tools to agents that went from roughly a hundred thousand monthly downloads at the end of 2024 to around 97 million by early 2026, with more than ten thousand public servers. When your capability is one of those tools, you are not a website the agent read about. You are a hand it can use.

Rung four is trust, and it is the rung almost everyone underestimates, so it gets the next section. The short version: an agent will read you at rung one, call you at rung two, act through you at rung three, and only make you its default when it can verify that acting through you is safe and correct. Across those ten thousand-plus public agent tools, independent censuses have found only around one in eight clears a real quality and trust bar. The field is crowded at the bottom and nearly empty at the top. That emptiness is your opening.

Use this as a diagnostic, not a trophy. Run your own product down the list and be honest about the first rung you fail.

Trust Is the Bottleneck, Not Access

Access is a solved problem, and it is getting cheaper by the month. Anyone can publish an API. The hard part, the part that decides who actually gets picked, is trust. An agent that cannot verify what you tell it has to treat you as a risk, and a careful agent routes around risk.

The reason trust is scarce is that machines are confident liars when the data underneath them is bad. AI shopping and research agents hallucinate: they invent product specs, cite features that do not exist, and quote prices that are out of date. When the catalog behind the agent is messy or stale, the agent does not know it is wrong. It just states the wrong thing fluently. The damage is already measurable on the human side, where more than a third of consumers report returning a product because the information they were given during the digital journey was inaccurate. Every one of those returns is a trust withdrawal, and agents are being built to avoid exactly that.

This is why the flood of agent surfaces has not produced a flood of trusted ones. Across the ten thousand-plus public agent tools that exist, only around one in eight meets a real bar for documentation, maintenance, and reliability. Getting readable is common. Getting trusted is rare, which means trust is the least crowded place to compete.

The failure modes are specific, and each has a specific fix. Find yours before an agent finds it for you.

The industry is already building the plumbing for machine trust, which tells you where this is going. New agent payment standards do not just move money; they attach verifiable credentials to intent. One emerging protocol separates an “intent mandate,” a signed record of what the human actually authorized, from a “cart mandate,” a signed record of what the agent proposes to buy, so that a transaction carries proof instead of assumption. Card networks have started launching vendor-neutral on-ramps that accept agents across several of these standards at once. Read past the acronyms and the message is simple: the winners are building surfaces an agent can prove things about, not just read.

So when you plan your climb up the ladder, do not stop at “we have an API.” An API gets you read. Verifiability gets you trusted, and trusted is what gets you chosen twice.

The New Distribution: Get Cited, Not Ranked

If the buyer is an agent, distribution changes as much as the product does. For twenty years, distribution meant ranking: win the search result, win the ad auction, win the demo, and a human clicks through. When an agent sits between you and the human, ranking on a page a human never opens is worth less. What matters is whether the agent surfaces you and can act through you. The goal shifts from getting ranked to getting cited and getting called.

The data already points this way. When buyers were asked what most shapes their shortlist, the AI assistant came first, ahead of review sites, your own website, and your sales team. If the assistant is the front door, then the job is to be the answer it gives and the tool it reaches for. That is a different craft than classic search optimization. It rewards clear, structured, verifiable content that a model can quote with confidence, and it rewards being callable so the agent can move from recommending you to using you without leaving the conversation.

You do not have to imagine what this looks like, because the largest commerce players have already wired it up. A shared discovery file standard for agents was co-developed by companies including Shopify, Google, Etsy, Wayfair, Target, and Walmart, and endorsed by a long list of payment and retail names such as Visa, Mastercard, Stripe, Klarna, Affirm, Best Buy, and Home Depot. Stripe runs an official remote agent tool endpoint, and its discovery file even carries an instructions section that tells agents how to work with it. Shopify auto-generates the discovery file for stores and ships multiple official agent servers. More than a million Shopify merchants, plus brands like Etsy, Glossier, and Vuori, are live inside AI shopping assistants. These companies are not decorating. They are making sure that when an agent goes shopping, they are in the set it can see, compare, trust, and buy from.

The lesson for a founder with none of that scale is oddly encouraging. The moves are mostly cheap and mostly undone by your competitors. A discovery file is an afternoon. Structured specs are a weekend. A clean tool endpoint is a sprint. None of it requires a brand budget, and all of it compounds, because every agent that can read, trust, and act through you becomes a distribution channel that runs without you.

Two Tools, One Agent: A Worked Example

Make it concrete. Say a founder wants to automate invoicing, and hands the job to an assistant: “Send the month’s invoices, chase the late ones, and reconcile payments.” Two vendors could serve this. Call them Vellum and Ledger.

Vellum is the product a human would fall in love with. The site is stunning, the onboarding is a joy, the reviews praise the design. Everything a person needs to decide is on the marketing page, written in warm, persuasive prose. It has no public API worth the name, and its pricing lives inside a “book a demo” flow.

Ledger is plain. The homepage is forgettable. But it publishes a discovery file, its prices and limits are structured data, it has a documented API, and it exposes its core actions as a callable tool an agent can invoke directly. It also returns a signed receipt for every payment it reconciles, so the result can be checked.

In a human bake-off, Vellum wins most of the time. It is nicer. But no human is running this bake-off. The assistant is. It queries for candidates and finds Ledger, because Ledger is readable and Vellum is a locked door. It compares on structured facts, and Vellum’s facts are trapped behind a demo form, so they are absent from the comparison. It tries the task end to end, and Ledger lets it complete the whole job, send, chase, reconcile, verify, without a human in the loop. Ledger wins. Not because it is better software by the standards we grew up with, but because it is better software by the only standard the buyer now applies.

The founder who built Vellum did nothing wrong by the old rules. That is the trap. The old rules quietly stopped being the rules, and the scoreboard changed while the game was still being played.

What Most Founders Get Wrong

The common response to all of this is to build for the old customer harder. When AI is the topic of every meeting, the reflex is to bolt a copilot onto your product so your human user can chat with it. That can be a fine feature. It is also, strategically, aimed at the wrong buyer. A chat box makes your product talk more nicely to the person who is stepping back from the decision. It does nothing for the agent that is stepping into it.

The move that matters is the inverse, and it feels wrong to a lot of good builders: spend less energy making your product charming to a human and more energy making it legible, callable, and verifiable to a machine. Not a prettier surface. A cleaner one, exposed to something that will never admire it.

Three illusions keep teams pointed the wrong way. The first is the brand illusion: the belief that your name protects you. In an agent-mediated market, a large share of buyers already end up with a vendor they had never heard of, named by an assistant that does not care about reputation. Your logo does not enter the pipeline. The second is the loyalty illusion: the belief that once you win a customer, habit keeps them. Agents have no habits. They re-shop the field on every task, so you re-earn the pick constantly, or you lose it silently. The third is the interface illusion: the belief that a great UI is a moat. A UI is a moat against human effort. It is nothing against a buyer with no eyes.

Now the honest counterweight, because this cuts both ways and I do not want to oversell it. Humans are not leaving the loop entirely, and craft is not dead. Someone still chooses which agent to trust, which brands to allow into the shortlist, and when to override the machine on a decision that matters. That choice is still made by a person who can be moved by design, story, and reputation. Brand and taste still win the top of the funnel, where a human decides who to delegate to. What changed is the bottom: the transaction, the repeated pick for the task, now runs through a machine. So the right read is not “abandon craft.” It is “keep craft where a human still decides, and add legibility everywhere a machine now decides.” Most teams are doing the first and skipping the second.

What to Do Monday Morning

None of this is theoretical, and almost none of it is expensive. Here is the order I would run it in.

Run the agent test first. Point a capable AI assistant at your product and ask it to complete your core job, start to finish, as if it were a customer. Watch exactly where it stalls. That first stall is the lowest rung you are failing, and it is your highest-return fix. This one exercise will teach you more than any deck.

Publish a discovery file. Put a plain, structured file at your root that tells an agent what you are, what you do, and where your key resources live. It is an afternoon of work and it moves you from invisible to findable.

Free your facts. Take your specs, prices, availability, and limits out of images and marketing prose and put them into structured data. If a claim matters to a buyer, a machine needs to be able to read it as a field, not infer it from a sentence.

Document the front door. If you have an API, make it clean, stable, and documented. If you do not, expose at least your core read, so an agent can pull what it needs without scraping a page.

Cross the read-to-act line. Wrap your single most important action as a callable tool an agent can invoke, using an open standard so any agent can reach it. This is the jump from “the agent knows about me” to “the agent works through me,” and it is where durable advantage starts.

Make one thing verifiable. Pick the claim an agent most needs to trust, live price, real stock, a completed result, and serve it in a form the agent can confirm. Trust is the rung almost no one climbs, which is exactly why climbing it pays.

Then give it an owner. Someone on the team should own agent-readiness the way someone once owned search ranking, with a metric attached: how much of your traffic is already machines, and how far up the ladder you have climbed this quarter. What gets owned gets built.

Frequently Asked Questions

What is a machine customer, or custobot?

A machine customer is an AI-driven agent or device that makes or influences purchases on behalf of a person or another machine, rather than a human clicking “buy” themselves. Gartner popularized the term custobot and projects that by 2030 machines will influence or participate in roughly 30 trillion dollars of purchases, with a fifth of “consumers” being non-human. They evolve through three stages: bound agents that follow human-set rules, adaptable agents that make some decisions on their own, and autonomous agents that decide independently. For a builder, the practical point is that this new buyer evaluates products through data and interfaces meant for machines, which reshapes where the real opportunities are.

What does “AI agents are the customer” actually mean for a B2B SaaS founder?

It means the entity that discovers, compares, and often selects your software is increasingly an AI assistant, not a person browsing your site. Buyers now name AI chatbots as the single biggest influence on their software shortlist, ahead of review sites and vendor websites. So your job expands from persuading a human to being readable and usable by the assistant that human trusts: structured facts it can compare, a documented interface it can call, and verifiable results it can trust. This is the same shift toward machine-legible, intent-first building that shows up in how founders now work with coding agents, applied to how customers find you.

How do I make my product agent-readable?

Climb the readiness ladder in order. First, publish a discovery file (such as an llms.txt) and move your specs, prices, and availability into structured data instead of images and prose, so agents can find and compare you. Second, expose a documented, stable public API. Third, wrap your core action as a callable tool using an open standard like the Model Context Protocol, so an agent can complete the job through you, not just read about you. Fourth, make your key claims verifiable in real time. Most products stall on the first two rungs, so even reaching the third puts you ahead of the field.

What is agentic arbitrage?

Agentic arbitrage is what happens when a single AI agent performs work that used to require a person operating several separate software tools. Because the agent stitches the tools together and delivers the outcome directly, the human stops opening most of those interfaces, and the link between the number of human users and the vendor’s revenue starts to break. It is the mechanism behind forecasts that a large slice of traditional software spend is exposed as agents take over the cross-tool workflows people used to run by hand.

Will AI agents completely replace my app’s user interface?

Not entirely, and not everywhere at once. Humans will still use interfaces for exploration, judgment calls, and the decisions they want to feel in control of. What changes is that a growing share of routine transactions and comparisons moves to agents, so a polished UI stops being sufficient on its own. The safe stance is dual-surface: keep an interface for the human moments that still matter, and add a clean machine surface for the agent moments that increasingly decide the sale. Relying on the interface alone is a version of the commodity trap, where the part a competitor can copy is the only part you built.

How do AI agents decide which product to recommend or buy?

They run a short pipeline: understand the human’s intent, discover which options are machine-readable, evaluate the readable ones on structured facts like specs, price, and reliability, verify that the data and the action can be trusted, then act and report back. Brand, design, and marketing copy barely enter this pipeline. Legibility and verifiability dominate it. A useful caution: agents lean on the platforms that broker these decisions, which makes your dependence on those platforms a real strategic risk to plan around.

Does SEO still matter, or is it all AEO now?

Classic search still matters for the human parts of the journey, but it is no longer the whole game. As assistants become the front door, the goal shifts from ranking on a results page to being the answer the assistant gives and the tool it can call. That favors clear, structured, verifiable content a model can quote with confidence, plus a callable surface so the agent can move from recommending you to using you. Think of it as optimizing to get cited and get called, not just to get ranked.

Is this only relevant to e-commerce, or does it apply to B2B software too?

Both, and B2B software is arguably further along, because business buyers already delegate vendor research to AI assistants at scale. The dynamics are identical: a machine discovers, compares, and shortlists, and the legible, verifiable option wins. Small teams often adapt fastest here, which fits the broader pattern that nimble builders move faster than incumbents. If you want the wider strategic frame, it sits inside the AI-native founder playbook, and the cost side of running agent-served products is covered in the economics of AI usage.

The founders who win the next decade will not be the ones with the prettiest product. They will be the ones whose product a machine can find, read, trust, and choose, on every single call, without a human ever admiring the interface. Your customer is changing species. Build for the one that is actually buying.