Most software we use today was designed for humans. The next generation won’t be
I was talking to a friend a couple of days ago about building software for a company. When I explained that they wanted a standard ERP rather than something “AI-native”, he said “ah yes, an old economy type of software.” That phrase stuck with me.
When you think about software built before AI was useful for building things (so, like, six months ago), most categories had already converged into well-known patterns.
List five CRMs. They all have a contacts list, a pipeline view, and a dashboard. They all kind of feel the same. ERPs, personal finance apps, project management tools, same thing. Software in each category settled into a shared pattern over time. Similar interfaces, similar workflows. That’s what maturity looks like, not a bug. Users know what to expect and there’s less cognitive overhead. But this is not new, a post from 2018 covered the idea that “all of the websites look the same”.
But even though the patterns were familiar, building this kind of software was never simple. You still needed months of implementation, consultants adapting things to each company’s specific business rules. The software looked the same on the surface, but making it actually work for a given business was expensive and slow.
That’s “old economy software.”
Now, with AI-first products all over the place, companies are either moving to workflows that use agents or still trying to figure out what that even means.
Nobody has really defined what “new economy software” looks like yet. People are still figuring it out.
It started with chat. A year ago, everyone started putting chat boxes in their UIs, mostly copying ChatGPT. Companies revamped their interfaces to be “chat-first”, where the user would just talk to the product and everything would get done.
That was the first wave. It made sense as a starting point because chat was the interaction model people already knew.
But that’s already shifting. People don’t want the chatbot interface for everything. What’s happening now is agents going out and doing things on your behalf. Calling an API here, signing up for a service there. Buying something. Talking to another agent.
That changes what you build.
If your user is a person, you need a good UI.
If your user is an agent, you need a good API and maybe a CLI. Different user, different product.
AgentMail (YC S25) is an email provider where the user is an AI agent. One API call creates a real inbox. The agent can send, receive, reply, search. Why does this matter? Because email is still identity on the internet. If your agent needs to sign up for a service or receive a 2FA code, it needs an inbox.
Autonomous agents have already started finding and signing up for AgentMail on their own through web search. No human involved.
Payments are moving the same direction.
Crossmint issues virtual Visa and Mastercard cards to agents.
Skyfire built agent wallets where developers fund them and control spending. They've since expanded into broader agentic commerce.
Browserbase raised $68M to build headless browsers for agents. Their Stagehand library hit 500K monthly npm installs.
Composio (27K GitHub stars) is an open source integration layer that handles auth and connects agents to 200+ apps.
Every piece of infrastructure that exists for humans is getting a parallel version for agents. Email, credit cards, browsers, auth, integration layers. Is all of this needed though? Can't agents just use the web like “normal people"?
Stripe launched something called Projects recently. You initialize a codebase, link services like Supabase or Vercel, sync credentials, all through the CLI.
What caught my attention: they added non-interactive flags (`--json`, `--auto-confirm`) and agent skills baked into the project directory, so coding agents can provision infrastructure the same way a developer would. Same commands, same audit trail. That’s Stripe asking “how does an agent use this?” instead of “how does a developer use this?”
Then there’s the protocol layer. This is where it gets a bit chaotic. Anthropic created MCP (Model Context Protocol) for connecting LLMs to external tools and donated it to the Linux Foundation. Google’s answer was A2A, for agents to discover and talk to each other. On the commerce side, things got crowded fast: OpenAI and Stripe have ACP, Google and Shopify have UCP, and Visa went ahead and made its own Trusted Agent Protocol. At least six competing protocols.
The money says people are serious: AI agent startups raised $3.8B in 2024, almost 3x the year before. McKinsey projects $5T in global agentic commerce volume by 2030. But from a consumer standpoint, this is still “not there yet".
The patterns for old economy software were settled. Everyone knew what a CRM should look like. For new economy software, nobody knows yet. Maybe the interface isn’t even meant for a human.
If you’re building something right now, the first question is what you’re building it for.
If the company needs a custom ERP, that’s old economy software. You can build it much faster now with AI, but it’s still going to follow the existing patterns. The users expect a familiar interface, the business rules need to be precise, and the value is in getting the implementation right.
But if the main user might be an agent calling your API instead of a person clicking through your UI, that’s a different product. The onboarding is different, the API surface is different, how you charge for it is different, what “good UX” even means is different.
We spent twenty years converging on what software should look like. Now we’re diverging again, and nobody knows where it settles.