We’re a few years into the AI boom and it’s still mind blowing to me that you can just talk to your computer. You can ramble, or be imprecise, or be stilted, and the model will figure out what you mean, how you meant it, and what you want. This is science fiction that literally came true! And it’s getting better at this every day.

“Talking,” of course, means typing or literally speaking. For decades, we’ve contorted user interfaces to work around the fundamental limitation that you couldn’t just tell a computer what you wanted. Now you can and that means the way we think about UI needs to change completely (I have a bunch of thoughts on generative UI, but that’s a post for another day).

To be clear, pure text or voice isn’t always the best interface. Sometimes you want a list of options from which to choose, or a cleanly formatted table, or a playful interaction that hints at what’s possible. But conversation is the most human way to interact, and now that it actually works, it’s becoming the default UI paradigm. And all those pixel-drawn interfaces we spent decades perfecting are playing a supporting role to just telling your computer what you want it to do.

Before this, the only flexible way to tell a computer what to do was to write a program. Doing so required a rigid, exacting instruction in a foreign language that most people found deeply confusing and annoying. So programming became a highly valued, specialised skill. Programmers then spent an inordinant amount of their time developing libraries, sharing best practices, and documenting logic to help make their and others lives easier. It turns out that this was a perfect base for AI models to learn from and so it’s no surprise that programming is one of the first things being automated.

So, UI and pixels-on-screens are still important, but simply telling your computer to do something and it figuring out how is the new paradigm. This leads to my main point:

The world needs 100x more APIs. Maybe 1000x.

I don’t know about you, but my tolerance for logging into domain-specific web apps to push buttons is, to vastly understate it, waning. I want to do all of my work from whatever AI agent I like best, and I want it to have access to all of my stuff (systems, tools, data, etc) so that I can tell it what to do across a broad set of domains. (When I need UI, it should generate it on demand.) People and, in particular, businesses want predictability. We’ve spent decades building highly reliable and predictable systems beneath layers of pixel-perfect UI. Now that “UI” == “just tell the computer what to do”, all of those existing systems need to be easily reachable and usable by agents.

In 2026 even the best API-first companies have 100s of private APIs that you need to log into a web app to use (some for good reason, many for arbitrary reasons). The future winners will expose ~everything programmatically so that agents are maximally empowered (with maybe some thoughtful guardrails for domain-specific security & compliance reasons). Many online products & services don’t have any public APIs, let alone good ones. Every new company will need to have an agent-friendly API just to be viable.

So, there’s going to be a huge explosion of APIs (and SDKs, CLIs, MCP tools, etc, to expose them) and every SaaS web app will be downgraded in user minds from a primary to a secondary interface to that system’s data & capabilities, i.e., I’ll start my work in my preferred agent and only fall back to any system’s first party UI if/when something went wrong / I need to verify something and want to go to the source. (This first party UI will still be valuable, to be clear, it just won’t be where most work starts and is done.)

As an aside, I think first party agent UIs, i.e., every SaaS web app becoming a prompt input with some tool-calling capabilities, etc, are a temporary stop on this journey. Why would I leave my preferred agent to log into a web app to use yet another similar-but-different agent? It’s a nice way to experiment but, really, just externalize the capabilities via API/MCP/etc so any agent can use them. This is what the world wants and where we’ll end up. (Maybe one of these becomes my primary agent, if so that’s a huge win for whoever does it.)

Companies that externalize their capabilities will be more valuable than those that don’t. Why? Agents create value when they compose tools across disparate systems to solve problems no single system contemplated, e.g., join data from system A with system B to then take some action in system C, etc.

Imagine you run a business in 2027 that relies on 5 systems of record (e.g., Salesforce, Notion, Stripe, Quickbooks, Workday). You do all of your work from a general purpose agent, call it ClausAI. 3 of your systems have gone hard into enabling agents, 2 have not due to slowness/organizational fear/whatever. Every time you ask your agent to do something that touches one of the laggard systems it gets blocked and you, annoyed, have to manually intervene, i.e., log into an unfamiliar web app and click buttons or attempt to take the same action from that system’s first party similar-but-different agent thing. You’ll resent the laggards and eventually churn to a more agent-native alternative (a big opportunity for startups). The systems that made themselves easily usable by agents are more valuable to you than the ones that didn’t. This is a new competitive landscape and being early here will matter. (Computer-use agents will bridge some of this, but programmatic access is just cleaner, faster, and more scalable so will dominate long term.)

API patterns will probably change a bit. Rate limits, key types, access control, error messages, documentation, etc, all need to be rethought with agent callers in mind. MCP is a great way to do this but some agents will just prefer to call APIs directly and users will mostly be agnostic. The change will probably look incremental (or everyone will just switch from REST to GraphQL 😆) but will make a big difference in outcomes. The industry is actively figuring this out and no one really knows yet what works well.

So, to wrap up:

• “Just talk to your computer and tell it what to do” is the new universal UI for doing work; traditional UI still matters but is becoming supplemental and will be increasingly generated on demand.
• Agents need APIs in order to do useful things, reliably.
• The world needs at least 100x more APIs.
• Companies that embrace agents (by exposing APIs) will have a big advantage, and those that don’t will be disrupted.
• API patterns will change as we collectively figure out what works. Watch the obvious companies to see these patterns emerge.