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 did. Integrating two systems meant custom work on both sides. That work was brittle. It broke when either system changed.
Then REST gave us a common language. OAuth let us delegate access without handing over credentials. HTTPS made trust transferable. The friction of connecting systems dropped, and software became more composable. A large part of the internet economy was built on 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 hard problems. They can write production code, plan complex logistics, synthesize across hundreds of sources, and run multi-step workflows with little 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 built for monthly subscriptions.
The bottleneck is not the model. It is everything the model must work through to 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 organization can use to refer to them, and a stable handle that ties actions back to a specific actor. That identity 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 runs under. The specific agent, doing a specific task, on behalf of a specific person, with permissions granted to that agent.
Right now, the answer to "who is this agent?" is usually "whoever has this API key." That is nearly 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 will do real work. Today they usually get access through API keys in environment variables. Security teams have tried to retire that pattern for years, for good reason.
Payments. Seat-based pricing works for humans. It breaks down for agents. Usage-based pricing is already common. What is missing 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 decides 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, 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 not been applied cleanly to agents.
Usage-based pricing exists. The payments problem is moving 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 needs new AI research. It needs infrastructure engineering applied to a new actor type.
The pre-REST parallel
Before REST, integrating with a web service meant learning that service's odd 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 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 an 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. 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 grow with every system built on top.
The agent economy is coming either way. The open question is who builds what it runs on.