The cloud we have today is built for us. Every layer assumes a human is there: dashboards to glance at, pages designed to hold attention, interfaces tuned for how we read and make decisions. But agents don’t need any of that. They don’t get distracted. They don’t fatigue. And they have completely different requirements around speed, structure, and access patterns.
I’ve been thinking about this distinction more since Anthropic framed the question differently than I expected: instead of asking what WE think agents need, we should ask what agents actually NEED. That’s a fundamental shift in how we approach infrastructure.
Rethinking the Stack from Agent-Up
For years, we’ve retrofitted new technologies onto human-centric systems. Mobile came and we made responsive UIs. APIs came and we wrapped web interfaces around them. Cloud came and we containerized our monoliths. Each time, we were translating the old into the new rather than building native.
Agent infrastructure demands we think differently. An Agent Cloud needs to handle primitives that don’t map to human workflows: structured execution environments where ambiguity is eliminated before it starts, compute resources that scale horizontally for massive concurrent task execution, and storage systems organized around agent queries rather than human browsing.
The implications here are significant. Developers building for agents need to think in terms of state machines, deterministic execution, and structured outputs. This is closer to how we built financial systems or telecommunications networks than how we’ve built cloud applications for the last decade. If you’ve been deep in the AI infrastructure space, you already feel this tension.
But here’s the catch: we can’t just burn everything down and rebuild. We still need to operate in the human world. Our agents need to interact with systems built for people. They need to pay for things, access databases, read emails, and navigate the web as it exists today.
The Translation Layer
This is where the real architectural challenge lives. An Agent Cloud isn’t just infrastructure for agents OR infrastructure for humans. It’s a translation layer that lets both thrive simultaneously.
For the agent side, this means building primitives from the ground up: deterministic execution layers, structured schemas for every interaction, audit trails that actually matter, and access controls that operate at the granularity agents need. When an agent needs to read a document, it shouldn’t get a webpage. It should get structured data.
For the human side, we maintain the familiar interfaces and control points. We need dashboards that show what agents are doing, approval workflows for sensitive operations, and the ability to intervene when things go sideways.
Developers caught in the middle here face a new kind of complexity. You’re not just writing code anymore. You’re designing agent workflows, defining execution primitives, thinking about how humans and agents collaborate on problems. This is what an updated SDLC for agents actually looks like.
What This Means for Security and Control
The translation layer becomes critical when we talk about security. Organizations need their agents to have deep access to systems of record to do meaningful work. But giving an agent unfettered access to your data is terrifying. The Agent Cloud needs fine-grained access controls that let humans define exactly what an agent can do, with what data, under what conditions.
This isn’t just role-based access control anymore. It’s temporal controls, context-aware access, audit events at every step, and the ability to revoke permissions retroactively if something goes wrong. The infrastructure has to assume agents will make mistakes and build in guardrails accordingly.
For developers, this means understanding your agent’s capabilities and limitations at a much deeper level. You’re not just deploying code and hoping it works. You’re orchestrating interactions between autonomous systems, human oversight mechanisms, and corporate data in ways that are simultaneously secure and useful.
The Web in an Agent-Native World
What does the web look like when agents are first-class citizens? Discovery becomes different. Payment flows become different. APIs that were designed for occasional human-triggered requests now need to handle millions of agent queries. The web we’ve built for browsing is fundamentally different from the web agents actually need.
This is the five-day journey Anthropic is taking us through with Agents Week: thinking through primitives, execution layers, development lifecycles, security models, and what the agentic web actually looks like when we stop forcing agent-shaped problems into human-shaped tools.
The question isn’t abstract anymore. It’s practical: what does YOUR agent need to actually get work done?