Open-source project
cloudflare/computer avatar
cloudflare/computer

Cloudflare Computer: a Durable Object filesystem for agent runtimes

GitHub describes it as Give your agent a computer 👾. The repository metadata lists TypeScript as its primary language. The metadata lists the MIT license. This article stays within the project description and details documented in the GitHub repository README.

9,923 stars592 forksTypeScriptMIT

At a glance

What is it?
Cloudflare Computer puts an agent's working directory inside a Durable Object, with three execution backends: a FUSE container, a shell in a Dynamic Worker, and an ECMAScript module runner. Its ContainerBackend and other work-in-progress components are experimental and unsuitable for production use.
Who is it for?
Adopt Cloudflare Computer for prototypes and experiments where you need a durable, SQLite-backed filesystem that multiple agent runtimes can share, and where you accept experimental components and a forward-looking spec that may not match the code. Do not use the experimental components such as the ContainerBackend in production; the README is explicit about that.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository last received commits 2 days ago.
What is it written in?
Mainly TypeScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • cloudflare/computer9,923 ★ · +1,980
Star history
Repository2026-08-132026-11-15
cloudflare/computer7.9k9.9k

1,980 Stars in the last 94 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

What problem it solves and who it is for

Cloudflare Computer gives an AI agent a persistent, programmatic working directory. The problem it addresses is that agents often need to write files, read them back, and execute tools, but they lack a stable place to do it. The project solves this by making the filesystem the authoritative state, stored in SQLite inside a Durable Object. The target user is a developer building agent prototypes on Cloudflare Workers who wants a workspace that survives across invocations and can be shared by different execution runtimes. The README says the package should be considered suitable for production use, but that work-in-progress and experimental components such as the ContainerBackend are unsuitable for production, and that the specification under docs/ is forward-looking.

Architecture: SQLite as the source of truth

The core design is a virtual filesystem that lives in a Durable Object. That Durable Object holds the authoritative state in SQLite. It exposes a single execution surface through workspace.runtime, and the runtime.exec(source, { backend }) call is the one entry point for running code. The backend parameter decides whether source is a shell command or an ECMAScript module. Backends connect lazily on first use, and a Workspace may register multiple backends under stable IDs. The workspace can also be constructed with no backend at all, giving you the filesystem alone. This separation is the key architectural choice: the filesystem is not tied to any particular execution model, so you can swap runtimes without migrating data.

The three backends: container, shell, JavaScript

The container backend projects the SQLite state into a sandbox container as a real FUSE mount. A daemon called computerd runs inside the container, mounts the state as a filesystem, and syncs changes back over a capnweb RPC channel. This gives you full Linux userland, real binaries, and real network. The isolate shell backend runs just-bash in a Dynamic Worker and reaches the authoritative Workspace over Workers RPC, so there is no second store and no sync round trip. The isolate JavaScript backend runs an ECMAScript module in a fresh Dynamic Worker with structured input and results, durable relative imports, configured libraries, Workspace-backed node:fs/promises, and host modules such as codemode:git, codemode:artifacts and codemode:container. The trade-off is clear: the container gives you fidelity at the cost of a daemon and a sync protocol, while the Worker-based backends are lighter but constrained to what a Dynamic Worker can do.

Getting it running: install and examples

To use Cloudflare Computer, you install the @cloudflare/computer package and follow its README, which contains installation steps, an entrypoint map, and worked examples of the fs and runtime surfaces. The repository includes runnable examples in the examples/ directory, each a Worker workspace with its own README. The container example runs computerd inside a container, mounts a workspace, and talks to a Durable Object over capnweb, exposing a write/read/exec HTTP surface. The worker-shell example uses the same HTTP surface but runs just-bash in a Dynamic Worker loaded through env.LOADER, with no container. The worker-javascript example mirrors worker-shell but evaluates an ECMAScript module in a Dynamic Worker. There is also an egress example that sends one URL through all three backends with matching none, all, or custom egress policies, which is useful for testing network access controls. The tutorial example walks through building one endpoint and an agent that writes a markdown recipe card on the host and runs pandoc on it in the container to produce a PDF.

Performance characteristics and what they mean

The container backend is the only one that gives a real FUSE mount: computerd mounts the SQLite state inside the sandbox and syncs changes back over a capnweb RPC channel. The isolate shell backend reaches the authoritative Workspace over Workers RPC, so there is no second store or sync round trip. Benchmark your own access pattern before choosing a backend.

Limitations and failure modes

