AI agents are pulling apart software products and reassembling the components into personalized stacks, making APIs and open protocols more valuable than UIs.
Software used to ship as a finished product for the end user. Finished, bundled, opinionated. Someone made the decisions about what goes together, how it looks, what you're allowed to do with it. You used the product the way it was designed, or you didn't use it at all.
For decades, every wave of technology added a layer of abstraction on top of the previous one. Bare metal to virtual servers. Managed servers to cloud. Cloud to managed services. Each layer hid the one below. Each one meant you stopped worrying about the layer beneath it. That was the pattern: abstract, simplify, raise the floor.
AI agents break that pattern. They don't add a layer on top, but pull the stack apart. They reach past the product and interact with the components directly. The calendar API behind your calendar app, the database behind your CRM, or the content feed behind the platform. The agent doesn't need the product. It needs the parts and then it reassembles those parts into something new. Something that works for one person, in one context, right now. No product manager decided this configuration should exist. The agent built it because it needed it.
Software is exploding into its components. The UI used to be the most important interface to most products. Now the layers underneath are what matter. Agents don't care about the UI. They integrate through whatever layer gets the job done: an API, a data layer, a protocol. They pick the pieces they need and assemble something that works for you.
Most SaaS applications are a collection of prefab building blocks, shared components, and thousands of lines of commodity code. Two or three things in the middle are genuinely unique, but what made these products valuable was never the code. It was the assembly: the choices about what goes together, how it fits, what gets left out.
Agents are taking over that job. An agent can find the right components, connect them, and configure something that works. It doesn't need the product company's opinion about the right way to do things. It has yours.
The orchestration layer used to be a company with a product vision and a sales team. Now it's an agent with access to your context and a set of tools.
Well-documented APIs and open protocols are becoming the primary interfaces for agents. Not new interfaces, existing ones.
The cost of custom dropped dramatically because an agent can generate a working integration in seconds. Hyper personalization became affordable. The API that was designed for a developer at another company is now consumed by an agent working for you, assembling your personal software stack on the fly. And if the API is missing, agents build their own adapters.
Every service with a clean API is suddenly more valuable than before. The documentation is the distribution. The API is the product surface.
Open protocols are the other half. RSS, CalDAV, IMAP, AT Protocol. Standards that have been around for years, sometimes decades, largely ignored by consumer products. A protocol is a surface an agent can work with without asking anyone's permission.
AWS has 200+ services. Most developers use five of them. The rest is complexity tax.
Vercel and Cloudflare figured this out. They don't compete with AWS on breadth. They compete on specific surfaces: deploy a frontend, run a function at the edge, store a key-value pair. Each surface is clean, well-documented, and simple enough for an agent to use without a manual.
An agent trying to deploy something on AWS needs to navigate IAM roles, VPC configurations, security groups, and a dozen services that overlap. An agent deploying on Vercel needs one API call.
The new infrastructure players don't compete by building everything.
They compete by making specific components so simple that they become the default surface for agents.
But this goes beyond simplicity. Infrastructure platforms don't just serve agents, they constrain them.
The protocol defines what's possible. The platform defines what's allowed. When an agent interacts with CalDAV, the spec determines how calendar access works. When it deploys to Cloudflare, the edge rules determine what it can and can't do. The standards become guidelines. The infrastructure becomes guardrails.
This is how governance works in an agentic world. Not through a new regulatory body that tries to keep up with what agents can do, but through the infrastructure they already run on. The rules are embedded in the protocol, and the infrastructure becomes the guardrail.
Content ownership is the sharpest version of this problem. When agents can consume and redistribute media at scale, creators need real control over who accesses their work and how it gets used. Cloudflare already gives website owners granular controls over which bots and agents can access what. That same pattern applies to every content platform: open does not mean uncontrolled. It means the creator decides what's accessible, what's behind a paywall, and what's available for training. The infrastructure enforces those decisions, not a terms-of-service page that nobody reads.
There's a lot of talk about an "App Store moment" for agents. A marketplace. A discovery layer. I don't think it works that way.
Self-driving cars don't drive on special roads built for autonomous vehicles. They drive on human roads, with human traffic signs, through human intersections. The entire infrastructure was built for a different kind of driver, and the self-driving car adapted to it.
Agents work the same way. They're not waiting for an agent-native internet. They're using what already exists.
The infrastructure was built for humans and their software. Agents turned out to be very good at using it.
I run an AI agent that manages my calendar, email, home automation, and contacts. It uses whatever interface gets the job done.
For my calendar it speaks CalDAV. For email it connects over IMAP. For my doorbell and motion sensors it listens to MQTT events. For contacts and outreach it queries a local SQLite database. For grocery shopping it drives the Albert Heijn web interface, searching products and adding them to my cart the same way I would. For investor research it opens a browser, reads LinkedIn profiles and fund websites, and writes what it finds back to the database.
Some of these are APIs. Some are protocols. Some are just web pages the agent navigates like a human would. The agent doesn't care about the distinction. It picks whatever path is available.
Even CLIs are having a second life. Command-line tools were built for developers. Now they're the preferred interface for agents: structured, predictable, no UI to parse. The graphical interface humans needed turns out to be optional when the user is a machine.
None of this infrastructure was built for agents. All of it works.
When something isn't connected, the agent writes the glue. It generates scripts to bridge services, transforms data between formats, builds one-off tools for tasks that will never happen again. The cost of producing software dropped to near zero. Not because the tools got simpler, but because the agent can write whatever is missing.
The products that will matter most are the ones that are reachable, open, and well-documented. Built on protocols that any agent can speak.
Not because openness is the right thing to do. Because openness is how you get assembled into someone's personal software stack.
Closed systems get routed around. Open systems get composed into something new.
Nothing Phone is one of the first consumer companies to act on this. Their Perfect Apps concept breaks mobile applications into components and reassembles them around what each person actually uses. Not a new app store. A recombination of what's already there. That's the explosion thesis applied to the device in your pocket.
The explosion has already happened. The agents are putting the pieces back together. Differently, for each person, every time.
