Cloudflare announced Project Think during Agents Week 2026 as the next layer for its Agents SDK: a set of primitives that turn stateless agent loops into long-running, crash-safe workers with their own sandboxed sub-agents and persistent sessions. Alongside it shipped Agent Lee, a built-in dashboard agent that already handles around a quarter of a million tool calls a day in beta. This guide explains what Project Think actually changes for mobile, automation, and orchestration teams, and where it fits next to n8n, Hermes, and OpenClaw.
Most production agents today still die when the box reboots. The process holds the plan, the call stack holds the state, and a single failed step throws the whole run away. Project Think is Cloudflare's answer to that problem: durable execution with fibers, isolated sub-agents with their own SQLite and typed RPC, and persistent sessions that survive deploys. The shipping target is the Cloudflare Agents SDK, available as @cloudflare/think.
The 30-Second Version
What Project Think Actually Ships
Project Think is not one feature. It is a small bundle of primitives that together push the Agents SDK from stateless orchestration into a durable actor model:
- Durable execution with fibers — checkpointing, automatic keepalive, and crash recovery so a long run resumes from the last safe step instead of starting over.
- Sub-agents — isolated child agents with their own SQLite database and typed RPC interface, so a parent can spawn workers without sharing memory by accident.
- Persistent sessions — conversation and tool state survive across deploys, region failover, and reconnects from a mobile client.
- Sandboxed code execution — agents can run generated TypeScript inside a sandbox without escaping the worker boundary.
- An opinionated base class — wires the primitives together so you do not glue them by hand on every project.
The shape matters. Each primitive is small enough to adopt independently, and together they remove most of the "why did the agent forget" bug class that haunts long-running automation.
Why Durable Execution Changes the Design
Once a run can be paused, persisted, and resumed, the design space for agents widens in three concrete ways:
Long waits become free
A workflow can wait hours for a webhook, a human approval, or a slow third-party job without holding a process open. The fiber sleeps and wakes on the event. That changes the cost story for any agent that used to keep a worker warm just to wait.
Crash recovery stops being your problem
If the runtime checkpoints after each tool call, a crash mid-run resumes at the last safe step. You do not write your own resume logic, and you do not duplicate side effects on the retry. That alone removes a lot of bespoke queue plumbing.
Sub-agents stop leaking state
Each sub-agent gets its own SQLite and a typed RPC contract. A parent cannot accidentally read a child's working memory, and a child cannot mutate the parent's plan. That makes multi-agent flows much easier to reason about than shared-context patterns.
The unit of work moves from "a request handler that calls an LLM" to "a durable actor that owns its plan and its children". The runtime, not your code, keeps the run alive.
Project Think vs. The Stack You Already Have
Project Think does not replace n8n, Hermes, or a Conductor-style router. It sits at a different layer. The clearest way to see it is side by side:
| Layer | Tool | What it owns |
|---|---|---|
| Visual workflow | n8n | Triggers, integrations, human-readable flow steps |
| Mobile orchestration | Hermes Workspace | Phone-side approvals and an agent control plane |
| Routing | Sakana Conductor | Picks which model handles which subtask |
| Durable runtime | Cloudflare Project Think | Crash-safe execution, sub-agents, persistent sessions |
| Dashboard agent | Agent Lee | Operates Cloudflare resources from the UI you already use |
A real production stack will likely use several of these. n8n keeps the human-readable map of a flow. Hermes is the phone for approvals. Project Think is the engine that makes the long-running parts of that flow survive a bad night.
Agent Lee, and Why It Matters
Agent Lee is the first first-party UI built on the Project Think stack. It lives inside the Cloudflare dashboard, knows your Workers, zones, DNS, and error rates, and lets you act on them in plain language. Cloudflare reports around 18,000 daily users and roughly a quarter of a million tool calls per day during the active beta.
The interesting part is not the chat box. It is the proof point. A dashboard agent that touches real production resources is exactly the kind of long, branching, crash-prone task that needed durable execution and isolated sub-agents to be trustworthy. If Cloudflare runs Agent Lee on Project Think, the primitives are tested at scale before you adopt them.
Why This Matters for Mobile Automation
Five Practical Use Cases for Halmob-Style Stacks
n8n flows that wait days, not seconds
Move the long-waiting branches of an n8n flow (contract approval, invoice review, scheduled escalation) into a Project Think durable agent. The n8n side stays as the visual map. The Cloudflare side owns the wait and the resume.
Mobile assistant with crash-safe sessions
A user starts a request on the phone, switches networks twice, and comes back an hour later. Persistent sessions mean the agent picks up exactly where it stopped, with the same plan, the same tool history, and the same approval state.
Sub-agents per integration
Each integration (CRM, billing, calendar) gets a dedicated sub-agent with its own SQLite. The parent only sees the typed RPC surface, so an experimental new integration cannot corrupt the rest of the flow when it misbehaves.
Background research that survives deploys
Long-running research or data-collection tasks no longer have to pause on every deploy. The fiber checkpoints, the deploy ships, and the next step picks up on the new code path with the same plan.
Operational agents that touch real infrastructure
Agent Lee shows the pattern: a chat surface that reads and changes production resources, with a durable trail behind every action. Project Think is what makes that safe enough to put in front of an operations team.
How to Get Started
- 1Read the Project Think announcement on the Cloudflare blog and skim the Agents SDK reference for the new primitives.
- 2Pick one existing automation that has a long wait or a flaky resume story. That is the cheapest way to feel the value of durable execution.
- 3Wrap that flow in a Project Think agent. Move the wait into a fiber. Add a single sub-agent for the most fragile integration.
- 4Instrument the run. Log every checkpoint, every sub-agent call, and every resume. The log is what you will use later to argue for or against expanding the pattern.
If you are still mapping out the agent layer, our OpenClaw 101 guide explains the building blocks (tools, skills, permissions, memory), and the orchestration era of agentic coding post sets the broader context Project Think slots into.
The Bottom Line
Project Think is not a new model and it is not a new harness. It is the runtime layer the Agents SDK was missing: durable execution, isolated sub-agents, and persistent sessions, wrapped in an opinionated base class. Agent Lee is the proof that the stack works under real load. For a team that already builds with n8n, mobile orchestration, or a router-style agent pattern, this is the piece that makes the long parts of the flow survive a bad day.
The question to take into your next sprint is simple. Which of your current agents would behave better if the runtime, not your code, kept the run alive across crashes, deploys, and long waits?