Today we're introducing Delta, a multiplayer environment for coding with agents and reviewing what they build, and we're inviting the first users into our private beta. Delta keeps code and conversations connected, so developers and agents can work together with the full context of how the code came to be.

Delta is the second half of a plan we've been executing for years: to build the best place to write code, then make it the best place to talk about code. When we first started out, not everyone understood why you'd want to have a conversation inside your IDE. Then came agents, and now talking about code is how software gets written.

To support our collaborative vision, we built DeltaDB, which replicates the conversation and the worktree together, in real time, for everyone in a thread. DeltaDB works with the git repository you already have. Every edit and conversation is captured between your commits. You can commit and push like you always did, and teammates who never open Delta see a normal git repo.

We could have added DeltaDB to Zed, and eventually we will. But the best possible experience required an entirely new kind of application. Building Zed made performance and craft an obsession for us, and Delta is built on those same principles.

On a commit-based platform, comments attach to snapshots and fall out of date as soon as the code changes. In Delta, you and your team can comment on anything: the conversation, or any line of code in the worktree, whether an agent touched it yesterday or a human wrote it three years ago. Everyone sees every comment in place, anchored to the code as it evolves, connected to the conversations that produced it.

And the agent is right there in the thread, working from the same original conversation and decisions as you. When something looks wrong, you don't reconstruct intent from a diff. You ask the agent to explain it or fix it. Review stays connected to the conversation and code as both evolve.

Over time, that context helps future teammates and agents understand not only what the code does, but why it took its current shape. The history stays with the code in DeltaDB, and it surfaces right where it's relevant.

Invite your team into the conversation with a click. Threads are private until you share them, and only the people you invite can see the conversation and the code. They join as first-class participants who can explore the thread, comment alongside you in real time, or continue a task later. When a teammate picks up the work, they never have to wonder whether the latest code was committed or pushed.

DeltaDB makes the worktree itself collaborative. Every participant gets their own copy of the code on their local machine, kept in sync in real time as the work happens.

DeltaDB also brings multiplayer to the cloud. Move your work to a cloud runner, close your laptop, and the agent keeps going while its conversation and code stay synchronized with the thread.

Share any thread with a link, and your teammate can open it in a browser without installing anything. Delta.dev isn't a second-class version of Delta built in JavaScript and HTML. We wanted to bring you the same Rust application, compiled to WebAssembly and rendered through WebGL, so your teammate gets the same experience you do.

Delta also connects to third-party agent harnesses, starting with Claude Code. Keep working in the terminal you already use, and your session syncs live into a Delta thread. Share it, and teammates can watch the conversation and code evolve, comment in place, and pick up the work with full context.

Agents produce more text and bigger changes than any human, and most tools cope by hiding things (e.g. collapsing diffs, truncating transcripts, summarizing what you should be able to read). We've spent over a decade building text editors, so this is exactly the problem we know how to solve. In Delta, diffs open in full, transcripts stay whole, and everything renders as fast as your model can emit it.

Showing everything only matters if you can act on it. In most agent tools, the conversation is something you watch. Output streams past, and your only way to respond is the text box at the bottom. Reacting to three parts of a plan means three serial messages, or hoping the answers don't tangle.

In Delta, the conversation is a document, and your cursor works everywhere in it. Move through the thread with the same keyboard motions you use on code. When you want to respond to something, put your cursor on it and start typing. Comments attach to the exact text they're about, and nothing in the thread is off limits: a line of the diff, a step in the plan, a thinking block. The agent sees precisely what you mean, and so does everyone else.

If you've followed our work on DeltaDB, you know we haven't been specific about how the capabilities we've been building would actually reach you; that was deliberate. For a long time we assumed the answer was Zed, but as DeltaDB took shape, we realized we needed to develop it without constraints so the database and its first application could shape each other, rather than fitting new primitives into an existing editor. And rebuilding Zed's foundations underneath hundreds of thousands of daily users would have meant disrupting the workflows they rely on every day.

So DeltaDB's first client became a new application, engineered around its replicated abstractions from day one, with the conversation instead of the editor at the center. The thread is where software happens now, and the interface should reflect it.

Delta gives us a focused place to iterate quickly and improve the primitives through real product use. We'll keep developing Zed, and DeltaDB will come to it, but Delta is where it begins.

The first invites to the private beta have gone out today. We'll be inviting more users over the coming weeks. Sign up if you want early access.