Zed opens agent-focused collaboration tool Delta to the public

Zed has released Delta in public beta for macOS, Linux, Windows, and the web. The collaborative coding environment preserves agent conversations alongside code changes, giving authors and reviewers access to the reasoning that produced a diff.

Delta organizes work around threads that contain conversations, edits, worktrees, reviews, and commits. Zed has also disabled pull requests in Delta’s own repository, where 33 team members have since landed 570 changes to the main branch using the new workflow.

The branch diff loses the trail

Pull requests center review on the difference between a branch and its target. As coding agents generate larger changes, that diff often omits the prompts, rejected approaches, tool output, and design decisions that shaped the implementation. Reviewers must reconstruct that context from code, comments, or a separate agent session.

A Delta thread keeps the agent conversation beside the resulting code. Teammates can join an active thread, inspect its history, ask the agent about earlier decisions, and continue the work from the existing context.

Reviewers can create a dedicated subthread with isolated copies of the parent thread’s worktrees. A worktree is a checked-out working directory associated with a branch. The isolated copy lets reviewers run agents, test alternatives, request revisions, or edit the code without changing the author’s active workspace.

DeltaDB versions the route

DeltaDB adds a version-control layer to Git. Git identifies stored objects by the hash of their contents and exposes commits as durable repository snapshots. Git may delta-compress objects internally; that storage optimization omits the conversation and sequence of edits behind a change.

DeltaDB records incremental edits between commits together with messages from humans and agents. Those records make the development path queryable, including intermediate states that would usually disappear before a commit. Commits remain the checkpoints used for builds, pushes, pulls, and interoperability with existing Git tools.

Git compatibility allows gradual adoption. Zed’s public repository will remain on GitHub for issue discovery and external contributions. Delta users can collaborate through threads and submit the resulting commits through GitHub, while other contributors continue to see a conventional Git repository.

From prompt to landed change

The public beta supports desktop applications, a browser-based client, and mobile access to threads. A typical workflow has five steps:

1. Start a thread and ask an agent to implement a change.
2. Invite a teammate, who receives the synchronized thread context and worktrees.
3. Create an isolated review subthread when the change is ready.
4. Let reviewers request revisions or make fixes with an agent.
5. Land the accepted change as a Git commit while DeltaDB retains the edit and conversation history.

Shared agent context changes the handoff between developers. A teammate joining a thread can ask why the implementation uses a Mutex instead of an RwLock, inspect the earlier reasoning, and continue working after the original author disconnects.

Beta limits shape deployment

Delta is free during the public beta. Zed plans to introduce paid individual and team plans while retaining a free tier.

In development

• Broader desktop functionality in the web client
• Repository access based on GitHub permissions
• Persistent cloud development environments for remote agent execution
• A Claude Code plugin that records conversations in DeltaDB
• Model Context Protocol support for connecting agents to external tools
• Subthreads for side conversations during an active agent task

Planned later

• @mentions for inviting teammates
• Repository-wide context shared across worktrees
• Sandboxed agent environments
• Windows Subsystem for Linux support
• Conversation branching for testing alternative approaches
• A graph view connecting conversations, edits, and commits

The published roadmap places GitHub-based repository permissions and agent sandboxing in future work. Organizations handling sensitive code will need to evaluate Delta’s current sharing boundaries and execution controls during the beta.

The bet behind threads

Zed calls this workflow “continuous engineering”: ideas, implementation, review, and landing occur within one persistent thread. DeltaDB supplies the versioned state beneath that thread, while Git remains the interchange format for the wider development ecosystem.

The model targets teams whose agents produce enough code that reviewers spend substantial time reconstructing intent from large diffs. Teams with smaller, primarily human-written changes may see less immediate benefit, although DeltaDB’s intermediate history still provides additional evidence for debugging and review.

Most GitHub competitors preserve branches, commits, diffs, and pull requests as their main collaboration units. Delta instead tests threads as the primary unit while retaining Git compatibility. Broader adoption will depend on whether preserved agent context reduces review time and errors, and whether the product’s access controls, execution isolation, and web tooling mature enough for production teams.