AQ vs Zed Delta: a new sync layer, or the shared machine

Published September 21, 2026 · by the AQ team

How is AQ different from Zed's Delta? Delta (delta.dev), from the team behind the Zed editor, calls itself "a multiplayer environment for coding with agents and reviewing what they build." It is built on DeltaDB, a new real-time versioning layer that records every edit and every agent conversation between your git commits, syncs them to everyone in a thread, and lets teammates comment on any line or any message, with the stated ambition of replacing pull requests. AQ shares the running session itself: agent CLIs run in persistent terminals on an always-on machine in your own cloud, and the whole team opens the same live terminal, editor, and app preview in the browser. Delta adds a new substrate beside git and asks your review culture to move onto it; AQ keeps plain git worktrees and ordinary pull requests, and makes the live session the thing the team shares. Both say multiplayer, and they mean genuinely different bets.

Delta is moving quickly, so dates matter: Zed announced Delta with private beta invites on August 12, 2026 and opened the public beta on September 16, 2026. Every Delta claim below is as of September 2026, drawn from Zed's own announcements (the "Introducing Delta," "Software Is Made Between Commits," and public beta posts on Zed's blog, and Zed's launch statements). Delta is new and in beta, so check current behavior against Zed's site before deciding.

AQ vs Zed Delta at a glance

What is Zed Delta?

Delta is a new application from Zed Industries, the company known for the Zed editor and its real-time collaborative editing. It is not an editor update: Zed describes Delta as a separate multiplayer environment built for a world where agents write much of the code and the conversation around that code is the actual work.

The foundation is DeltaDB, which Zed introduced in a post titled "Software Is Made Between Commits." Where git captures a snapshot at each commit, DeltaDB records every operation in between, giving each fine-grained delta a stable identity. It syncs those deltas, together with the human and agent conversation that produced them, to everyone in a thread in real time. Because a delta can be addressed on its own, comments attach to the code at a moment in its evolution instead of to a snapshot that goes stale: Zed's framing is that on a commit-based platform, comments fall out of date as soon as the code changes, while in Delta you can comment on the conversation or on any line of the worktree, whether an agent touched it yesterday or a human wrote it. Importantly, DeltaDB runs beside the git repository you already have. You commit and push as usual, and teammates who never open Delta see a normal git repo.

Around that substrate, Delta is thread-centric. You invite teammates into your conversations with agents; someone who joins your thread sees the same worktrees you do, with their own synced copy on their machine. Work can move to a cloud runner so the agent keeps going after you close your laptop, with the conversation and code syncing back to the thread. Delta connects to third-party agent harnesses, starting with Claude Code over Zed's open Agent Client Protocol, alongside its own agents. And the browser version is unusually serious: delta.dev runs the same Rust application compiled to WebAssembly and rendered through WebGL, so, in Zed's words, a teammate in the browser gets the same experience as the desktop app.

The positioning is aggressive. The public beta post is titled "Replace PRs with Delta," and Zed reports that 33 of its own team members landed 570 changes to main after turning pull requests off internally (a company-reported figure). Zed's own open-source editor repository stays on GitHub for now, with conventional PRs still the contribution path. Public discussion has pushed back on parts of the pitch: in the Hacker News thread on the public beta, some commenters argued that tracing the prompts behind a change amounts to a more advanced git blame, and that reviewers still have to understand the final code for themselves.

What is AQ?

AQ is the multiplayer coding harness where engineering teams run AI coding agents like Claude Code and Codex together: shared live terminals, a code editor, and app previews, in your own cloud.

On AQ the agents are the real CLIs your engineers already use (Claude Code, Codex, Cursor Agent, Kimi, Grok, or plain shells), running in persistent tmux sessions on the team's VM and streamed live to the browser. Sessions survive a closed laptop and resume from any device. Teammates open the same workspace and watch the same live session; typing into someone else's terminal is delegated by its owner approving a control request in one click, and the owner keeps their own input. Each engineer signs into the CLIs with their own Claude or OpenAI account, and AQ never marks up usage. Every workspace gets one isolated git worktree (branch ai/{id}-{slug}, automatic dependency install, one-click rebase onto main), agents commit, push, and open PRs with per-user GitHub auth, and PRs are tracked per workspace. Each workspace runs a live dev-server preview with shareable links that work without an account for viewing, and comments pinned on the preview can be sent to the agent as prompts. Label a Linear issue ai-task and a workspace appears, with status syncing both ways; humans start agents, never auto-launched.

