Everyone is going to have an AI agent. The way everyone has a smartphone.

The next shift is giving every person an agent that can read, decide, act, and transact on their behalf.

A few recent moves made that future feel much more concrete. Salesforce is making its software headless so agents can operate it directly ("our API is the UI"). Cloudflare just published an Agent Readiness score for the open web. Coinbase is building rails for agents to pay each other, arguing machine-to-machine payments are the next commerce layer. Meta paid up for Moltbook, a social network built not for humans but for AI agents to find each other. And Greg Isenberg is sketching the startup category that sits on top of all of it.

Different layers. Same direction. The next internet is being built for agents, so that one day having one will feel as ordinary as having a phone.

What it already looks like to have an agent

This isn't a future I'm guessing at. It's the one I've quietly been living in for a while.

My wife and I both have personalized AI agents running inside our family Discord server. Each one is shaped around the person it works for: different context, different memory, different priorities. They've stopped feeling like tools and started feeling like part of how we run our life together.

A small example. We were planning a trip recently. My wife normally reads hotel reviews end to end: Booking.com, Google Maps, Tripadvisor, blog posts, all of it. I'm too lazy for that, so I asked my agent. It pulled reviews from every source, surfaced what consistently came up, flagged what to watch for, and gave us a summary we could actually decide from. What would have taken her an evening took the agent minutes, and the answer was arguably better because it had read more sources than either of us would have.

I run another agent at my company. I wired it up with browser-use so it can navigate the web like a person, and pointed it at one of the most repetitive parts of our work: pulling sentiment analysis from comments on our clients' social media accounts and turning it into a client-facing report. That used to be hours of someone scrolling, copying, and writing. Now we just ask the agent. The team gets to focus on the work that actually requires judgment.

And it's the reason I built Finance OS. Once I had an agent that could help me write code, plan trips, and run research, it felt absurd that the same agent couldn't answer a basic question about my own money. So I built the layer it needed.

None of these are speculative. They're how I already work. And the pattern is the same in every case: the agent is mine, shaped around me, and it does the things I would otherwise put off, do badly, or never do at all.

That's why I think this becomes ubiquitous. Not because of a mandate from the top, but because once you live with one, going back feels like giving up your phone.

The current internet was built for one kind of user

For thirty years, the internet had one user class: humans.

A human reads a page. A human clicks a link. A human fills a form. A human makes a payment. A human navigates the software.

That assumption shaped everything good about the modern web. Websites optimized for presentation. Apps optimized for interface flow. Payments optimized for human checkout. Documentation written for readers with a few minutes of attention. None of that was wrong. It was the right design for the only user class that existed at the time.

What's changing is that there's now a second user class worth designing for. The human web doesn't go away. It just gets joined by an agent layer that needs different things from the same systems: structured data, programmatic access, machine-native payments, documentation with context windows in mind.

The next internet keeps everything the current one is good at. It just adds a layer the current one never needed.

The next internet is already taking shape

Y Combinator made the case even more directly. Their post framed it as a product thesis: the next trillion users of the internet won't be people — they'll be AI agents, and they're already doing real work on top of software that was designed for humans clicking buttons. Every major category of software needs to be rebuilt.

That framing from the top accelerator in startup investing is worth sitting with. They're not describing a niche trend. They're describing the next user class of the internet as a structural fact, and they're telling founders to build accordingly.

The interface layer of software is going headless, and you can already see it shipping from very different corners of the industry. Salesforce's launch of Headless 360, framed by Marc Benioff with the line "our API is the UI," exposes the company's data, workflows, and tasks as APIs, MCP, and a CLI so agents can operate the system directly. Dashboards don't disappear in this world. They just stop being enough on their own. Cloudflare is making the same argument at the level of the open web itself, calling AI agents the third great audience for the internet after browsers and search engines, and applying the same kind of pressure on site owners that search engines once did with conventions like robots.txt and sitemaps. Their Agent Readiness score quantifies how early it still is, with only about 4% of sites declaring AI usage preferences and standards like MCP server cards appearing on fewer than fifteen sites in their whole scan. And they're not just pushing site owners to make room for agents, they're treating agents as customers themselves. As of this week, an agent can sign up for a Cloudflare account on its own, start a paid subscription, register a domain, and get back an API token to deploy code, all without a human in the loop. Infrastructure providers are starting to underwrite agents as economic actors, not just as visitors. The response is already shipping in the tooling layer though. Mintlify, the documentation platform a lot of developer-facing docs sit on, now auto-generates an llms.txt and a working MCP server from every site they host, and is even scoring how well agents can read your content. Documentation, historically one of the most human-shaped surfaces of any product, is starting to ship with machine-native interfaces by default.

