Cloudflare just shipped the most complete serverless agent platform to date. Project Think introduces durable execution, sub-agents, persistent sessions, and sandboxed code execution — signaling that agents are becoming infrastructure, not just tools.
Cloudflare's Project Think is not another agent framework. It is a declaration that AI agents need infrastructure-grade primitives to escape the laptop and become scalable, serverless, durable systems. With durable execution via fibers, sub-agents through Facets, persistent tree-structured sessions, sandboxed code execution, and an execution ladder from workspace to full OS sandbox, Project Think maps out what the third wave of agentic AI looks like. For enterprises, the signal is clear: agent infrastructure is now a platform decision, not a DevOps project.
The first wave of agents was chatbots: stateless, reactive, and fragile. The second wave brought coding agents like Claude Code, Codex, and OpenClaw — stateful, tool-using, and genuinely capable. But they run on your laptop, for one user, with no durability guarantees. Cloudflare identified the structural problem: agents are one-to-one. Each agent serves a single user, running a unique task with different ingredients, techniques, and tools every time. This is nothing like traditional applications that serve many users from one instance. A restaurant has a menu and a kitchen optimized for volume. An agent is more like a personal chef. That fundamentally changes the scaling math. If a hundred million knowledge workers each use an agentic assistant at even modest concurrency, you need capacity for tens of millions of simultaneous sessions. At current per-container costs, that is unsustainable. Cloudflare's answer is to stop treating agents as containers and start treating them as serverless actors.
The most important primitive in Project Think is runFiber(). An LLM call takes thirty seconds. A multi-turn agent loop can run for minutes or hours. At any point, the execution environment can vanish: a deploy, a platform restart, hitting resource limits. The upstream connection is severed, in-memory state is lost, and connected clients see the stream stop with no explanation. A fiber is a durable function invocation: registered in SQLite before execution begins, checkpointable at any point via stash(), and recoverable on restart via onFiberRecovered. The SDK keeps the agent alive automatically during fiber execution. For longer operations like CI pipelines or design reviews, the agent starts the work, persists the job ID, hibernates, and wakes on callback. This changes the reliability model from "hope nothing crashes" to "crash recovery is built in." For enterprises, this means agents can run overnight batch processes, long-running analyses, and multi-step compliance checks without requiring always-on infrastructure.
Project Think introduces sub-agents through Facets — child Durable Objects colocated with the parent, each with isolated SQLite and typed RPC. A single agent should not do everything itself. An orchestrator can spawn a researcher and a reviewer, run them in parallel, and synthesize their outputs. Sub-agents are isolated at the storage level: no implicit data sharing, enforced by the runtime where RPC latency is a function call, and TypeScript catches misuse at compile time. This is essentially the agentic mesh architecture built into the platform. For enterprise deployments, this means organizations can decompose complex workflows into specialized agents without building custom orchestration infrastructure. The parent agent becomes a workflow conductor; the sub-agents become domain specialists. Security is structural rather than policy-based because each sub-agent's data is physically isolated.
The experimental Session API in Project Think treats conversation history as a tree rather than a flat list. Each message has a parent_id, enabling forking — explore an alternative approach without losing the original path. Non-destructive compaction summarizes older messages rather than deleting them, while the full history remains in SQLite. Full-text search via FTS5 lets agents query their own past conversations. On top of this, the Think base class adds persistent memory through context blocks: structured sections of the system prompt that the model can read and update over time, surviving hibernation. The model sees something like "MEMORY (Important facts, use set_context to update) [42%, 462/1100 tokens]" and can proactively remember things. This is exactly the four-layer memory architecture we have described for production agents: working memory in the context window, episodic memory in conversation trees, semantic memory in context blocks, and procedural memory encoded in the tools themselves. Cloudflare has built this into the platform rather than leaving it as an exercise for the developer.
Further reading:
See how memory architecture powers production agent systemsProject Think formalizes a capability escalation model that every enterprise agent system needs but few have articulated. Tier 0 is a durable virtual filesystem backed by SQLite and R2 — read, write, edit, search, grep, diff. Tier 1 is a Dynamic Worker: LLM-generated JavaScript in a sandboxed isolate with no network access. Tier 2 adds npm resolution via a worker bundler so the agent can write import statements and have dependencies resolved automatically. Tier 3 is a headless browser for services that do not yet expose APIs or MCP servers. Tier 4 is a full Cloudflare Sandbox with toolchains, repositories, and bidirectional sync to the workspace. The key principle is that the agent should be useful at Tier 0 alone, with each tier additive. The user grants capabilities explicitly rather than starting with a general-purpose machine and trying to constrain it. This is the right security posture for agent infrastructure: begin with almost no ambient authority and grant permissions resource by resource through bindings.
Perhaps the most forward-looking feature of Project Think is self-authored extensions. An agent can write its own TypeScript programs that run in Dynamic Workers, declare permissions for network access and workspace operations, and register new tools that did not exist when the agent started. The ExtensionManager bundles the code, optionally resolves npm dependencies, loads it into a sandboxed worker, and registers the new tools. The extension persists in storage and survives hibernation. The next time the user asks about pull requests, the agent has a github_create_pr tool that it wrote itself thirty seconds ago. This is a genuine self-improvement loop, not through fine-tuning or RLHF, but through code. For enterprises, this means agents can adapt to new systems, APIs, and workflows without waiting for engineering teams to build integrations. The extensions are sandboxed, auditable, and revocable — which makes this far more governable than giving agents unrestricted API access.
Further reading:
Explore why architecture-level controls beat policy-based safetyCloudflare frames Project Think as the third wave of AI agents: agents as infrastructure. Durable, distributed, structurally safe, and serverless. This is the wave where agents move from developer laptops into production systems that any organization can deploy for any number of users. The implications for enterprise strategy are significant. First, agent infrastructure is becoming a platform decision. Organizations will evaluate cloud providers not just on compute and storage, but on native agent primitives: durability, session management, sandboxed execution, and sub-agent orchestration. Second, the cost model shifts from always-on containers to zero-cost hibernation. For agents that are active only a fraction of the time — which is most agents — this changes the economics dramatically. Third, security moves from behavioral policies to architectural controls. Dynamic Workers start with no authority and gain capabilities only through explicit bindings. This capability-based security model is inherently more robust than prompt-based restrictions. Enterprises planning their agent architecture in 2026 should study Project Think carefully. It is not the only platform that will offer these primitives, but it is the most complete articulation so far of what agent infrastructure needs to become.
May 5, 2026
EngineeringApr 27, 2026
Market AnalysisApr 22, 2026
Download our free ebook for a comprehensive guide to deploying autonomous AI agents in your organization.
Get the Free Ebook