Zed is building DeltaDB, a version control system that records every keystroke as an addressable delta and binds your agent conversations to the code they produce. It's a genuine rethink of how teams collaborate with AI. It also asks developers to abandon a workflow that, for all its friction, has quietly become the connective tissue of open source.
Zed has never hidden its disdain for the pull request. In a new post from co-founder Nathan Sobo, the company makes that disdain into a product thesis: the conversation that produces code, increasingly a conversation with an AI agent, is becoming the real source of software, and Git was never built to hold it. Their answer is DeltaDB, a new version control system that records not just commits but every operation in between, and stitches those operations to the chat that drove them.
The pitch is clean. Where Git takes a snapshot at each commit, DeltaDB captures every edit as a fine-grained delta with a stable identity. Because each delta is individually addressable, a reference can point at a specific moment in the code's life and survive as the lines shift around it. A message from an agent and the edit it produced get stored side by side. From any line in a past conversation you can jump to that code as it stands now, and from any line of code you can trace back the conversation, human or agent, that wrote it. Underneath sits a conflict-free replicated data type, so multiple people and agents can edit the same files across different machines, with those files remaining real enough to mount to disk and run your own tooling against.
The argument Zed is actually making
Strip away the version control plumbing and the claim is about timing. Pull requests, review threads, and inline comments all exist, Zed argues, to reattach a discussion to code after the fact, because the discussion and the code lived in separate places to begin with. Put them in the same place and the ceremony dissolves. A teammate joins while the work is still happening, talks to the agent that did the work, and annotates as they go, no commit-and-push required first.
This is a real observation, and anyone who has watched a thoughtful design discussion evaporate into a terse commit message and a thumbs-up emoji on a PR knows the feeling Zed is describing. The most important conversation about a change frequently happens before the change is reviewable, and the current toolchain has no memory of it. In the agent era the gap widens: the prompt history that generated a function carries the actual design intent, and today it lives nowhere durable, scattered across chat panes and terminal scrollback.
This is also consistent with where Zed has been heading. The company shipped collaborative editing early, made noise about not building AI features for the money, and introduced parallel agents in April. DeltaDB reads less like a pivot than the load-bearing wall the rest of the product was leaning toward.
Where the skepticism lives
The counter-case is not that Zed is wrong about PRs being clunky. It's that PRs do more than Zed's framing admits, and the things they do are precisely the things that are hard to replace.
A pull request is a boundary. It marks a point where someone says "this is ready to be judged," and that boundary is what lets a maintainer who has never met you evaluate a contribution from a stranger. Zed's model optimizes for a high-trust team sharing a worktree, which is exactly how Zed itself describes working. But most software on GitHub is not built that way. It's built by loose federations of people who do not share a machine, do not want a live conversation, and specifically value the asynchronous, snapshot-based review that lets them engage on their own schedule. "You shouldn't need to commit to collaborate" is liberating inside a tight team and faintly alarming if you maintain a 4,000-star project and a stranger's agent is editing your worktree in real time.
There's also the lock-in question that any new version control format has to answer. Git won not because its data model was elegant, and it mostly isn't, but because it became the universal substrate. Every CI system, every code host, every IDE, every security scanner speaks Git. Zed is careful here: the post explicitly keeps Git and CI around "for what they're good at," running checks and connecting you to the rest of the world. That's a pragmatic hedge, but it also means DeltaDB has to prove it adds enough on top of a workflow you're still running to justify learning a second model of history. Developers have watched alternative VCS efforts, from Pijul to Fossil to various CRDT experiments, fail to clear that bar despite real technical merit.
Then there's the durability of the conversation itself. The promise that a reference "survives as the code moves underneath it" is the hardest engineering claim in the post and the easiest to oversell. Anchoring annotations to deltas rather than line numbers is a known good idea, but reconciling those anchors across heavy refactors, rebases, and the kind of wholesale rewrites agents love to perform is where these systems historically get messy. The demo will be smooth. The question is what happens after an agent reorganizes a file three times.
What it signals beyond Zed
Whatever happens to DeltaDB specifically, the underlying observation is one a growing number of teams are circling: as agents write more of the code, the artifact worth preserving shifts from the diff to the intent behind it. The diff is increasingly cheap and regenerable. The reasoning, the constraints, the rejected approaches, the "why is it written this way," that's the scarce thing, and it's the thing today's tools throw away.
You can see adjacent bets on the same hunch. Anthropic and others are pushing agent context and memory as first-class concerns. Editors are racing to make agent transcripts persistent and queryable. Zed is making the most architecturally aggressive version of the bet, building it into the version control layer rather than bolting it on, and that's either prescient or premature depending on how quickly the rest of the ecosystem decides that conversation-as-source is a real category.
The beta is a few weeks out, gated behind a waitlist, and Zed is hiring against the thesis. That's the right time to be skeptical and curious at once. The PR is not beloved; it's tolerated, a piece of bureaucratic infrastructure that quietly made global open source collaboration possible. Replacing it requires more than showing that it's annoying. It requires reproducing the trust boundary, the asynchrony, and the universality that made it stick, while delivering enough new value to be worth the switch. Zed has correctly identified the disease. Whether DeltaDB is the cure or just a very elegant diagnosis is the part we'll only learn once strangers, and their agents, start editing each other's worktrees.
The download for the editor itself is available today on macOS, Windows, and Linux, which remains the surest way to judge whether the team building DeltaDB has earned the benefit of the doubt.
Comments
Please log in or register to join the discussion