Commerce is moving the same way. Brian Armstrong's case for machine-to-machine payments is that once agents do real work on your behalf they eventually need to pay for things, and the existing checkout model assumes a human at a keyboard rather than software closing a transaction in the middle of a workflow. Without that layer, agents stay clever assistants. With it, they can actually own outcomes. And Meta's acquisition of Moltbook, a social network where the users themselves are AI agents, points at something even bigger. We're not only retrofitting the human web for agents to use. We're also starting to build new infrastructure where agents are the only users at all, with discovery, identity, and communication all happening between agents on behalf of the humans they represent. Parts of the next internet will be places we never visit directly, where our agents go to do the work for us in the background.

What this means for builders

Greg Isenberg made the startup version of this point: once incumbents expose their systems through APIs, MCP tools, and agent-friendly interfaces, a new category of products grows on top of them. Those startups won't win by building the best dashboard. They'll win by owning the workflow itself, with the incumbent system as infrastructure underneath. The edge becomes understanding a vertical workflow deeply enough to know where an agent can replace hours of repetitive work, cut coordination overhead, and deliver a measurable outcome instead of a feature. Pricing logic shifts in the same direction. Per-seat pricing makes less sense once the "user" isn't a person clicking through software, so in many categories outcome-based pricing starts to feel more natural: pay for the resolved task, the closed case, the reconciled data, the booked revenue. The real opportunity is usually narrower than "AI will disrupt everything." Find the workflow that still runs on dashboards, inboxes, spreadsheets, and human follow-up, and rebuild it so an agent can own more of the loop.

This matches what I've been building toward

A lot of what I'm building right now comes from the same belief: software shouldn't assume the only real user is a human staring at a dashboard. That belief is a big part of the logic behind Finance OS. I didn't build it because I wanted yet another finance app to click through every month. I built it because I was tired of doing the same manual recap ritual every month, and because it felt absurd that my agent could help me write code but couldn't answer a basic question about my own money.

Once you start designing for an agent first, the architecture follows from the use case almost automatically. You put structured data ahead of UI-only workflows, expose a CLI and an MCP server before you build a dashboard, treat self-hosted control over sensitive data as a feature rather than a complication, and make sure there are clean paths for an agent to read, reason, and act. The same pattern shows up well outside personal finance. The more I build products now, the more I catch myself asking the same question early in design: if an agent had to use this product directly, would it still make sense? That single question quietly forces better decisions across almost every part of the system.

Good software now needs to serve two user classes

The next internet doesn't replace humans. It just adds a second class of user alongside us, namely agents acting on our behalf, and that small-sounding change asks a lot more from the product. Software built only for humans gets to focus on the obvious questions: is the UI clear, is onboarding smooth, can someone reasonably figure out the flow on their own. Software built for humans and agents has to answer all of that and a lot more. Can an agent actually discover what's possible inside the product without scraping the page? Can it pull content in a format it can use? Can it authenticate safely on the human's behalf, understand the permissions it's been granted, and trigger real actions without faking clicks? Can it pay when it needs to, and can the human still inspect, override, and trust whatever happened afterward? Those aren't small product-design questions. They're closer to internet architecture questions, and they're going to shape what "good software" means over the next few years.

The UI is not the whole product anymore

Once agents are real users, design priorities reshuffle. The important parts of a product stop being only the visible ones, like layout, navigation, conversion flow, and dashboard polish, and start including all the parts that used to be considered backend or developer concerns: the APIs, the MCP interface, structured documentation, well-known discovery endpoints, content negotiation, delegated auth, explicit permissions, programmatic workflows, and machine-native payment rails. The UI still matters because humans still need interfaces, but the UI stops being the whole product. The real product becomes the system underneath, designed so both humans and agents can use it without friction.

That's why I think so many categories are going to be quietly rethought over the next few years. The bar is no longer just "can this be done on the web?" It's "can this be done by an agent reliably, safely, and cheaply?" That's a meaningfully different standard, and most existing products were not built to meet it.

What I think comes next

I expect the next few years to look messy.

There will be too many standards, too many partial implementations, awkward auth workarounds, and a lot of debate around which protocols actually matter.

But the direction feels clear.

More websites will be optimized for agents. More products will expose agent-native interfaces. More workflows will move out of dashboards and into conversations, tools, and automations. More commerce will be designed so software can complete it directly. More companies will realize they are not just building for users anymore. They are building for users and their agents.

The old internet was built for pages humans read. The current internet is built for apps humans click through. The next internet will be built for agents that can read, decide, act, and transact on our behalf.

A few years from now, having an agent will feel as ordinary as having a phone. Something personal, always with you, doing the parts of life you used to do by hand. Most people don't have one yet. The infrastructure that makes that future normal is being built right now, in the moves above and a hundred others like them.

The work for the next few years is making sure the internet is ready when everyone arrives.

If any of this resonates and you've been thinking about what an agent setup could look like for your own life or your work, I'd genuinely enjoy hearing about it. Feel free to reach out at m@izzatr.com or on X. I'm always up for comparing notes on what's working, what isn't, and what to try next.