What happened
Zed Industries has released Delta CLI, a beta command-line interface for syncing agent sessions to DeltaDB. The product page positions it as a way to “bring Delta to the agent you already use.” Its first supported harness is Claude Code, whether Claude Code is running in a terminal or in the Code tab of the Claude desktop app. The installer is available for macOS, Linux, and Windows; on macOS and Linux it installs the Delta app into the user’s home directory and runs it in the background when a CLI command needs it.
The main workflow begins inside Claude Code. A user installs the Delta Claude Code plugin, runs /delta share in the active session, and sends another person the resulting link. That teammate can run /delta join <link> to continue from their own session. Delta says the joined agent receives what the user asked, what Claude attempted, and the uncommitted changes in the checkout. The service describes joining as setup rather than prompt stuffing: it clears the new session, mounts the thread worktrees, and does not initially put the old history into the prompt. For long threads, the page says Claude receives roughly 100,000 tokens of the newest history while older material remains behind a pointer row rather than being summarized.
The CLI also exposes session history and workspace operations. delta thread search can search messages, summaries, and files edited by an agent; delta thread query accepts a keyword and a question about a past transcript. A user can fork a thread without altering the original, mount a referenced worktree locally, and share a thread to an organization. For automation, Delta says its commands support JSON on standard output, diagnostics on standard error, exit codes, and background mode. The company has published the Claude Code plugin as open source and invites developers to use it as a starting point for plugins for other harnesses. Pi support is listed as in progress.
DeltaDB is the persistence layer underneath this design. The page contrasts Git’s commit snapshots with DeltaDB’s record of every step between commits. Delta sharing still begins from a Git checkout with a remote, and the team continues to commit and open pull requests normally; Delta is meant to cover the work before a change is ready to commit. That coverage is broad: a shared thread includes user messages, agent replies, tool calls and their inputs and outputs, images, and checkout files, including staged, unstaged, and untracked changes. It excludes extra --add-dir folders, Git-ignored files, local branches, unsent prompts, and messages from earlier or compacted sessions.
Access is consequential. Sharing publishes a thread and its files to the entire Delta organization, not only the person sent the link. A repository can instead be configured for private sync, where sessions remain visible only to the user until they are shared. The current scope is narrower than the product’s general framing: Claude Code cloud sessions, print mode, and SDK sessions are not supported, and teammates cannot join a shared thread unless they use Delta. People using Delta can access the same conversation and files from the app or a browser.
What the archive adds
We have not covered this before; it opens a new thread.
Trend signal
This release supports Harness architecture outlives model choice. Delta CLI does not present a new model as the durable asset; it makes session history, worktrees, search, and handoff capabilities available around an existing coding harness. Its current Claude Code dependency and proposed Pi integration also show that this boundary is still being built through specific adapters rather than a finished universal layer.
Why it matters
A coding agent’s useful context often exists before a pull request: the prompts that set the task, failed attempts, tool output, and local files that have not yet been committed. Git alone cannot hand that state to another engineer or another agent. Delta CLI makes that intermediate state queryable and transferable through a command-line interface, so a team can potentially treat an agent session as a working artifact rather than an ephemeral chat.
For builders, the practical value is not simply more transcript retention. It is the ability to search the reasoning attached to a change, mount the associated worktree, or fork an approach without first manually compiling a handoff document. The JSON and exit-code interface matters because it allows scripts and other agents to operate on those artifacts too. But teams must treat the tool as a data-sharing system, not just a convenience plugin: the shared set includes uncommitted and untracked files, and organization-wide visibility is the stated default for a shared thread.
What happens next
- Delta will add at least one non-Claude-Code harness integration, beginning with Pi or a community-built plugin. (6 months, 70%). Watch for: a documented Pi setup or an additional supported-harness page.
- Teams adopting the CLI will add repository-level rules for what may enter a shared agent session. (3 months, 65%). Watch for: guidance or controls around untracked files, visibility, and private sync.
Limits and uncertainty
The source is a product page and describes intended behavior; it provides no adoption figures, reliability data, performance measurements, or independent assessment of retrieval quality. It does not establish how well the roughly 100,000-token recent-history behavior works across different tasks, nor how permissions, retention, deletion, or audit requirements operate beyond the visibility statements on the page. Delta’s claim that a joined agent gets the relevant prior work is also not evidence that the agent will correctly understand or safely continue that work. Support outside Claude Code remains prospective rather than shipped.
Skill to build now
Run a controlled handoff on a non-sensitive repository. Start a Claude Code task, make a deliberately uncommitted change, share the session, and have a teammate join it on another machine. Compare the time needed to explain the task manually with the joined workflow. Before doing so, inventory staged, unstaged, and untracked files, decide whether organization-wide sharing is acceptable, and use private sync if the repository contains material that should not be broadly visible.
Reader takeaway
Delta CLI is a beta attempt to make the pre-commit life of a coding-agent task portable: conversation, tool activity, and local checkout state can move together. That can improve handoffs for Claude Code users, but the operational unit being shared is much larger and more sensitive than a Git diff.
Open question
Can Delta make its session and workspace layer broadly usable across harnesses without forcing teams to accept organization-wide sharing of uncommitted work?