In the early days of the internet, every service talked to every other service in its own way. No common format, no shared conventions, no standard for how you’d even describe what an endpoint did. Integrating two systems meant custom work on both sides — brittle, one-off, broke whenever either system changed anything.
Then REST gave us a common language. OAuth gave us a way to delegate access without handing over credentials. HTTPS made trust transferable. Suddenly the friction of connecting systems collapsed, and things got composable. The whole economy built on top of that.
We’re in the same pre-standard moment for agents. Except now we know what’s coming.
The capability arrived early
AI agents can reason through genuinely hard problems. Write production code, plan complex logistics, synthesize across hundreds of sources, run multi-step workflows without much handholding. The intelligence is not the bottleneck.
Every time an agent stalls in production, it’s almost never a reasoning failure. It’s an infrastructure failure. It couldn’t authenticate to a service that only knows how to talk to browsers. It couldn’t get a credential without a human completing an OAuth flow by hand. It couldn’t pay for a $0.001 API call because the payment rails were engineered for a monthly subscription model.
The bottleneck isn’t the model. It’s everything the model has to work through to actually do anything.
Three things that don’t exist yet
The things that unlocks the next level of autonomous agents isn’t more intelligence, its these missing infra pieces.
Agent Identity: The first thing a employee gets is an identity: a unique username, an email that the entire org uses to refer to the particular employee. It is this identity that allows people to delegate work, provide access and even hold them accountable.
When an agent calls an API, writes to a database, or sends a message, the receiving system needs to know who this is. Not the company that deployed it. Not the human account it’s running under. The specific agent, executing a specific task, on behalf of a specific person, with specific permissions that were granted for this agent. Right now, the answer to “who is this agent?” is usually “whoever has this API key” — which tells you almost nothing useful.
Access Management: Just like how employees get roles, teams and acess to specific services, agents also need access to services to do anything. The way they get that access today is API keys in environment variables. Security teams have been trying to retire that pattern for years, and not without reason.
Payments: The traditional seat based pricing that worked for humans doesn’t really work for agents. Usage based pricing is already a widely adopted pricing staretgy. What is misisng is the stack to allow agents to pay, with user defined budgets and guardrails.
This is an infrastructure problem, not an AI problem
It’s worth being specific about the kind of problem this is, because the framing matters for who solves it.
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 essentially the same problem 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 thing, extended to cover the delegation chain from user to agent to action.
The credential problem is the same problem cloud providers solved for compute workloads. Google and Microsoft both eliminated long-lived service account keys by issuing short-lived tokens scoped to the workload’s identity. That model already exists. Nobody has applied it to agents yet.
Usage based pricing exists. The payment problem has new protocols taking shape — x402, Stripe’s Machine Payments Protocol, Google’s Agent Payments Protocol — that treat machines as first-class payment actors rather than 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 specific service’s particular approach. Before OAuth, delegating access meant sharing credentials. The early internet worked — sites existed, things happened — but you couldn’t build reliably on top of it because nothing was composable.
Then the standards arrived, and the entire surface area for 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 doesn’t exist is the common layer — a standard for how agents prove who they are, a protocol for how they access what they need, infrastructure for how they pay for what they use.
Once those exist, everything built on top becomes dramatically more capable. An agent that can prove its identity can get fine-grained revocable access to specific resources. An agent that doesn’t hold its own 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 isn’t the reasoning. It’s the plumbing. Fix the plumbing and the ceiling moves.
Where the real leverage is
There’s a version of this that’s 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, the things that make agents composable and safe to deploy at scale.
That company would be to the agent economy roughly what Stripe was to e-commerce. Not the product people buy, but the layer that makes buying possible. Stripe didn’t make e-commerce interesting. It made e-commerce work — and in doing so captured enormous durable value, because once the payment layer was built, everything else got built on top of it.
The model layer is getting crowded fast. The infrastructure layer is mostly empty. And infrastructure, once it works, tends to be where value compounds — because the 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.