Serverless Objects: durable state for agents, on your own hardware.

#What Serverless Objects is

Agents need durable state, scheduled wakeups, long-lived connections and sandboxes. The Durable Objects model fits that well, and the Cloudflare Agents SDK is built on it. Some teams can't run it on Cloudflare's network: regulated industries, air-gapped environments, customer VPCs, or cost at scale.

Serverless Objects is the operating layer that lets you run that model on your own hardware. You deploy an ordinary Wrangler project, and sobjects runs it on a host you control with TLS ingress, a local dashboard, engine upgrades and service units. Durable Object state lives in your own bucket. The engine today is celld, Deno's Apache-2.0 runtime for Wrangler bundles, with a Node-native engine in progress.

#Get started

You need Node.js 22 or later. Write a Durable Object exactly as you would for Cloudflare, then run it locally; no bucket is needed:

npm i -g serverless-objects
sobjects dev . --port 8787

To run it as a node, add a sobjects.toml that points at an S3-compatible bucket you control (Cloudflare R2 and SeaweedFS are tested), then:

sobjects deploy .        # bundle the app and upload it to the bucket
sobjects up --detach     # start the node on 127.0.0.1:8080

State survives sobjects down and up because it lives in the bucket. sobjects service install generates a systemd or launchd unit, and there's a Docker Compose bundle too. The install guide adds TLS ingress and the dashboard.

#What you get today

• The sobjects CLI. dev, deploy, up, down, status, logs, upgrade (checksum-pinned engine versions with rollback) and service. Unknown Wrangler config keys are rejected with a readable error.
• Agent runs as objects. One Durable Object per Autopilot run holds its state, budgets, timers and an event log that streams from a cursor, with a registry per workspace. Stop the node mid-run, restart it, and the run resumes from where it was while its Hotcell sandbox keeps working.
• A Hotcell Sandbox binding. It has the Cloudflare Sandbox SDK's call shape and reattaches to its sandbox after the object is evicted. With egress enabled, sandboxes get gateway tokens, never real provider keys.
• TLS ingress. Static certificates or ACME HTTP-01, hostname routing, WebSocket tunnelling, HTTP-to-HTTPS redirects and JSON access logs.
• A local dashboard and admin API. Node load, the objects in each namespace, a key-value browser and read-only SQL console per object, eviction, JSON export and Prometheus metrics. It listens on loopback only.
• A native engine, in progress. sobjects dev --engine native runs Workers and Durable Objects directly in Node, each object in its own SQLite file, with full Node APIs and npm packages, including native addons. --backup-bucket copies objects to S3-compatible storage and restores them onto an empty disk, and with --backup-mode durable every write is in the bucket before it's acknowledged; --threads N spreads objects over worker threads and replaces any that stall or crash. Autopilot can run in-process inside an object.
• A portability check. sobjects build --strict flags code that wouldn't run on Cloudflare.
• A conformance suite that runs the same apps under wrangler dev and the engine. The latest results pass every check on real Cloudflare (17/17), Wrangler (16/16), celld (17/17) and the native engine (17/17), covering IDs, KV and SQL storage, transactions, input gates, RPC, alarms across a restart, WebSockets with hibernation, and the Agents SDK. See the results, and the benchmarks that run one app on all four.

#What's not there yet

Be clear-eyed about the pre-alpha. It runs on a single host. Sockets moving between nodes, facets, PartyServer, and the Agents SDK's chat, MCP and Workflows features aren't covered by the conformance suite. There's no point-in-time restore on celld yet; JSON export is available instead. The native engine is for trusted code: worker threads are not a security boundary, and by default its writes reach the bucket only with the next backup, so a lost machine can lose the last few seconds of writes. --backup-mode durable closes that gap at some cost in speed. Running across several nodes is designed but not built yet.

#Roadmap

The project's milestones, with target dates rather than promises. Milestones are named separately from npm release numbers.

#Where it fits

Serverless Objects is an independent open-source project, not affiliated with or endorsed by Cloudflare. Cloudflare, Workers and Durable Objects are trademarks of Cloudflare, Inc.

FAQs

Is Serverless Objects ready for production?

Not yet. It's pre-alpha: good for evaluation and testing, on a single host running macOS (Apple Silicon) or Linux (arm64 or x64). Multi-node operation, point-in-time restore, SSO and audit logs are on the roadmap.

Do I need a Cloudflare account?

No. Everything runs on your own machines. Local development with sobjects dev needs nothing else. To run a node, Durable Object state lives in an S3-compatible bucket you control, set in sobjects.toml; Cloudflare R2 and self-hosted SeaweedFS have been tested. Credentials come from the environment, never the config file.

Will my existing Workers project run unchanged?

Often, but check first. The celld engine runs Wrangler bundles with Durable Objects, KV, D1, R2, Queues, Workflows and Containers. Workers AI, Vectorize, Hyperdrive, Browser Rendering and Email Workers are not provided, and Durable Object rename, delete and transfer migrations are rejected. The compatibility table on GitHub lists what has been tested.

Can I move back to Cloudflare later?

That's the design rule: the Workers and Durable Objects APIs are the contract, so an app that runs here should run on Cloudflare and the reverse. sobjects build --strict checks that an app stays portable.

Does it run the Cloudflare Agents SDK?

Partly, and it's tested. The conformance suite covers the Agents SDK's state, SQL, schedules, addressing and @callable() RPC on both engines. Chat agents, MCP, Workflows and PartyServer aren't covered yet.

What is celld, and what is the native engine?

celld is Deno's Apache-2.0 runtime for Wrangler bundles and the supported engine today, pinned to a tested release. The native engine, in progress, runs Workers and Durable Objects directly in Node with full Node APIs inside objects; it passes the full conformance suite, backs objects up to an S3-compatible bucket with --backup-bucket, and spreads objects over worker threads with --threads, replacing stalled or crashed threads. It is meant for trusted code. Try it with sobjects dev --engine native.

How fast is it compared with Cloudflare?

On one machine, much faster per call, because there is no network hop to the object. In the project's benchmark, a Durable Object write from the Worker took about 19 ms on Cloudflare, 9 ms on celld and 0.05 ms on the native engine. The guarantees differ: Cloudflare and celld acknowledge a write only once it's durable. The native engine by default commits to a local SQLite file and copies it to the bucket within seconds; with --backup-mode durable it also holds each result until the write is in the bucket, which is slower but loses nothing if the disk dies.

How does it relate to Autopilot and Hotcell?

It's the state layer of the Directionally Local stack. Its Hotcell Sandbox binding lets an object start sandboxes that never hold a real API key, and Autopilot runs can live as durable objects: stop the node mid-run, restart it, and the run resumes from its saved position.