Software is being built for agents, not people

For years we’ve told ourselves a comforting story: the pace of new software is constrained by two things—how many developers can build it, and how many users can adopt it.

AI has largely removed the first constraint. The second one hasn’t moved.

That mismatch leads to a conclusion that feels provocative but is increasingly hard to ignore: we’re accelerating software production much faster than the number of people willing (or able) to use that software is growing. And if humans can’t keep up as “users,” the most natural next user is… not a human.

It’s an AI agent.

Production is becoming effectively unlimited

AI keeps driving the cost of “making” down: writing code, generating UI and content, connecting integrations, producing documentation and tests, shipping and maintaining releases.

What used to be gated by human-hours is turning into an assembly line. A small team with agents can produce what previously required whole departments—faster, with more iteration, and lower downside to being wrong: if it’s not good enough, regenerate; if it doesn’t work, refactor; if you need three variants, you get them in minutes.

But none of that changes a basic reality: humans haven’t started consuming software faster.

Attention is the real bottleneck

People still have 24 hours a day, limited cognitive bandwidth, limited willingness to learn yet another UI, and low patience for “one more login,” “one more dashboard,” “one more onboarding flow.”

Every new product competes not only with competitors, but with fatigue, habit, and indifference. In a world where software is cheap to create, the expensive part becomes attention and behavior change.

The obvious escape hatch: the user isn’t human

If people can’t keep up with the volume of software being created, the “user” has to change.

Enter AI agents.

This isn’t just philosophy—you can see it in how interfaces evolve: from menus and clicks to intents and commands; from “fill out 12 fields” to “do what we did last time, but for this new client”; from onboarding humans to exposing capabilities machines can call.

For a long time, UI was the product’s primary contract. Increasingly, the contract becomes a tool, an API, a schema, a capability an agent can invoke inside a larger workflow.

Software becomes action infrastructure, not screens

The “app = UI” model doesn’t disappear overnight, but it becomes secondary.

In an agent-first world, UI is still useful—more as an observation window and exception-handling console. The real work happens via tool calls and orchestrated workflows. The product’s value is less “beautiful UX” and more machine-accessibility: stability, safety, predictability, and clear boundaries.

MCP servers, hubs, and the new app ecosystem

Once you have many agents, you need a standard and safe way to connect them to tools and data sources. That’s why we’re seeing momentum around MCP servers as adapters between agents and real systems, and around capability hubs that collect connectors to CRMs, databases, ticketing systems, payments, and infrastructure.

We’ll also see more emphasis on capability catalogs (what a tool can do, what arguments it takes, what permissions it needs), plus policy, access control, and audit trails—because agents can execute thousands of actions per minute.

It starts to look like a direct evolution: the “app marketplace” becomes a “capability marketplace.” The buyer is no longer a person picking an icon—it’s an agent selecting an action.

So who are we building for?

Still for humans—but differently.

Humans remain the source of goals, the holder of context and responsibility, the judge of “what good looks like,” and the final approver in ambiguous situations. But the operator is increasingly an agent.

If the last era of software was a world of screens, the next one is a world of actions.

Conclusion

We’re entering a phase where the bottleneck isn’t producing software—it’s humans consuming it. The market’s natural adaptation is to shift consumption to AI agents.

That means more and more “products” will be built not as apps for people, but as tools for agents—discoverable through hubs, standardized through protocols, and connected via MCP-like servers.