Zed Lets Developers Share Live Claude Code Sessions Across Machines

Zed Industries, maker of the Zed code editor, has released a Claude Code integration and launched the Delta CLI in beta. Together, they let developers share an active Claude Code session, including its full conversation history and uncommitted worktree changes, with a teammate on another machine.

The release extends Delta, Zed’s multiplayer coding environment, beyond the company’s own applications. Claude Code is its first third-party agent harness, the application layer that runs a coding model and manages its tools. The public CLI also gives developers an extension point for connecting other harnesses to Delta’s shared threads and worktrees.

A two-command handoff

Sharing starts inside Claude Code after installing the Delta plugin and CLI. The host creates an invitation link, the guest joins from another terminal, and Delta synchronizes the conversation and working copy across both machines.

Each developer can prompt independently with access to the shared conversation. The CLI keeps file changes synchronized in both directions, so collaborators work from the same checked-out files and current edits.

Delta replicates the state that typically exists between commits: prompts, model responses, the file tree, and unfinished modifications. A teammate joining midway receives the reasoning that produced the code alongside the code itself.

The state between commits

Agent-assisted tasks are difficult to hand off before they reach a branch or pull request. Developers often push a work-in-progress branch, paste prompt history into chat, and ask the next person to reconstruct the task. A shared Delta thread carries the intent, transcript, and interim edits together.

• Timezone handoffs. One developer can stop midway through a task and another can continue from the same thread and working copy.
• Early refactor reviews. A colleague can inspect and modify an unfinished change before a pull request exists.
• Mixed-tool pairing. One developer can work in Delta while another remains in Claude Code, with both attached to the same thread.

The CLI exposes the building blocks

The beta Delta CLI docs provide a single-command installer for macOS and Linux. The resulting delta binary manages threads, worktrees, organizations, and Model Context Protocol tools, which agents use to call external capabilities.

• delta thread search and delta thread show find and display previous agent conversations. The --edited-path flag limits results to threads that changed a specified file.
• delta thread query sends selected transcripts to a model, allowing developers to ask questions about earlier work without rerunning the original coding task.
• delta worktree mount uploads a checkout, including uncommitted changes, and synchronizes subsequent edits in both directions.
• delta thread invite grants specified email addresses access to one thread.

Creating a shared thread from an existing checkout requires five operations: create the thread, register the worktree, attach the two, set organization visibility, and start live synchronization. With jq installed, the shell sequence is:

THREAD_ID="$(delta --json thread create | jq -er '.thread_id')"
REFERENCE="$(delta --json worktree create "$PWD" | jq -er '.reference')"
delta --json worktree attach "$REFERENCE" --thread "$THREAD_ID"
delta --json thread share "$THREAD_ID" --visibility organization
delta --json worktree mount "$REFERENCE" "$PWD" --existing-checkout

DeltaDB keeps files and chat together

The collaboration layer runs on DeltaDB, a replicated store built by Zed. A replicated store maintains synchronized copies of data for every participant. DeltaDB groups the transcript and worktree into a thread, then distributes updates in real time.

DeltaDB works alongside an existing Git repository and records conversations and edits between commits. Developers outside Delta continue to interact with an ordinary Git repository. Inside a shared session, the transcript, file tree, and in-progress edits remain synchronized data that a new participant can use immediately.

Claude first, foreground sync

• The interface can change. The CLI remains in beta, so commands, flags, and output formats may shift between releases.
• Harness support is narrow. Claude Code is the first third-party harness supported, with Pi planned next. Zed plans to support Pi next and offers the open-source reference plugin for developers adding others.
• Conversation capture requires a plugin. Mounting a checkout synchronizes its files but does not collect conversations from an agent running inside it.
• Mounting requires a foreground process. delta worktree mount stops synchronizing when the process exits or the user presses Ctrl+C.
• Sharing can expose unfinished files. A mounted checkout can include uncommitted changes, so teams need to verify the selected files and access scope before uploading it.

Threads become portable

Zed introduced Delta around a thread that combines agent conversations, code, and collaborator activity. Connecting Claude Code makes that thread portable across tools while preserving Git as the repository format.

The CLI turns Delta’s internal collaboration model into a public integration surface. Planned Pi support and additional community plugins will show how consistently the same thread and worktree model can operate across agent runtimes.