# Cloudflare Computer

> A virtual filesystem inside a Cloudflare Durable Object that gives AI agents a persistent, SQLite-backed workspace with pluggable execution backends including containers, shell, and JavaScript isolates.

Cloudflare Computer is an open-source TypeScript library published by Cloudflare that gives AI agents a durable, SQLite-backed virtual filesystem running inside a Durable Object. It is currently in preview — suitable for experiments and prototypes but not yet recommended for production use. The project was created in June 2026 and has accumulated over 450 GitHub stars as of early August 2026.

## What It Is

Cloudflare Computer provides a `Workspace` abstraction: a virtual filesystem whose authoritative state lives in SQLite inside a Cloudflare Durable Object. On top of that filesystem, it exposes a single pluggable execution surface — `workspace.runtime` — that can be backed by one of three runtime backends. The result is a self-contained "computer" that an agent can read from, write to, and execute code on, all within Cloudflare's edge infrastructure.

## Three Execution Backends

The library ships three backends that can be registered under stable IDs on the same Workspace:

- **Container** — projects the SQLite state into a sandbox container as a real FUSE mount via a `computerd` daemon. Changes sync back over a capnweb RPC channel. Provides a full Linux userland with real binaries and real network access.
- **Isolate shell** — runs [just-bash](https://github.com/vercel-labs/just-bash) in a Dynamic Worker. It reaches the authoritative Workspace over Workers RPC with no second store or sync round trip.
- **Isolate JavaScript** — evaluates an ECMAScript module in a fresh Dynamic Worker with structured input/results, durable relative imports, configured libraries, Workspace-backed `node:fs/promises`, and trusted `ws:git` and `ws:artifacts` modules.

`workspace.runtime.exec(source, { backend })` is the single entry point; the selected backend determines whether `source` is a shell command or an ECMAScript module. Backends connect lazily on first use, and a Workspace can also be constructed without any backend to use the filesystem alone.

## Repository Architecture

The repo is a monorepo of focused packages:

- **`@cloudflare/dofs`** — the Durable Object SQLite-backed virtual filesystem, sync protocol building blocks, and a `@platformatic/vfs` provider for Node.
- **`@cloudflare/computer-rpc`** — capnweb wire types and server/client helpers shared between the Durable Object and `computerd`.
- **`@cloudflare/computerd`** — the `computerd` daemon: a FUSE mount plus HTTP/WebSocket RPC server that runs inside the sandbox container.
- **`@cloudflare/computer`** — the top-level package consumed by Durable Objects.
- **`@cloudflare/computer-computerd-linux-x64`** — the prebuilt `computerd` binary for linux-x64, distributed for use in container images.

## Performance Characteristics

According to the project's own benchmarks in `docs/19_performance.md`, `computerd`'s FUSE mount beats real disk on metadata-heavy workloads and trails it on large sequential I/O. The docs include `fs-bench` numbers and a `cloudflare/sandbox-sdk` `npm install` comparison with reproduction steps.

## Runnable Examples

The `examples/` directory ships several end-to-end consumers of the public surface:

- **container** and **worker-shell** — identical HTTP `write`/`read`/`exec` surfaces, one using a container and one using just-bash in a Dynamic Worker.
- **worker-javascript** — same HTTP surface but `exec` evaluates an ECMAScript module.
- **think** — a `@cloudflare/think` chat agent that uses the workspace as its working directory, reachable from a terminal.
- **think-compare-runtimes** — a web UI that runs the same agent task against container and worker runtimes side by side.
- **tutorial** — a step-by-step build that writes a markdown recipe card and runs `pandoc` in a container to produce a PDF.
- **artifacts** — generates a Worker project in a workspace and publishes it to Cloudflare Artifacts.
- **assets** — turns a prompt into an image with Workers AI, writes it to the workspace, and returns a shareable link.

## Current Status: Preview

The README explicitly marks the package as **PREVIEW ONLY** — APIs are unstable and the design is subject to change. The `docs/` specification is described as forward-looking intent rather than a description of the current code. The project is MIT-licensed and open source under Cloudflare's GitHub organization.

## Features
- SQLite-backed virtual filesystem inside a Durable Object
- Pluggable execution backends: Container, Isolate shell, Isolate JavaScript
- FUSE mount via computerd daemon for full Linux userland
- just-bash shell execution in Dynamic Workers via Workers RPC
- ECMAScript module execution with durable relative imports
- Workspace-backed node:fs/promises for JavaScript isolates
- Trusted ws:git and ws:artifacts modules
- Lazy backend connection on first use
- Filesystem-only mode without any backend
- capnweb RPC channel for container sync
- Prebuilt computerd binary for linux-x64
- Workers AI image generation integration
- Cloudflare Artifacts publishing support
- Monorepo with focused packages (dofs, rpc, computerd, computer)

## Integrations
Cloudflare Durable Objects, Cloudflare Workers, Cloudflare Containers, Cloudflare Workers AI, Cloudflare Artifacts, just-bash (vercel-labs), @cloudflare/think, @platformatic/vfs, capnweb RPC, node:fs/promises

## Platforms
WINDOWS, LINUX, API, DEVELOPER_SDK, CLI

## Pricing
Open Source

## Version
preview

## Links
- Website: https://github.com/cloudflare/computer
- Documentation: https://github.com/cloudflare/computer/tree/main/docs
- Repository: https://github.com/cloudflare/computer
- EveryDev.ai: https://www.everydev.ai/tools/cloudflare-computer