celld v0.5.1 is released~ - Dynamic Workers can enforce CPU time and subrequest limits from WorkerCode.limits - Support for Tail Workers - KV accepts a ReadableStream value in put() - Compaction can read retained LTX bundles after their segments leave the in-memory index, so a slow cell can continue draining its history. - The /evict/ operator route reports a refusal, cancellation, or failure instead of returning success before the eviction completes. - Node.js compatibility improvements

Last month I wrote about how we can build a positive and safe future for everyone: Every lab has the responsibility and incentive to move at the pace required to train its models safely, and the ability to take its own actions to ensure that happens. The reality is: - People won't want to use agents that are misaligned with them and that don't do what they ask, so labs have a strong natural incentive to make their models more aligned. There is a lot of debate about slowing progress on capabilities until alignment catches up. My view is that trust and alignment are quickly becoming the most important capabilities that will differentiate agents and models. Any lab that doesn't focus on alignment will fall behind. - Labs face significant liability if their models cause harm, so they have a strong incentive to prevent this as well. Meta delayed shipping Muse for several months to focus on safety and security. We didn't call for everyone else to do this before we would. We just did it as part of our day-to-day work because it was clearly the right thing for people and for us. I'm proud of the security foundations we've built. - Engaging independent evaluators and advisors is industry best practice. MSL already does this today in several areas because it helps produce better work. Other labs can just do this too. In general, it would be helpful for there to be a larger and more diverse ecosystem of evaluators. - Committing the significant majority of compute towards serving people rather than racing towards recursive self-improvement is one of the best ways to ensure we develop this technology safely. Meta has made this commitment and other labs can do this as well. I believe the key to building a positive future for everyone is maintaining the right balance of power. This is within our power to do.

10% chance of extinction indeed is ridiculous here are my priors for various doom scenarios in next 10 years p(extinction) = 0.0001 p(terminator war) = 0.0002 p(super covid) = 0.001 p(cyber attack that leads to >1k deaths) = .5 p(autonomous weapons used in war) = .9 p(>25% of white collar work disappears) = .9 p(mass fraud) = .99

I want to share how I have developed celld - because it's a bit different and it's working well for me. You might have noticed that the repo is pretty bare - this is because it's an export of a much larger private repo: denoland/celld.dev This larger repo contains: an llm-wiki with an enormous amount of design docs, a large test suite, a spec written in TLA+, the code for the website, scripts for spinning up fleets of celld instances on various clouds and running tests against them, and a speculative centralized managed control plane that I might someday release as a commercial product. My llm-wiki is modified to fit my workflow - diff here I find llm-wiki extremely useful for gathering context. Reviewing wiki/design/ is a primary development activity. celld is open source, but the development happens in private. The test suite and design docs are private. Why do this? First of all, I don't need the public following my every commit - it's oversharing. Secondly, in the age of coding agents, I don't really need external contributors. I'll always appreciate a patch, but most properly reported issues are one-shottable solutions. Third, it's just a bit of IP that might be valuable someday. I do a lot of experiments with celld on Vultr with a VPC. I'll spin up between 2 and 10 VMs at a time, run some experiment, and usually try to tell some story via a chart of some sort (one below). My own coding agent setup is ssh/tmux to mac mini, with various codex and claude sessions running. I don't use an enormous number - something like 2-4 at a time. (Why a mac mini? idk someone just gave me it)

Introducing Dactyl Dactyl is a vibe coding platform for native iOS and native Android apps. What's interesting about it is the device simulator: we've built a SwiftUI renderer in WASM. This means as you're developing, you get low latency in browser canvas simulation of the app to play with. Also things like oauth flows happen in the browser. If the app uses the camera - the browser camera API allows us to display it in the simulator. We also let you connect your ChatGPT subscription so you don't have to buy tokens through us (+ markup) Through [magic] - we can run the same SwiftUI code the agent writes for iOS in android, with native components. This is the work of @undefined_void (primarily), @piscisaureus, myself, and others at Deno. It's built on Durable Objects perhaps unsurprisingly

Experimenting with celld in increasingly pathological situations. After merging the replicated write-behind log, this experiment had 4 instances of celld, each on its own machine, and round-robin kills them every few minutes to see how the fleet handles it. Testing is done at a few layers: a TLA+ model, deterministic simulation testing, typical regression testing, and real life lab experiments like this. Maybe some day I'll be able to experiment with it at discord scale :)

celld v0.3.0 is released. This version contains what (hopefully) will be the last major architecture change: a replicated write behind log. I want celld to be scalable enough to handle a site like Discord. Every channel would be a cell. At an estimated 4B messages per day, before this release celld would be doing ~46k PUTs per second to S3. That equates to $600k/month in write ops alone. In 0.3.0, celld doesn’t write to S3 on each message sent. It buffers before sending off to object store. Cutting it to ~300 PUTs per second, ~$4k per month. But doesn’t that weaken the durability and correctness guarantee? In the new version of celld, writes aren’t ack’d until they’ve been persisted on three disks. And should a crash happen in the short buffer period, it can restore from peers. RPO=0, surviving even the loss of an availability zone. This is the replicated write-behind log. Aside from the cost savings, writes get much faster: ~5ms instead of a ~50ms round trip to S3. This latest release also includes support for the D1 database, crons, azure blob service, in addition to many bug fixes. celld is effectively a database. We take correctness and durability problems seriously. The software is becoming more robust, but do keep in mind this is still a 3 week old project and is labeled as Alpha software. We’re making good progress and hope to raise that to a Beta standing soon. Your bug reports and patches are much appreciated!

celld v0.2 is released - Telemetry support - with the ability to upload parquet files directly to your bucket (use duckdb to query!) - memory usage per cell reduced from ~4mb to ~0.5mb - support for wasm via workers-rs - LTX compaction - more node and web crypto APIs filled in