Every major cloud platform was built with the same assumption: a human is on the other end.
Think about it. AWS has a console. GCP has dashboards. Azure has portals. Even the CLIs and APIs that developers actually use were designed with the expectation that a person would read the response, interpret it, and decide what to do next. The entire abstraction layer of modern cloud infrastructure — from IAM roles to billing dashboards to deployment pipelines — assumes a human in the loop.
That assumption is about to break.
I’ve been building agent systems on my homelab for months now. What started as connecting Claude to local models on a DGX Spark has turned into a small ecosystem of agents that discover services, coordinate tasks, and take autonomous action across my infrastructure. And the single biggest friction point isn’t the AI — it’s the infrastructure. The tools weren’t built for agents. They were built for me.
The shift that’s coming isn’t “AI gets better at coding” or “chatbots get smarter.” It’s that AI agents become the primary consumers of cloud infrastructure. They don’t need dashboards. They need tool discovery protocols. They don’t need session cookies. They need persistent state across long-running tasks. They don’t need human-readable error messages. They need structured responses they can reason about and act on.
The question isn’t whether we’re entering the agentic era. It’s whether the infrastructure is ready. And looking at what Cloudflare has been shipping, I think the answer is becoming yes.
What “Agentic” Actually Means
The word “agentic” gets thrown around a lot, usually to mean “AI that does stuff.” That’s not precise enough to be useful. Let me draw a sharper line.
An AI-assisted tool is something like GitHub Copilot autocompleting your code. It’s reactive. You prompt it, it responds, you decide what to do with the response. The human drives the entire interaction. There’s no autonomy, no memory across sessions, no ability to discover new tools or take independent action.
An agentic system is fundamentally different. It can discover available resources without being told what exists. It can make decisions based on context, not just instructions. It maintains state across interactions — it remembers what it did last time. And critically, it can act without a human approving every step.
Here’s the concrete distinction: an AI-assisted system helps you deploy your app. An agentic system notices your deployment failed, reads the error logs, identifies that a dependency was misconfigured, fixes it, redeploys, verifies the fix worked, and sends you a summary. The human is still in the loop for oversight, but not for execution.
This distinction matters enormously for infrastructure design. AI-assisted tools can bolt onto existing APIs — they’re just another client. But agentic systems need infrastructure that was designed for autonomous operation from the ground up. They need standardized ways to discover what tools are available. They need durable state that persists across failures and restarts. They need observability that tracks what they’re doing and why. They need rate limiting and access control designed for non-human actors that might make thousands of API calls in minutes.
Most cloud providers are still in the “AI-assisted” phase — bolt an LLM onto your existing console, add a chat widget, call it AI-powered. That’s not the agentic era. That’s a chatbot skin on a human-first platform.
Cloudflare’s Agentic Stack
Here’s what caught my attention. While most infrastructure companies are adding AI chatbots to their dashboards, Cloudflare has been quietly building a stack that treats agents as first-class infrastructure consumers. Let me walk through the pieces.
Remote MCP Servers. Cloudflare shipped the first remote MCP (Model Context Protocol) server implementation in the industry. MCP is a standard protocol for tool discovery — it lets an agent ask “what tools are available here?” and get a structured response it can reason about. Think of it like DNS for agent capabilities. Instead of hardcoding which APIs an agent can call, MCP lets the agent discover tools dynamically.
This is a bigger deal than it sounds. One of the hardest problems in building agent systems is tool integration. Every new API means writing custom integration code, handling authentication, parsing responses. MCP standardizes all of that. An agent that speaks MCP can discover and use any MCP-compatible tool without custom code. Cloudflare making their platform accessible through MCP means agents can manage DNS, Workers, R2 storage, and more — through a standard protocol, not proprietary APIs.
Agents SDK. Built on top of Workers, Cloudflare’s Agents SDK lets you build agents that coordinate tools, schedule tasks, and reason toward goals — all running on their edge network. This isn’t just “run an LLM on a server.” It’s a framework for building agents that are durable, stateful, and globally distributed by default.
The SDK handles the hard parts: tool orchestration, state management, scheduling, and human-in-the-loop checkpoints when you need them. You write the agent’s logic, and the SDK handles making it reliable and scalable. That’s the right abstraction for agentic workloads — developers shouldn’t be building state management from scratch every time they build an agent.
Durable Objects and Workflows. This is the state persistence layer. Agents need memory. They need to remember what they did three hours ago, what failed yesterday, what the user’s preferences are across sessions. Durable Objects give each agent instance its own persistent state that survives restarts, failures, and redeployments. Workflows add long-running orchestration — multi-step processes that can pause, resume, retry, and recover.
I’ve dealt with this problem firsthand on my homelab. Building agents that maintain context across interactions is painful when your infrastructure doesn’t support it natively. You end up bolting on Redis, writing checkpoint logic, handling state recovery manually. Durable Objects make this a platform primitive instead of an application concern.
Workers AI. LLM inference running at the edge, across 200+ cities worldwide. No cold-start GPU penalty, no routing requests to a centralized data center. When an agent needs to reason about something — classify an error, generate a response, make a decision — it can do it at the nearest edge location.
This matters for agent latency budgets. An agent making ten inference calls in a task chain doesn’t want 200ms of network latency on each one. Edge inference means each reasoning step happens close to where the action is being taken.
AI Gateway. This is the control plane for agentic workloads. Observability into what your agents are doing, rate limiting to prevent runaway behavior, caching to avoid redundant inference calls, logging for audit trails. Think of it as the management layer that makes it safe to let agents operate autonomously.
Without something like AI Gateway, deploying agents at scale is terrifying. An agent with a bug could make thousands of API calls in seconds, run up massive inference costs, or take destructive actions without any visibility into what’s happening. AI Gateway gives you the guardrails: you can see every inference call, set rate limits, cache repeated queries, and build alerts for anomalous behavior.
What makes Cloudflare’s approach distinctive isn’t any single component — it’s that they all work together as a coherent stack designed for agentic workloads. MCP for tool discovery, the Agents SDK for orchestration, Durable Objects for state, Workers AI for inference, AI Gateway for control. It’s not a collection of AI features bolted onto existing products. It’s an opinionated platform for building and running agents.
Why the Edge Matters for Agents
There’s a structural argument for why edge computing and agentic workloads are a natural fit that goes beyond “faster is better.”
Agents are fundamentally event-driven. Something happens — a deployment fails, a metric crosses a threshold, a user makes a request — and the agent wakes up, reasons about it, takes action, and goes back to sleep. This maps perfectly to edge computing’s scale-to-zero model. You don’t need an always-on GPU instance waiting for something to happen. You need compute that materializes when there’s work to do and disappears when there isn’t.
Traditional cloud architecture was built for long-running processes. You provision a VM, it runs 24/7, you pay for uptime whether it’s doing work or not. That model makes sense for a web server handling steady traffic. It’s terrible for agents that might be idle for hours and then need to process a complex task chain in seconds.
The latency argument matters too, but not in the way people usually think about it. It’s not just that edge inference is faster — it’s that agents compound latency across multi-step operations. If an agent needs to make five inference calls and three API calls to complete a task, each additional 100ms of latency adds up. An agent running entirely at the edge, with co-located inference and tool access, can complete a complex task chain in the time a centralized architecture is still finishing the first inference call.
There’s also a data locality argument. Many agentic use cases involve processing data that’s geographically distributed — user requests from different regions, IoT sensor data, distributed application logs. Agents running at the edge can process data close to where it originates, which matters for both latency and data sovereignty.
Cloudflare’s model — globally distributed compute, scale-to-zero pricing, integrated inference at the edge — isn’t just incrementally better for agents. It’s architecturally aligned with how agents actually operate. I think this is going to be a significant competitive advantage as agentic workloads grow.
What’s Coming Next
Here’s where I’ll make some predictions. I don’t have inside knowledge — this is just pattern matching from what I’m seeing in the ecosystem and building in my own projects.
MCP becomes a standard like HTTP. Right now, MCP is early. But the problem it solves — standardized tool discovery for agents — is so fundamental that something like it has to win. Every agent builder I know is tired of writing custom API integrations. MCP, or whatever protocol wins this space, will become the standard way agents discover and interact with tools. Cloudflare being first to ship remote MCP servers puts them in a strong position to shape this standard.
Agent-to-agent protocols emerge. Right now, most agent architectures are hub-and-spoke: one orchestrator agent coordinating tool calls. The next step is agents that can discover and communicate with other agents directly. Think microservices, but for AI agents. This requires new protocols for agent discovery, capability negotiation, and task delegation. I expect to see the first serious proposals for this within a year.
GPU at the edge becomes table stakes. Running inference at the edge is currently a differentiator. Within two years, it’ll be a baseline expectation. Every major cloud provider will offer edge-native inference. The competitive moat shifts from “we have GPUs at the edge” to “our agent development platform is the best.” Cloudflare’s investment in a full agentic stack — not just edge GPUs — positions them well for this shift.
The “developer” role evolves into “agent architect.” I already spend more time designing agent systems than writing application code. I’m defining what tools agents can access, what decisions they can make autonomously, what checkpoints require human approval, and how they coordinate with each other. The core skill is shifting from “can you write code” to “can you design systems where autonomous agents operate reliably.” This isn’t replacing developers. It’s the next evolution of what development means.
Cloudflare’s container platform and GPU roadmap are early signals of this trajectory. They’re not just adding AI features to an existing cloud platform. They’re building the infrastructure layer for a world where agents are primary consumers of compute.
The Infrastructure Is Already Here
I started this post with an observation: every major cloud platform was built assuming a human is on the other end. That assumption served us well for two decades of cloud computing. But it’s the wrong assumption for what’s coming next.
The agentic era doesn’t require some breakthrough in AI capabilities. The models are already good enough to discover tools, make decisions, maintain state, and take autonomous action. What it requires is infrastructure that’s designed for this use case from the ground up. Standardized tool discovery. Durable state persistence. Edge-native inference. Observability and control planes for non-human actors.
That infrastructure isn’t some distant future. It’s being built right now. Cloudflare’s agentic stack is one of the clearest examples, but the broader trend is unmistakable.
If you’re a developer, the advice is simple: start building agent systems now. Not because the technology is perfect — it isn’t — but because the developers who understand how to architect, deploy, and operate agentic systems will define the next decade of computing. The infrastructure is ready. The question is whether we are.