Software platforms are going to be rebuilt for agent-first.
AX is not the new DX, it’s the new UX
Nov 5, 2026
Over the past year, Agent Experience (AX) has become one of the most talked-about shifts in infrastructure. Developer tools are being rebuilt for coding agents instead of human engineers, and the companies that moved first, like Netlify, Supabase, and Resend, are seeing it in their growth. That part is well understood by now. The common framing is that AX is the new DX.
I think that framing misses the much bigger story. Infrastructure is just where AX showed up first, because coding agents got good first. The bigger shift is that every product is becoming something agents use, including SaaS, enterprise software, and consumer apps. As traditional UIs fade and software goes headless, the question isn’t how your human users experience your product. It’s how all your users experience it, and more and more of those users will be agents.
That’s why AX is not the new DX. It’s the new UX.
In this post, I’ll walk through what’s happening in infrastructure, why it’s spreading across software, and what it means for how products are built, tested, onboarded, and sold.
From developer experience to agent experience
Before AI coding agents, infrastructure and developer tools competed on developer experience, the craft of faster time to value, better debugging, and stickier brand loyalty.
As we know, software engineering has now fundamentally changed, where the job of engineers is now managing agents, not writing artisanal crafted code by hand as it was for decades.
Individual-contributor roles are looking more and more managerial, only without all the pesky human hiring, firing, and team building. Those who thrive steer the work while delegating its execution to legions of agents.
So if you're an infrastructure company, sitting at the frontier of software development and looking to succeed in 2027, you’re not optimizing your product experience for human developers, you’re optimizing for their armies of agents.
Mathias Biilmann of Netlify saw this coming and coined the term Agent Experience in 2025. If you haven’t seen this phrase much yet, I promise this article is far from the last time you’ll hear about it.
Say goodbye to the old UI
Humans consume software through pixels. Increasingly, agents consume it through protocols. But a lot of the software they need to use still only speaks pixels.
Product playbooks are being completely rewritten right now because industry best practices for human developers largely no longer apply.
Agents behave in fundamentally different ways that require product builders to rethink almost every aspect of their product experiences, surfaces, and constraints. For one, they love to put blocks together by writing all the glue code, as outlined in @mitchellh's excellent piece Building the Block Economy.
But the shift to agent-first software extends well beyond infrastructure. Many companies are beginning to recognize that traditional UIs are just one way to access their products, with APIs, MCP servers, CLIs, and skills designed for agents rapidly undercutting their UIs’ relevance.
The usage data is already screaming and waving in this direction. Amplitude is seeing rapid growth in MCP adoption, while Linear now has more issues created through its MCP server than through its own applications. Platforms such as OpenAI and Vercel are reporting similar momentum across their ecosystems.
This isn’t limited to startups or developer tools either. Salesforce has joined the headless game with Salesforce Headless 360, reframing its products as systems for agents to operate directly.
An agent-first world doesn’t mean every product suddenly becomes headless. Most software was built for humans, and much of it will stay that way for years. Agents will need to work across both worlds: calling APIs where they exist, using WebMCP tools where they’re available, and navigating screens when that’s the only way in.
That makes computer use and browser use critical infrastructure for this transition. A model that can click a button still needs a browser to run in, a session that stays logged in, and a way to understand what went wrong. Browserbase is building that layer for the browser. There is a substantial opportunity in connecting agents to the software the world already runs on.
WebMCP is exciting for the agentic web: you can expose tools directly to agents without changing your website or the normal UI for people. Want to try it? Just ask Codex to add WebMCP support to the website or app you’re building!
Super excited about how WebMCP can change the open web as we know it. You also still got a few days to join our WebMCP hackathon. If you want to learn more about what this is all about, I got you! 👇 x.com/i/article/2094…
The rise of consumer agents
Most of the agent-first shift so far has been about infrastructure and B2B software. That’s starting to change. Personal agents like Instinct and Muse are doing real work for people, from shopping to switching insurance policies.
The interesting part isn’t the savings. It’s who did the work. Joe didn’t compare quotes or fill out forms. His agent did all of it. For the insurer, the customer on the other end wasn’t a person browsing their website. It was an agent.
That changes what consumer products need to be good at, and some are already responding. DoorDash has previewed a CLI that enables agents to order food. Across categories, products are becoming headless, programmable, and accessible without a human navigating a screen.
Even as we keep designing UIs for humans, it's only a matter of time before the agent interface becomes the primary one. Agents will soon far outnumber human users, with each of us having hundreds of agents working for us.
The agent-first internet is already here
Automated traffic now makes up the majority of traffic on Cloudflare’s network, with agents and AI crawlers bringing the crossover forward to May 2026. At this point, the question isn’t whether the transition to agents is happening – it’s how to make the most of it.
I'm already seeing tangible results among companies that have gone agent-first and reshaped their products around it.
Netlify is a well-known example: the team saw this shift early, pivoted the company toward agents, and after fearing they’d bet wrong or too early, saw business explode as agents started deploying websites and applications to Netlify in droves.
At the database layer, Supabase has accelerated to 10 million users, with AI agents driving much of its 600% growth: more than 60% of new databases are launched by some form of AI tool, where the primitives of Postgres combined with a strong focus on open source turned out to be the right ingredients to supercharge their agent-first transition.
Similarly, Resend, which builds email infrastructure and was early in optimizing for agent experience, is reaping the benefits of becoming a default choice for AI coding agents that need to send email. The company grew from 1 million to 3 million users in just 6 months.
Resend is so well represented in the data available to coding agents (an AEO feat as much as one of AX) that some users, like @swyx, are seeing agents rip out existing email infrastructure altogether to replace it with Resend. 🤯
Agents will take any path to a working outcome, not necessarily the human path or the path of least resistance. Effort doesn’t matter – success does.
Hit one blocker, and an agent will switch products, migrate stacks, or rip and replace without hesitation. This ruthlessness is the new reality of an agent-first world, and optimizing for it is already yielding major market share.
Agent-first software is becoming the new norm
As software goes headless, user expectations are keeping pace with it, choosing products based on how well they work with their agents (aka what their agent recommends), which has little to do with how polished their interfaces are.
Products that agents can discover, understand, and operate are at a premium, while those they can’t are liabilities. If your customers’ agents can’t use your product easily, your customers will simply go elsewhere. They may not even know the decision has been made.
This is why the shift to agent experience extends far beyond developer tools and infrastructure.
Agent experience is becoming the new user experience.
And the next wave of category winners will be the companies that build “the best agent-first version of X.”
The rise of agent readiness
As companies embrace AX and build agent-first products, a new market is emerging: agent readiness.
This category of tools helps companies understand how they rank across coding agents, where their product experience falls short, where agents get confused or stuck in loops, and how agents use and perceive their products.
Where UI had heat maps, click-through rates, and an array of inferential analytics and metrics to glean the efficacy of designs on humans, AX offers much more delineated, repeatable, and robust testing grounds.
Infrastructure companies like Netlify, Supabase, and Vercel have begun developing their own evals to understand how agents use their products: Netlify AXIS, Supabase Evals, and Next.js Agent Evals.
But standards like AgentReady are also emerging, with companies like Ora offering sandboxed environments called Journeys to watch and evaluate how well agents play with your products.
While first-generation AEO (Answer Engine Optimization) products like Profound monitor brand rankings by prompting ChatGPT, Claude, and Gemini, which strong AX can help your weighting on, agent readiness tools like Ora test how well your product performs when agents actually use your product in real-world environments.
Understanding agents as users
Agents don't just change how you test your product. They change how you understand adoption: how users sign up, find their way around, and get to value.
Product teams have always been able to instrument this for humans. Telemetry tells you where people drop off in a signup flow. What it can't tell you is why. For that, you need surveys, interviews, and UX research, which are slow, small-sample, and lossy. Mostly, you're inferring intent from clicks.
Agents change this in three ways.
-
You can reproduce your users via simulation. Your agent users are a handful of models running in a handful of harnesses. You can run those same agents in a controlled environment, give them a task like "add email to this app," and watch what happens. You can't recruit your next thousand human users on demand. With agents, you can.
-
You can see the reasoning, not just the clicks. An agent's trace shows which docs it read, which options it weighed, why it picked one, and where it gave up. That's the "why" human telemetry never gave you, and you don't have to ask for it or factor in selection bias of respondents.
-
You can rerun the experiment. Change your docs, your CLI, or your error messages, run the same tasks again, and compare. Onboarding becomes something you test like code, not something you piece together from a quarter of usage data.
It's not perfect. Real agents run with context you won't see, like their human user's memories, context, and prompts. But it's far closer to your actual users (other agents) than any focus group could provide.
Even seemingly straightforward functions like customer support must be reimagined for an agent-first world. How do you trigger agents to provide feedback or steer them forward when they get stuck in a loop?
Brian Armstrong of Coinbase offers an early example:
I've spent my career understanding developers and building developer experiences through anthropological user studies, surveys, data, and friction logs. What will their agent-first correlates be?
We're looking at a new generation of tools that can run agentic loops on both the development and consumption sides of software, creating compounding systems that build, test, and use software continuously – without being constrained by human pace, comprehension, or availability.
The consequences for go-to-market
It’s thrilling to see how products and experiences will change around AX, but the implications for go-to-market and distribution are just as profound.
As agents become primary consumers of software, infrastructure, and developer tools, they also become the ones discovering, evaluating, and selecting them.
Ask Claude to build a web application, and it’ll typically reach for TypeScript and Next.js. If it needs a database, probably Supabase. For email, Resend.
With tools like Stripe Projects and emerging standards like WorkOS’s auth.md, agents can also create accounts, buy subscriptions, and wire API keys directly into the codebase.
That makes agents both discovery engines and gatekeepers. Within a single loop, an agent can:
They now decide which products become dependencies – and whether those dependencies are needed at all. In infrastructure, coding agents are already making deferred buys by building alternatives instead of purchasing a product.
When a tool creates friction, agents are, as ever, ruthless: they switch vendors, rip it out, or roll their own.
Agentic commerce compounds the shift. Machine-payment protocols like x402 combined with stablecoin rails are making micropayments practical, enabling accountless, pay-as-you-go API access. Agents can skip sign-ups and onboarding, unlock tools on demand, and pay only for what they use, lowering adoption friction even further and making AX design all the more crucial.
Meanwhile, switching costs are collapsing. Agents excel at migrations, from rewriting code themselves to moving data. So traditional moats like vendor lock-in and data gravity start to tremble under the pressure, which will almost certainly upend pricing economics across software.
Agents are becoming software’s new market makers. The dynamic echoes the early days of search, when reaching Google’s first page transformed thousands of businesses. The opportunities under AX could be even more dramatic.
We’re still early, but the go-to-market playbook for infrastructure and developer tools is already being rewritten. The playbook for the rest of software will follow soon.
Building for agents
So what does building for agents actually look like?
Start with the surface. For humans, the product is the UI. For agents, it's the primitives: APIs, MCPs, CLIs, and WebMCP tools. If something can only be done in your dashboard, it doesn't really exist for an agent.
Errors matter more than ever. A human who hits an error searches for a fix. An agent decides what to do next, and often that means trying a different product. "Invalid date" is a dead end. "Expected ISO 8601 (2026-11-02), received 11/02/2026. See docs.example.com/errors" is a fix the agent can apply on the next step.
Testing moves from clicks to outcomes. Instead of integration tests and heat maps, you run agents through simulations of real tasks and measure whether they finish, with recorded traces that show exactly where they got stuck.
Onboarding has to get out of the way. Most of the web's onboarding was built to keep bots out: CAPTCHAs, email verification, phone codes. That changes now. A human might have the patience to sign up and verify an email. An agent doesn't. If it can't get to an outcome, it will churn and find an alternative. Onboarding becomes a question of identity and access: who is this agent, who is it acting for, and what is it allowed to do? It's no longer about educating the human on how to use the UI.
A brave new agent-first world
Taken together, these shifts reveal a new market spanning the entire product lifecycle: development, user testing, marketing, go-to-market, customer support, and observability. The whole stack was built for humans. Now it must be reimagined for agents.
What began in infrastructure is spreading across software. In consumer, agents like Muse and Instinct are doing personal shopping and errands. In B2B, Salesforce is going headless, and it's the load-bearing test (yes, I wrote that myself) of whether headless works for enterprise software. If it works for Salesforce, it becomes the enterprise blueprint for the rest of the market and accelerates the shift to AX across it.
Holding onto traditional UIs as the only way to use a product will be tempting, but increasingly limiting.
This moment marks the arrival of agents as new users of software. At Innovation Endeavors, we believe that as agents become the primary users of all software, we’re looking at a new decade of infrastructure-shaped software – and a chance to reimagine every layer of the stack.
Agent Experience is not just the new Developer Experience. It's much more. It's the new User Experience for an agent-first world.
/k
If this perspective resonates and you're building for the agent-first world, I'd love to hear from you here or @auchenberg.
Innovation Endeavors is an investor in Ora
Plugging in AI, Part 3: “The data center next door will lower your electric bill”
Two years ago, we wrote about the electricity gauntlet – the collision between A...
Read more
Meet Soffi: the first truly collaborative workplace for product development
Over the last few years, AI has undeniably transformed the pace of software engi...
Read more
How Agents Use Systems Differently
Increasingly, coding agents are the ones provisioning and interacting with syste...
Read more
A decade of software infrastructure
Today, we are excited to announce Kenneth Auchenberg is joining the team at Inno...
Read more
Our monthly dispatch for the technically curious