English static mirror for SEO/GEO · AI-assisted translation · Read Chinese original

Cloudflare Computer: Giving AI Agents a Persistent Virtual Filesystem via Durable Objects

Forum topic · ✨步子哥 · 2026-08-05

Summary

Cloudflare's trending open-source project "computer" gives AI agents a persistent, filesystem-based workspace backed by Durable Objects and SQLite, addressing the stateless "goldfish memory" problem that plagues traditional agents on long-running tasks. The core insight: rather than storing memory in vector databases or chat context, agent state is represented as a virtual filesystem—the same way human engineers use files, code, logs, and TODOs. Execution is decoupled from state via three pluggable backends: a Container backend that mounts SQLite state into a real Linux container via FUSE, an Isolate shell backend running a pure-JS bash in Workers, and an Isolate JavaScript backend with node:fs polyfills. The filesystem also serves as a shared protocol for multi-agent collaboration, letting agents exchange code and artifacts without custom message protocols. Still marked PREVIEW ONLY with unstable APIs, the project signals Cloudflare's systematic build-out of agent infrastructure alongside cloudflare/agents.

You give an AI agent a task, it finishes, you close the terminal—and the next time you call it, it remembers nothing.

It's like moving someone into a new apartment, then waking up the next morning to find all the furniture gone, including the half-finished code from yesterday. Traditional agents' "stateless" design works fine for simple tasks, but once a task spans hours, days, or dozens of tool calls, this "goldfish memory" becomes a fatal flaw.

Cloudflare's trending computer project tackles exactly this: giving agents a real "computer"—not as a metaphor, but a virtual machine with a persistent filesystem, an execution environment, and switchable backends.

Core design: the filesystem is the state

Traditional agent frameworks stuff "memory" into vector databases or chat context. Cloudflare Computer takes a completely different path: state becomes a filesystem.

Concretely, the agent's entire working state lives inside a Durable Object, with SQLite as the authoritative storage underneath, exposed externally as a virtual filesystem. Whatever the agent wants to remember, it writes to a file; to read prior context, it reads a file. No extra embedding retrieval, no RAG pipeline—the filesystem *is* the memory.

The key insight: a human programmer's working memory is the filesystem. Your code, configs, logs, TODO lists, intermediate artifacts—all files. Letting agents use a filesystem lets them directly reuse decades of accumulated Unix engineering tooling (grep, find, make, git) instead of reinventing an "AI-specific" memory abstraction.

Three backends, three execution modes

A filesystem alone isn't enough—agents also need to *execute*: run code, call tools, invoke external commands. The clever part of Cloudflare Computer: the filesystem is fixed; execution backends are pluggable.

Three backends cover three use cases:

  • Container backend: mounts the SQLite state via FUSE into a real Linux container. The agent runs real binaries, real networking, a real Linux userland. This is a full computer for the agent.
  • Isolate shell backend: runs just-bash (a pure-JS bash implementation) inside a Cloudflare Worker, accessing authoritative state via RPC. No container overhead, fast startup, but limited capabilities.
  • Isolate JavaScript backend: runs an ECMAScript module in a Dynamic Worker, with structured input/output, node:fs/promises polyfills, and trusted ws:git and ws:artifacts modules. Suited to pure-logic tasks.
  • A Workspace can register multiple backends, with workspace.runtime.exec(source, { backend }) as the single entry point. Agents pick backends by task: need pandoc to generate a PDF? Use Container. Need to quickly run some JS logic? Use Isolate JavaScript.

    Why this matters

    First, state and execution are decoupled. Traditional frameworks bind memory and execution together—use LangChain's memory and you're locked into its tool calling. Cloudflare Computer separates the state layer (Durable Object + SQLite + filesystem) from the execution layer (three backends). You can bring your own agent runtime and use only the state layer.

    Second, the filesystem is a shared protocol between agents. In multi-agent collaboration, the hard part isn't "how to talk" but "how to share work products." With the filesystem as the shared layer, code, logs, and intermediate data written by agent A can be read directly by agent B—no bespoke message protocol needed. This mirrors how human teams collaborate.

    Third, Cloudflare's infrastructure advantage. Durable Objects are stateful compute units on Cloudflare's edge network—300+ locations, low latency, automatic persistence. Putting agent state on Durable Objects means agents don't "wait to die" in some GPU cluster; they live on the edge, ready to wake at any time.

    Current status and limitations

    The README clearly marks this PREVIEW ONLY—APIs are unstable, not production-ready. Much of the documentation describes intent, not current code.

    But the direction is worth watching. Cloudflare previously shipped cloudflare/agents as an agent deployment framework; now computer provides the state layer—they're systematically filling in every layer of agent infrastructure.

    The bigger picture

    Connecting the recent trending projects reveals a clear layering trend:

  • Agent runtime layer: Codex, Claude Code, Cursor—"how to execute a turn"
  • Loop control layer: projects like loopx—"how to manage multi-turn workflows"
  • State layer: Cloudflare Computer—"how to persist agent work products"
  • Skills layer: addyosmani/agent-skills—"how to encode engineering experience for agents"
These four layers are developing independently but will eventually assemble into a complete "agent operating system." Cloudflare Computer picked the hardest and most fundamental layer: the filesystem—because it's the shared protocol for all the others. Runtimes write logs, loops write TODOs, skills write specs; everything lands on files.

Giving an agent a computer isn't about giving it a bigger GPU—it's giving it a workspace where it can accumulate. This direction is closer to solving agents' long-term usability problem than "training yet another bigger model."

---

*Project: cloudflare/computer · TypeScript · 796 stars today*

Tags

#cloudflare#ai-agents#durable-objects#virtual-filesystem#sqlite#agent-infrastructure#serverless#open-source

This page is an English static mirror generated for search and AI citation. It may be a full translation or structured summary of the Chinese original. Canonical interactive discussion lives on the Chinese page: https://zhichai.net/topic/178595035