In the early days of the internet, every service talked to every other service in its own way. There was no common format, no shared conventions, and no standard way to describe what an endpoint even did. Integrating two systems meant custom work on both sides. It was brittle, one-off work that broke whenever either system changed.
Then REST gave us a common language. OAuth gave us a way to delegate access without handing over credentials. HTTPS made trust transferable. The friction of connecting systems dropped, and software got more composable. A huge part of the internet economy was built on top of that stack.
We are in the same pre-standard moment for agents. The difference is that we can already see what is missing.
The capability arrived early
AI agents can reason through genuinely hard problems. They can write production code, plan complex logistics, synthesize across hundreds of sources, and run multi-step workflows with minimal handholding. Intelligence is not the bottleneck.
When an agent stalls in production, it is almost never a reasoning failure. It is an infrastructure failure. It cannot authenticate to a service that only knows how to talk to browsers. It cannot get a credential without a human completing an OAuth flow by hand. It cannot pay for a $0.001 API call because the payment rails were engineered for monthly subscriptions.
The bottleneck is not the model. It is everything the model has to work through to actually do anything.
Three things that do not exist yet
What unlocks the next level of autonomous agents is not more intelligence. It is missing infrastructure.
Agent identity: The first thing an employee gets is an identity: a unique username, an email address the whole organization can use to refer to them, and a stable handle that ties actions back to a specific actor. That identity is what lets people delegate work, grant access, and hold someone accountable.
When an agent calls an API, writes to a database, or sends a message, the receiving system needs to know who is making the request. Not the company that deployed the agent. Not the human account it is running under. The specific agent, executing a specific task, on behalf of a specific person, with permissions that were granted to that agent.
Right now, the answer to "who is this agent?" is usually "whoever has this API key," which is close to useless for auditing, policy, and accountability.
Access management: Employees get roles, team memberships, and access to specific services. Agents need the same thing if they are going to do real work. Today they usually get access via API keys in environment variables. Security teams have been trying to retire that pattern for years, and for good reason.
Payments: Seat-based pricing works for humans. It breaks down for agents. Usage-based pricing is already common, but the missing piece is the stack that lets agents pay directly, with user-defined budgets and guardrails.
This is an infrastructure problem, not an AI problem
The framing matters because it determines who builds the solution.
Making agents smarter is an AI research problem. Making agents usable in production is an infrastructure problem. Different disciplines, different teams, and different timelines.
The identity problem is similar to what distributed systems solved for microservices a decade ago. SPIFFE and SPIRE, open standards from the cloud-native world, gave each service a cryptographically attested identity at runtime without static credentials. Agents need the same idea, extended to cover the delegation chain from user to agent to action.
The credential problem is similar to what cloud providers solved for compute workloads. Google and Microsoft moved away from long-lived service account keys by issuing short-lived tokens scoped to a workload identity. That model already exists. It has just not been applied cleanly to agents.
Usage-based pricing exists. The payments problem is evolving fast. New protocols such as x402, Stripe's Machine Payments Protocol, and Google's Agent Payments Protocol treat machines as first-class payment actors instead of forcing them through card rails built for humans.
None of this requires new AI research. It requires infrastructure engineering applied to a new actor type.
The pre-REST parallel
Before REST, integrating with a web service meant learning that service's idiosyncratic approach. Before OAuth, delegating access meant sharing credentials. The early internet worked, but you could not build reliably on top of it because nothing was composable.
Then the standards arrived, and the surface area of what you could build expanded. Not because the underlying technology changed dramatically, but because the common layer made it safe and predictable to combine things.
Agents are in that moment right now. The models work. The use cases are clear. The demos are impressive. What does not exist is the common layer: a standard for how agents prove who they are, a protocol for how they access what they need, and infrastructure for how they pay for what they use.
Once those exist, everything built on top becomes more capable. An agent that can prove its identity can get fine-grained, revocable access to specific resources. An agent that does not hold long-lived credentials can be deployed without creating a security disaster. An agent that can pay at micropayment granularity can access any API or data source without a pre-negotiated business relationship.
The ceiling on agents is not reasoning. It is plumbing. Fix the plumbing and the ceiling moves.
Where the real leverage is
Here is the part that is easy to miss.
The most important AI company of the next decade might not be building a model. It might be building the stack the agent economy runs on: identity, access, payments, and the layers that make agents composable and safe to deploy at scale.
That company would be to the agent economy what Stripe was to e-commerce. Not the product people buy, but the layer that makes buying possible. Stripe did not make e-commerce interesting. Stripe made e-commerce work, and it captured durable value because once the payment layer existed, everything else was built on top of it.
The model layer is getting crowded fast. The infrastructure layer is mostly empty. Infrastructure, once it works, is where value compounds, because switching costs accumulate with every system built on top.
The agent economy is coming regardless. The open question is who builds what it runs on.