Codecast vs Delta

Two bets on where the work lives

Delta's founding claim is that the thread is where software happens now, so the thread should be the workspace. You add a project, Delta imports its files into DeltaDB, and every thread you open gets its own checkout under .delta with the conversation and the edits recorded together. Zed says it has turned pull requests off on Delta's own repository and lands changes from threads instead.

Codecast starts from the opposite observation: your team already runs agents in terminals, IDEs and tmux panes on many machines, and the problem is that all of that evaporates when the pane closes. So the daemon records what is already happening and the product grows around the record: an inbox of every session by who acts next, search and memory over the corpus, and a control channel back into any live session.

The practical difference is what you give up. Delta asks for a new app, a new agent and an upload of your repository. Codecast asks for a daemon and leaves the agent, the terminal and the git workflow exactly as they were.

What each one records

Delta records operations. Each edit gets a stable identity and a place in sequence, so you can scrub a thread back to any point, revert the conversation to the cursor, comment on a passage while the agent is mid turn, and hand a teammate the exact state of the working tree without a commit. That is a stronger primitive than a diff, and it is the reason Delta had to be a new application rather than a feature of git or of Zed.

Codecast records the agent's own transcript: every message, tool call, permission prompt, thinking block and file edit, with diffs materialized per edit and commits tied back to the session. It does not replay keystrokes, but it keeps things Delta does not: which commands the agent ran, what it read, which prompt it was answering, and what the person said back. cast blame then joins git blame to that record so any line resolves to the conversation and the message that wrote it.

The upload differs too. Delta stores your repository's git objects and file contents on Zed's Cloudflare infrastructure so that browser participants can see the worktree. Codecast stores transcripts and diffs, hashes project paths, redacts secrets before sync, and can run on your own backend.

Isolation and git

Delta isolates by default. Every thread gets a managed checkout, every participant gets their own checkout of that worktree on their own machine, and a prepare script runs when a checkout is created. The agent can push to a second remote named local, which points at your own repository, so a teammate can pick up a branch without going through origin. The cost is that two threads on the same branch name are two separate checkouts, and uncommitted work in one does not appear in the other.

Codecast works in your checkout by default and treats isolation as something you ask for. cast ws acquire creates a git worktree with copied env files, its own port allocations and the project's setup commands, and cast ws destroy tears it down; a warm pool can keep worktrees ready. Because sessions run real git on real branches, landing work is ordinary: commit, push, open a pull request, and codecast binds the session to that pull request so reviews and failing checks wake it.

Review

Delta's review is the strongest part of the product. The Changes tab shows diffs against the branch base, the last commit or the last turn. You select a passage and type to comment; comments queue until your next message and reach the agent as targeted feedback on that exact passage. A review subthread asks the agent for a change guide, a walkthrough of the change in the order that explains it, and ends with Approve or Request Changes posted back to the parent. A skill marked as a landing action turns the merge into a subthread that runs checks and publishes.

Codecast reviews at three levels. In a conversation you quote any reply, leave notes on diff lines and send them as one batched review to the session. Across sessions, a reviewer reads a teammate's transcript and diff and reports back to that session or its owner. On GitHub, cast pr holds notes and submits them as one review with a verdict, and the session that owns the pull request is woken with the whole review as one message.

Working together

In a shared Delta thread everyone can message, steer, edit files and comment, and drafts are visible as people type. All pending drafts go to the agent as one turn. The turn runs on the sender's machine with the sender's tools and credentials and is billed to the sender, so what the agent can reach depends on who pressed send. Browser participants get replicated files and a hosted model, not a shell.

Codecast's collaboration is built around the inbox rather than the thread. Each session has one or more owners and appears in their inboxes sorted by who acts next; passing a session moves it to a teammate; cast send messages any session and the reply carries your name. Around the sessions sit team chat, transcribed calls with action items, a decisions queue that lets an agent ask a question without stopping, and an org model where roles hold standing sessions and a line of stations carries a task from analysis to review.

Safety and where the data goes

Delta's own docs are direct about this: the agent acts autonomously and does not ask before calling tools, there is no sandbox, and Delta runs a repository's prepare script, direnv file and AGENTS.md without asking you to review them first. Permissions, sandboxing and worktree trust are on the roadmap. Data is encrypted in transit and at rest on Cloudflare with Cloudflare managed keys, secrets are redacted on the device before upload, and account deletion is by email.

Codecast leaves the agent's own permission model in place and lets you answer prompts from any device. It redacts secrets before sync, hashes project paths, supports a private, summary only or full visibility level per conversation, and can encrypt conversation bodies so the server never reads them. The backend is MIT licensed and documented for self hosting.

What is not there yet

Delta's roadmap, as of this reading, lists the Claude Code plugin, MCP support, a remote runtime, repository based access and web parity as in progress, and mentions, repository level context, sandboxing, WSL, conversation branching and a graph view as up next. Until the plugin ships, Delta only records work done through Delta's agent.

Codecast has its own gaps, stated in its own docs. OpenCode and pi support is in the tree but pre release. A Codex fork inherits its parent's history but cannot yet take a follow up turn. Cursor sessions are ingested and resumable but cannot be launched or messaged from codecast. The team tier is early access with no self serve billing yet.