Where Delta stands out

• It records the layer git drops. The conversation that produced a change, and every intermediate edit, become first-class versioned artifacts. If your review pain is "I can see the diff but not the reasoning," DeltaDB attacks exactly that.
• Comments that survive change. Anchoring review comments to stable delta identities instead of commit snapshots is a real improvement over comment threads that detach as code moves.
• A serious browser story. Shipping the same Rust app to the browser via WebAssembly means a teammate with a link reviews in the full application, not a cut-down web viewer.
• Zed's collaboration pedigree. This team has built real-time collaborative editing for years; syncing worktrees and conversations in real time is squarely their expertise.

Where AQ wins

• Nothing new beside git. AQ's unit of isolation is a plain git worktree and an ordinary branch. There is no second versioning substrate to adopt, operate, or migrate away from, and your PR-based review process keeps working unchanged.
• Any agent CLI, as itself. Delta's third-party harness support starts with Claude Code as of September 2026. On AQ, Claude Code, Codex, Cursor Agent, Kimi, Grok, and plain shells run as stock CLIs under each engineer's own login, so a new CLI works the day your team adopts it.
• The live session, not just its record. Delta syncs conversation and code into a reviewable thread. AQ puts the team inside the running terminal: you can catch and steer a wrong turn mid-run, and share the session itself rather than its transcript.
• The whole workbench is shared. A workspace is the terminal plus a code editor plus a live dev-server preview with links outsiders can view without an account, so a PM or designer reviews the running app, not a delta stream.
• Your own cloud. AQ's Team plan runs on VMs you connect from your own cloud, or a dedicated always-on AQ-managed VM in its own isolated network, with no shared multi-tenant execution tier. As of September 2026 we could not verify a bring-your-own-VM option for Delta's cloud runners.

The deeper difference: adopt a substrate, or share a machine

Delta and AQ agree on the diagnosis. Agent-assisted development is single-player by default, and the evidence says so: a July 2026 LeadDev analysis of 25,264 agent-generated pull requests across 2,361 popular GitHub repositories found that in 79 percent of agentic PRs the same developer both reviewed and modified the agent's contribution, and only about one in eight workflows involved multiple humans. Both products exist to make agent work a team activity, and both push toward multiplayer agents.

They ask different prices for it. Delta's bet is that the fix requires new infrastructure: a versioning layer underneath your work that captures what git cannot, and a review culture that moves from pull requests to threads. If that bet lands, the payoff is large; the cost is that your team's collaboration now lives in a beta-stage substrate beside git, reviewers work in Delta to see it, and the exit path back to plain PRs is a real question to ask. AQ's bet is that teams mostly do not need a new substrate, they need a shared place: run the agents on one always-on machine, let everyone watch and drive the same live session in a browser, keep the output as ordinary branches and pull requests. The session's scrollback and the PR trail remain the record, in tools you already trust. This is the same fault line as AQ vs Mosaic, which syncs session memory across personal machines: what actually gets shared, the record of the work or the work itself, live?

Pricing compared

Delta, as of September 2026: free during the public beta on macOS, Linux, Windows, and the web. Zed says paid plans for individuals and teams are coming, and that a free version of Delta will always exist; published team pricing did not yet exist as of this writing.

AQ has two plans. Free is a personal sandbox for one person: AQ creates a private machine in an isolated network, nothing to install, no time limit. Team is $50 per user per month early access (standard $200, billed monthly), covering VMs you connect from your own cloud or a dedicated always-on AQ-managed VM in its own isolated network, with your rate locked for your first 12 months. Inviting a teammate costs nothing until the person accepts and joins. Model usage rides each engineer's own Claude or OpenAI account: AQ never marks up usage.

Bottom line

Delta is the most ambitious statement yet that agent-era collaboration needs new version control: record everything between commits, sync conversation and code as one artifact, and retire the pull request. It comes from a team with deep collaboration credentials, and it is a free public beta you can evaluate today. AQ asks for much less ceremony: real CLIs on an always-on machine in your own cloud, live terminals every teammate can open, watch, and steer from a browser, one git worktree per workspace, and ordinary pull requests at the end. If you believe review should move onto a new substrate, try Delta. If you want multiplayer agent coding on the git and PR workflow you already have, that is AQ.