The rise of autonomous AI agents has shifted how software interacts with the world.
Where earlier systems followed fixed scripts, agents now reason through tasks, call tools, inspect intermediate results, and adjust their next steps. This flexibility comes with a practical requirement: the agent needs a place to work.
It needs files it can read and write, a shell it can run commands in, and a way to keep that working state consistent across multiple steps.
Without those pieces the model is limited to pure text generation or to narrow, pre-defined function calls.
For most of the past year the default answer has been a container.
Spin up a Linux environment, drop the agent inside it, and let the model treat the container as its computer. The approach works, yet it scales poorly. Containers consume relatively large amounts of memory and CPU even when idle, start-up times are measured in seconds rather than milliseconds, and the global pool of available compute is finite. If every user session or background task eventually requires its own long-lived container, the arithmetic quickly becomes untenable once agent deployments move from thousands to millions of concurrent instances.
An alternative path has therefore begun to take shape.
And Cloudflare is trying to help.
Cloudflare is a global cloud platform that acts as a "reverse proxy" between website visitors and host servers to optimize website security, speed, and reliability.
It is introducing Cloudflare Computer with the idea of improving how the so-called "harness", or the brain" of AIs work, so they can stay lightweight and stateful while the actual work of editing files or executing code is handed off to short-lived, sandboxed tools.
The separation keeps the expensive parts of the stack under tighter control.
Cloudflare previews the open-source package @cloudflare/computer, which takes that separation further by giving each agent a durable, shared filesystem that can be operated on by two different kinds of execution environment.
According to its GitHub page, Cloudflare Computer is a virtual filesystem that lives inside a Durable Object, and is backed by SQLite. The Durable Object holds the authoritative state in SQLite and exposes one pluggable execution surface through workspace.runtime.
It can be populated from a git repository, an object-storage bucket, or any other source the developer chooses.
Once the workspace exists, the agent receives a familiar set of tools: read, write, edit, list directory contents, and execute shell commands.
Behind those tools sit two backends.
The first runs inside a V8 isolate. Shell commands are translated into JavaScript and executed in a Dynamic Worker that talks directly to the same Durable Object storage; there is no second copy of the data and no network round-trip for synchronization. The second backend mounts the identical filesystem into a full Linux container through FUSE.
When the agent needs npm, a native binary, or any other capability that only a complete userland provides, the runtime routes the request to the container.
Changes made inside the container are written back to the shared SQLite store so the isolate side remains consistent.
Because the model itself chooses which backend to use, most routine operations stay inside the isolate.
File manipulation, simple data processing, and many git operations can be completed without ever starting a container. Only the minority of tasks that truly require a full Linux environment incur the heavier cost.
The package exposes an AI-SDK-compatible tool set so existing agent frameworks can adopt the workspace with minimal changes. All operations are gated by permissions, logged, and observable, giving developers a clear audit trail of what the agent actually did.
In an era when agent workloads are expected to grow rapidly, the hybrid design addresses two constraints at once.
It supplies the familiar computer-like interface that models already know how to use, and it does so while keeping the majority of compute on the far more elastic isolate substrate.
The result is not a replacement for containers but a way to use them sparingly, reserving full Linux environments for the moments they are genuinely required. The package is still an early preview, with APIs subject to change, yet the underlying pattern illustrates one concrete route toward making large numbers of persistent, tool-using agents practical.
