Git Forgets What Your Agent Did. Zed Just Shipped the Fix.

TL;DR

On August 12, Zed started sending private beta invites for Delta, a brand new application that is deliberately not part of the Zed editor. Delta is a multiplayer environment where you and coding agents work in a shared thread, and where reviewing what the agent built happens in that same thread rather than in a pull request three hours later. Underneath sits DeltaDB, the operation-based CRDT version control layer Zed previewed on June 11. Git stores one snapshot per commit. DeltaDB stores every operation in between and gives each one a stable identity. The first third-party agent harness it connects to is Claude Code, over the Agent Client Protocol. Pricing has not been announced.

What actually shipped

Delta is a separate download, not a Zed plugin. Zed's stated reason is that it needed to build the database and its first application together without either constraining the other, which is the kind of sentence a team writes after a year of discovering that bolting a new storage model onto a mature editor does not go well.

It also runs in a browser. Zed compiles it to WebAssembly and WebGL, so a thread link opens for a teammate with nothing installed. Threads are private until you share them, and per Zed, "every participant gets their own copy of the code on their local machine, kept in sync in real time." That is not a hosted workspace with a shared cursor. It is a replicated worktree.

The pitch: software is made between commits

The argument Zed has been making since June is that Git's unit of history is now the wrong size. When you drive an agent, the interesting record is the prompt, the eleven edits it produced, the two you reverted, and the correction you typed at edit nine. Git sees exactly one thing: the diff you eventually committed, with a message you wrote afterward that describes what you meant rather than what happened.

Think of Git as the family photo album. One posed picture per gathering, and everything that actually happened between the shots is gone forever. DeltaDB is the security camera in the corner that nobody turned off.

Mechanically, DeltaDB breaks work into a stream of fine-grained deltas. Zed's June post puts it plainly: "Where Git captures a snapshot at each commit, DeltaDB captures every operation in between and gives each one a stable identity." Because operations are the unit and the structure is an operation-based CRDT, the same primitive that lets many humans and agents edit one file across machines is also the primitive that gives you history.

Anchors, not line numbers

This is the part that matters most in daily use, and it is easy to skim past. In Delta, comments do not attach to a file at line 214. They attach to a delta. Zed's phrasing: "every reference is anchored to a delta instead of a line number, it survives as the code moves underneath it."

Anyone who has opened a six-day-old review thread and found every comment pointing at whitespace understands the problem. Line numbers are a coordinate system that the next edit invalidates. A delta is an identity, so you can jump from a conversation to the code as it is now, or to the exact state it was in when the agent wrote it, and you can go the other way too: ask which conversations ever touched this line.

The quiet part: Zed already owns the pipe

Delta connects to third-party agent harnesses, starting with Claude Code, and it does so over ACP, the protocol Zed originally built to stop every editor and every agent from writing a bespoke integration for each other. ACP is Apache 2.0, now lives under its own GitHub org at roughly 4,000 stars, and ships official SDKs for Rust, TypeScript, Python, Java, and Kotlin. Its self-description is blunt: "A protocol for connecting any editor to any agent."

The adoption is the story. The protocol's own directory currently lists dozens of agents that speak it, including Codex CLI, Gemini CLI, GitHub Copilot, Cursor, Cline, Goose, OpenCode, OpenHands, Kimi CLI, and Junie, alongside a long tail of editors, CLIs, and desktop clients.

So the sequence reads as strategy rather than luck. Ship an open protocol, get most of the agent ecosystem to speak it, then release the product that treats those agent sessions as first-class objects it can store, replicate, and review. Zed is not trying to win the agent war. It is trying to be the floor everyone stands on.

It is not a Git replacement, whatever the headlines say

Several write-ups framed Delta as replacing Git. Zed's own post does not. It says DeltaDB "works with your existing git repositories," that "every edit and conversation is captured between your commits," and that you commit and push exactly as before. Teammates who never install Delta see an ordinary repository. In the June post Zed was explicit that Git stays for "running checks and connecting you to the rest of the world," and you can mount real files to disk whenever you want.

That is the correct and much less exciting claim. DeltaDB is a layer with finer resolution than Git that hands Git a normal commit at the end. Your CI does not need to know it exists.

What we do not know yet

• Pricing. Not announced. Zed's editor is GPL-3.0-or-later at about 88.5k stars on GitHub, but nothing published so far says DeltaDB or Delta will be open source, and a replicated CRDT worktree implies servers that somebody pays for.
• Access. Private beta. Invites started August 12 and roll out over the following weeks. A product whose thesis is that pull request ceremony wastes your time launched with a guest list, which is at least self-aware.
• Agent coverage. Claude Code is the first harness. ACP makes the others plausible, not present.
• Self-hosting. No published answer. For teams whose code cannot leave their own infrastructure, that is the only question that matters, and a real-time replicated worktree of your source tree is not a small trust ask.
• Scale. No public numbers on repo size, delta volume, or long-lived thread performance. Operation logs grow. Nobody has shown what a two-year-old DeltaDB history costs to sync.

Why you should care

If you drive agents daily, you already run a worse version of this by hand. You keep a terminal transcript because the diff alone does not explain itself. You paste a prompt into the PR description so a reviewer knows what the agent was told. You lose the mid-session correction that was the actual insight. Delta's bet is that the conversation is the source and the code is the output, and that version control should therefore version both.

Whether Zed's product wins is a separate question from whether the abstraction is right. The abstraction looks right. Git was designed for humans making deliberate, sparse commits, and a machine that emits forty edits a minute is a different workload wearing the same clothes.

Key Takeaways

• Zed opened private beta for Delta on August 12, 2026, a standalone app for coding with agents and reviewing the result in the same thread. It is not part of the Zed editor.
• DeltaDB, previewed June 11, is operation-based CRDT version control: Git snapshots at each commit, DeltaDB records every operation in between and gives each a stable identity.
• Comments and references anchor to deltas rather than line numbers, so they survive edits instead of drifting onto whitespace.
• It layers on Git rather than replacing it. You still commit and push, and teammates without Delta see an ordinary repo.
• Claude Code is the first supported harness, connected over ACP, the Apache 2.0 protocol Zed created that dozens of agents and editors now implement.
• Pricing, open-source status, self-hosting, and scale behavior are all unannounced. Judge the abstraction now, the product later.

Sources: Zed, Introducing Delta, Zed, Software Is Made Between Commits, Agent Client Protocol agent directory, ACP client directory, agent-client-protocol on GitHub, zed-industries/zed on GitHub