The most obvious limitation is the preview status. The README warns that the package contains work-in-progress and experimental components such as the ContainerBackend, which are unsuitable for production use, and that the specification under docs/ is forward-looking, meant as intent rather than a description of the code today. That means the docs may describe features that are not implemented. Another limitation is the complexity of the container backend: it requires a daemon (computerd), a FUSE mount, and a capnweb RPC channel, which is a lot of moving parts for a prototype. If the sync protocol fails, the filesystem state could diverge from the container view. The Worker-based backends avoid that by reaching the authoritative Workspace directly over Workers RPC, but they are constrained to just-bash or ECMAScript modules, so you cannot run arbitrary Linux binaries. The ContainerBackend in particular should not be used in production.

Alternatives and how they differ

The closest alternative is a plain Durable Object with its own SQLite storage and a custom execution layer, which is what Cloudflare Computer abstracts away. The difference is that with Cloudflare Computer you get a ready-made virtual filesystem with a runtime.exec entry point and pluggable backends, so you do not have to design the sync protocol or the FUSE mount yourself. Another alternative is to run an agent in a traditional sandbox like a VM or a container with a real disk, and skip the Durable Object entirely. That gives you a real filesystem with no sync overhead, but you lose the durability and location independence of a Durable Object. The just-bash approach, which Cloudflare Computer uses for its shell backend, is itself an alternative if you only need shell commands and no persistent filesystem. The key difference is that Cloudflare Computer makes the filesystem the source of truth, while alternatives treat the filesystem as ephemeral or as a side effect of execution.

Maintenance, upgrade cost, and license

The project is MIT licensed, so you can use and modify it freely. The README points to CONTRIBUTING.md for feedback, and approved collaborators follow COLLABORATORS.md for setup, build, and test instructions. The release cadence is recent: versions 0.7.0 (2026-10-23), 0.7.1 and 0.8.0 (both 2026-10-26) came out within four days, which suggests active development. The upgrade cost may be high because the package releases quickly, contains experimental components, and the spec is forward-looking. The repository is a small monorepo with packages for dofs, rpc, computerd, and the top-level computer package, plus a private Docker image context for the prebuilt computerd linux-x64 binary. Before adopting it, plan to track releases closely and expect to adapt your code frequently.

Editorial conclusion

Adopt Cloudflare Computer for prototypes and experiments where you need a durable, SQLite-backed filesystem that multiple agent runtimes can share, and where you accept experimental components and a forward-looking spec that may not match the code. Do not use the experimental components such as the ContainerBackend in production; the README is explicit about that. Before building anything, verify which backends actually work today, read the package READMEs for installation steps and entrypoint maps, and check the docs/ spec against the code to see which parts are implemented. The container backend is the only one with a real filesystem mount; the shell and JavaScript backends reach the workspace over Workers RPC, so choose based on whether you need full Linux binaries or just lightweight execution.

Frequently asked questions

Is Cloudflare Computer safe for production use?

Partly. The README says the @cloudflare/computer package should be considered suitable for production use, but that it contains work-in-progress and experimental components such as the ContainerBackend, which are unsuitable for production use.

How do I install Cloudflare Computer?

The top-level project page does not carry the install steps. It directs you to install @cloudflare/computer from packages/computer/README.md and follow that package's README, which has the installation steps, the entrypoint map, and worked examples of the fs and runtime surfaces. To work in the repository itself, npm install at the root also runs the type generation step.

What execution backends does Cloudflare Computer ship?

Three: a Container backend that projects SQLite state into a sandbox as a FUSE mount with a computerd daemon syncing changes over capnweb, an isolate shell backend running just-bash in a Dynamic Worker over Workers RPC, and an isolate JavaScript backend running an ECMAScript module in a fresh Dynamic Worker with Workspace-backed node:fs/promises plus host modules such as codemode:git, codemode:artifacts and codemode:container.

How does Cloudflare Computer perform on file operations?

The container backend mounts the SQLite state as a real FUSE mount in the sandbox and syncs changes back over capnweb, while the isolate shell backend reaches the authoritative Workspace over Workers RPC with no second store or sync round trip.

How do container scheduling policies differ in Cloudflare Computer?

With scheduling_policy set to durable_object, the Durable Object schedules the container itself and the launch call names the image and instance size, moving both out of the config. The container-legacy example keeps the platform in charge, sizing the container from a containers block, while exposing the same write, read and exec HTTP surface.

Official sources

  1. Official README
  2. Project repository
  3. Release notes
Community

Where developers are discussing it

Posts on Hacker News, dev.to and Lobsters that link to this repository, found by our scan of those communities. 1 in the last 30 days; newest first.

Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/cloudflare-computer.svg)](https://hysenlabs.com/projects/cloudflare-computer)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/cloudflare-computer.svg)](https://hysenlabs.com/projects/cloudflare-computer)

Was this useful?