The AI Agent Infrastructure Nobody's Watching Yet

There's a multi-billion dollar infrastructure stack being assembled in public right now, and if you're building AI agents, you're probably standing on top of it without realizing how unstable the ground is.

Nate B Jones, who covers AI strategy, argues we're watching something as foundational as the shift to cloud computing—except this time, the customer isn't human. "The new customer for infrastructure is going to be the agent," he explains in a recent breakdown of what he calls the six-layer agent infrastructure stack. "We are talking about a shift at least as big as cloud when we're moving to agentic primitives."

The problem? Almost nobody outside the companies building this stack can distinguish signal from noise. And that matters, because the choices being made right now—which primitives survive, which get absorbed by hyperscalers, which turn out to be expensive shims—will determine what's possible for agent builders in 18 months.

The Lego Analogy Is a Lie

The pitch you've heard is that agent tools are composable building blocks. Snap them together, ship your agent. Jones dismantles this immediately: "These are not all bricks with the same size knobs that you can just slap together. Right now, it's as if you have Legos and wooden blocks and they're all marketing themselves as Legos."

A better mental model, he suggests, is system calls. Agents need defined, reliable interfaces for compute, identity, memory, communication, and payments. The companies building those interfaces are essentially building an operating system—not for humans, but for the automated economy.

So what are those six layers, and how mature is each one?

Layer One: Compute Is Mostly Solved

The compute and sandboxing layer is the most production-ready piece of the stack. Agents need somewhere safe to run code—not on your laptop, not in production, not unsupervised. E2B ($32M in funding) uses Firecracker microVMs, the same tech behind AWS Lambda. Daytona ($24M Series A) took a different bet: Docker containers with a shared kernel, optimized for speed with 90-millisecond cold starts.

The philosophical split here matters more than it looks. E2B treats sandboxes as disposable—spin up, run code, tear down. Daytona assumes persistence—your agent installs dependencies, creates files, comes back later. "This is not a style preference," Jones emphasizes. "This is an architectural bet from these startups on how long agent sessions in the new economy will run and whether state matters."

Both approaches will probably survive because the agent economy will be that big. But builders need to understand which model their workload actually requires.

Layer Two: Identity Is Still a Mess

Agents need to exist as entities on the internet. They need to authenticate with services, send and receive messages, hold verifiable identities. The pragmatic answer right now? Give them email addresses.

AgentMail just raised $6M from General Catalyst (with Paul Graham and HubSpot's CTO as angels) to let you programmatically create email inboxes for agents. Real addresses, full threading, attachments—the works. The CEO frames email "not as a communication tool, but as a fundamental identity layer."

But Jones flags the obvious question: what if email is just a shim? "Email works today because it's everywhere, not because it's the right protocol for agents, but because it's the right protocol for humans who built the internet." Threading is brittle. Rate limits were designed to block automated agents. Signal-to-noise ratios are terrible for context windows.

Multiple teams are working on agent-native protocols—on-chain identity, dedicated agent-to-agent communication standards, MCP-based service discovery. Nothing has won yet. "If you're betting on agent email," Jones warns, "you should be aware you're making a pragmatic bet, not necessarily an architectural bet."

(Though he's quick to add: "I am not the person to bet against email. Email has been famously cockroach-like in its ability to survive lots and lots of revolutions.")

Layer Three: Memory and the Hyperscaler Question

Agents need to remember—not just within a session, but across tasks, days, deployments. Mem0 is the clear leader here: $24M raised, 41,000 GitHub stars, selected by AWS as the exclusive memory provider for its agent SDK.

What Mem0 gets right is treating memory as active curation, not just conversation logs. Their hybrid architecture—graph database, vector store, key-value store—lets them selectively store, forget, and recall. On benchmarks, they outperform OpenAI's built-in memory by 26% on accuracy with 91% faster latency.

But here's the platform risk: every frontier lab is building memory into their models. If memory becomes a model-level feature the way search got absorbed into ChatGPT, standalone memory companies are vulnerable. Mem0's counter-thesis is portability—you should own your memory, not rent it from a hyperscaler.

"The question here is really: which thesis wins?" Jones says. "Will the market decide they want a memory solution that does not belong to a hyperscaler? Or is the convenience the hyperscalers offer so compelling that the market just decides to go with it? I don't know. It feels a little bit like a coin flip."

Layer Four: Integration Hell Never Dies

Any agent working in an enterprise needs to touch Slack, Jira, Salesforce, GitHub, Google Workspace. Without middleware, every agent builder independently manages credentials, OAuth flows, rate limits, error handling, API schema changes for every tool. It's the classic N×M integration nightmare.

Compose.io ($29M from Lightspeed) provides a managed integration layer—authentication handling, pre-built connectors to hundreds of services, observability on every tool call. They're not building agents; they're building the plumbing agents need to navigate enterprise environments.

This space is durable as long as the ecosystem remains fragmented, which it will. "I do not believe in fast-changing enterprises at scale," Jones says flatly. "A lot of enterprises move like dinosaurs." The long-term risk is standardization—if MCP becomes universal, managed integration loses value. But that's years out, if it happens at all.

Layer Five: Stripe Solves the Last Human Bottleneck

Agents have been able to do almost everything except the part where they need to create accounts and provision infrastructure—that's always required a human for authentication. Stripe Projects, launched last week, closes that gap.

Agents can now use CLI commands to provision databases, upgrade hosting tiers, handle payments. Databases are ready in 350 milliseconds. Everything scales to zero when inactive. "Every design choice is optimized for how quickly an agent can provision something the agent is building," Jones notes. "It's not for human-speed dashboard clicking."

This is brand new infrastructure, but it's immediately fundamental. Stripe made the right call (as Stripe tends to do) focusing on agent legibility first, human observability second.

Layer Six: Orchestration Is Wide Open

The biggest gap in the stack is orchestration—making multiple agents work together reliably at scale, with fallback handling, audit trails, cost controls. Gartner reported a 1,445% surge in multi-agent system inquiries between Q1 2024 and Q2 2025.

The problem is that current tooling is at the framework level, not the infrastructure level. LangChain lets you spin up a multi-agent workflow in a notebook, but the gap between that and reliably running 50 agents across enterprise systems with failure recovery and human escalation paths? Everyone's hand-rolling that right now.

What's missing: scheduling and lifecycle management for agents as a managed service. Merge and coordination infrastructure for parallel work. Supervision hierarchies where meta-agents monitor other agents as configurable infrastructure, not hand-coded patterns. Financial observability across workflows. Standard failure and recovery patterns.

"Individual agent capabilities are something we've largely solved," Jones says. "What's been missing is the layer that makes those capabilities composable and parallel and reliable."

That layer is the biggest opportunity in the stack. It's also the one that doesn't exist yet.

The builders who develop what Jones calls "stack literacy" now—who understand which layers are durable, which are transitional, where the platform risks hide—will avoid the reliability failures already trapping teams who moved fast without foundations. Everyone else is building on layers that might not exist in 18 months, using integration patterns that will look like technical debt by 2026.

The infrastructure is being assembled in public. Whether you're paying attention is the only question that matters.

Marcus Chen-Ramirez covers AI, software development, and technology strategy for Buzzrag.