Delta (by Zed)

Overview

Every year, pull requests look more like a workaround. Agents generate code faster than humans can review it, the diffs mushroom, and the reasoning behind the changes — the actual decisions — lives somewhere else. GitHub lets you talk about code only after you commit and push, and by then the important conversations are over.

Delta, from the Rust editor team at Zed Industries, is built on a different bet: that the conversation with the agent is the unit of work. The thread — the agent chat, the repository checkout it edits, and the human review on top of both — becomes one shareable artifact. No branch, no PR, no reconstructing intent from a diff. The idea, the implementation, the review, and the landing all happen in the same thread — a mode of working Zed calls continuous engineering.

Delta anchors every change, so your reasoning lives on with the results.

Delta launched its public beta on September 16, 2026, and the team is already eating its own cooking: 33 engineers landed 570 changes to main via threads after disabling pull requests on Delta's own repository.

How It Works

The foundation is DeltaDB, a version control layer that extends Git's content-based versioning with a stream of fine-grained deltas. Where Git captures a snapshot at each commit, DeltaDB records every edit between commits and gives each one a stable identity. Because every delta is addressable on its own, a reference anchors to a change rather than a line number — and it survives as the code moves underneath it.

Software now takes shape in the conversation, not the commit.

The radical part: prompts, agent reasoning, and the edits they produced are recorded side by side. A message and the edit it caused never drift apart. DeltaDB embeds conflict-free replicated worktrees, so many people and agents can edit the same files at once across different machines, and the whole worktree can be mounted to disk whenever you want your own tools on it.

You still commit and push exactly as you always did — a commit remains the checkpoint you push, pull, and build from. Teammates who never open Delta see a normal git repository. Git and CI stay for what they're good at; Delta just stops forcing collaboration to happen inside them.

Key Features

• Threads as the unit of work: A thread keeps the agent conversation and the code it edits together, shareable as one artifact. Threads are private until you share them, and invited teammates join as first-class participants — they see the same live worktrees on their own machines.
• Review subthreads: Create a dedicated review subthread with its own isolated copy of the parent's worktrees. Reviewers can run agents to explore the code and try changes without disrupting the original work, then push fixes back into the parent thread before the agent lands the change.
• Agent-native review context: When something looks wrong, you don't guess intent from a diff — you ask the agent that wrote it. Teammates can question the same agent, and every comment stays anchored to the exact text it's about: a line of the diff, a step in the plan, even a thinking block.
• Sub-commit version control: Every edit in a thread is captured and versioned, so you can revert to any moment in the work's evolution — not just the last commit.
• Cloud runner: Move a thread to a cloud runner, close your laptop, and the agent keeps going while its conversation and code stay synchronized.
• Delta in the browser: Share any thread with a link and it opens in a browser without installing anything — the same Rust application compiled to WebAssembly and rendered through WebGL, not a JavaScript knockoff.
• Third-party agent harnesses: Delta connects to agent harnesses you already use, starting with Claude Code. Your terminal session syncs live into a Delta thread that teammates can watch, comment on, and pick up.
• Desktop, web, mobile: Full experience on macOS, Linux, and Windows, plus the web app and follow-along threads on a mobile browser.
• An interface built for agent throughput: The conversation is a document — your cursor works anywhere in it, and comments attach to the exact text they're about: a line of the diff, a step in the plan, a thinking block. Diffs open in full, transcripts stay whole, and everything renders as fast as your model can emit it.

Use Cases

Replacing the PR loop is the headline use case. A teammate joins your thread mid-work, reviews with full agent context, forks a review subthread to try fixes, and merges them back — without ever opening a pull request. Zed itself runs on this workflow.

Agent pairing across time zones: If you log off, a teammate — or a cloud runner — picks up where you left off, keeps working with the same agent, and the history of why the code took its shape stays attached to the code.

Onboarding mid-thread: New teammates don't reconstruct intent from a diff. They read the conversation that produced the code, jump from any line to the exact moment an agent wrote it, and ask the original agent why it's written that way.

Hybrid GitHub workflows: You don't have to move your whole team. Zed's own repo remains on GitHub for community contributions, while contributors share Delta threads alongside their pull requests — and teammates who never open Delta still see normal Git history.

Pricing / Licensing

During the public beta, Delta is free — and Zed has committed that there will always be a free version. Paid plans for individuals and teams are coming.

Pricing shares the same account and plans as Zed:

• Personal — $0: Use your existing API keys or external agents. Revert to any edit in a thread, see the conversation behind every change, review in context, and collaborate with teammates.
• Pro — $10/mo (free trial): Zed-hosted models out of the box, $5 of tokens included each month, usage-based billing beyond the included credits.
• Business — custom: Centralized control over how Zed is used, with organization-level data and privacy controls that apply in Delta.

DeltaDB itself is closed-source — there is no self-hosted or community edition, and the product is proprietary to Zed Industries.

Pros & Cons

Pros

• One shareable artifact for conversation, code, and review — the reasoning behind the code never detaches from it
• Sub-commit versioning with revert-to-any-edit, powered by DeltaDB's fine-grained deltas
• Review subthreads with isolated worktrees let reviewers experiment with agents safely
• Cloud runner keeps agents productive while you're away from the machine
• Browser access via the real Rust app compiled to WebAssembly and WebGL
• Git-compatible and GitHub-friendly — you can adopt it incrementally

Cons

• Proprietary and closed-source, including the DeltaDB layer
• Still in public beta, with roadmap capabilities ahead (in-thread CI, DeltaDB Git storage)
• Tied to the Zed account and subscription model
• Third-party harness ecosystem is young — Claude Code first, more promised
• Mobile browser supports following along, not full editing

Further Reading

• Delta official site — Home, docs, roadmap, and download
• Introducing Delta — Private beta announcement and product vision
• Replace PRs with Delta — Now in Public Beta — Public beta launch post with the no-PRs milestone
• Software Is Made Between Commits — DeltaDB technical deep dive