This article was originally published on aicoderscope.com
TL;DR: Zed 1.0 ships parallel agents that run in isolated Git worktrees, support any ACP-compatible AI (Claude, Codex, Gemini, Ollama), and cost half what Cursor Pro costs. Cursor hits back with true cloud VMs, browser access, and the autocomplete quality gap that Zed hasn't closed. If you're already paying for Claude API directly, Zed wins on value. If Tab completion quality or cloud VM access matter more, stay on Cursor.
| Zed Parallel Agents | Cursor Background Agents | |
|---|---|---|
| Best for | BYOK developers, local-model setups, performance-sensitive projects | Cloud-hosted tasks, browser automation, teams needing managed environment |
| Price | Free (BYOK) or $10/mo Pro | $20/mo Pro, $60/mo Pro+, $200/mo Ultra |
| Max parallel agents | Unlimited (bounded by API rate limits) | 8 per session |
| Agent isolation | Local Git worktrees | Cloud VMs (Ubuntu) with browser + terminal |
| Model choice | Any ACP agent: Claude, Codex, Gemini CLI, OpenCode, Ollama | Built-in model picker (Claude, GPT, Gemini) |
| Tab completion | Zeta2.1 — solid, narrowly trails Cursor Tab | Best autocomplete on the market |
| Open source | Yes (Apache 2.0) | No |
| The catch | Local machine carries the compute; no browser agent | Opaque billing; single 50k-line task can eat 22% of monthly credits |
Honest take: Switch to Zed if you're already paying Anthropic or Google directly — you get parallel agents at half the subscription cost with more model flexibility. Stay on Cursor if you need cloud VM agents for CI-style tasks or if Tab autocomplete quality drives most of your daily throughput.
Two editors solving the same problem differently
The premise of parallel agents is simple: your coding bottleneck isn't thinking speed, it's waiting. While Agent A refactors your authentication module, your laptop's CPU sits idle. Nothing stops a second agent from fixing the bug in the payments service. The question is how each editor manages that concurrency without turning your codebase into a merge conflict graveyard.
Zed and Cursor took completely opposite architectural bets.
Zed runs everything locally. Agents operate in isolated Git worktrees branched from your current HEAD. No cloud account, no VM spin-up latency, no surprise bill at the end of the month. The tradeoff: your laptop carries the inference cost if you're using local models, and you don't get a browser-connected agent that can visual-verify a React component rendered in Chrome.
Cursor runs agents in the cloud. Background agents spin up Ubuntu VMs, get full terminal and browser access, and push results back as pull requests. You can kick off a task and close your laptop. The tradeoff: the cost model is opaque, and heavy multi-agent use has pushed real-world bills into the $200–$1,800/month range for power users, despite the $20 plan headline.
Zed 1.0 parallel agents: what actually ships
Zed 1.0 launched April 29, 2026. The headline AI feature is the Threads Sidebar — a pane that lets you launch, monitor, pause, and archive agent threads without leaving your editor window.
Each thread runs inside its own context:
$ git worktree add ../my-project-auth-fix auth-fix-branch
$ git worktree add ../my-project-payments payments-fix-branch
You point Thread A at ../my-project-auth-fix and Thread B at ../my-project-payments. Both agents work concurrently. Neither sees the other's uncommitted changes. New worktrees start in a detached HEAD state by default, so there's no accidental branch sharing.
The agent protocol underneath is ACP — Agent Client Protocol — an open standard Zed created and published under Apache 2.0. At 1.0 launch, four agents support ACP natively:
- Claude Agent (Anthropic's agentic Claude interface)
- OpenAI Codex (via Codex CLI)
- Gemini CLI
- OpenCode (open-source, runs locally)
Any Ollama model can run as a local agent through OpenCode. That means you can configure one thread to use Claude Sonnet 4.6 for the complex refactor, another thread to run qwen3-coder:8b locally for the boilerplate task, and a third thread to use Codex for the test generation — all inside one editor window, all simultaneously.
JetBrains is co-developing the ACP standard, so the ecosystem is expanding.
Performance context: Zed's Rust architecture runs the editor at 120fps. Opening a 100,000-line monorepo takes under one second versus approximately 4.5 seconds in Cursor. RAM for a typical project sits at 200–400MB versus Cursor's 500–800MB. None of that affects agent quality directly, but if you're running 4–6 threads, not having your editor itself stutter matters more than it sounds.
Cursor background agents: what you actually get
Cursor 3.5 shipped Cloud Agents on May 20, 2026. The architectural difference from Zed is the VM.
When you launch a Cursor background agent, Cursor provisions an Ubuntu cloud VM with:
- Full terminal access
- Browser access (so the agent can navigate to
localhost:3000and screenshot what rendered) - Multi-repo access
- Async operation (close your laptop; it keeps running)
You can run up to 8 agents in parallel. Each works on a separate branch and pushes results as a PR. For long-running tasks — database migrations, multi-service refactors that need a build to verify — the cloud VM model is genuinely better than Zed's local worktrees.
The cost model is where Cursor loses the comparison. Cloud agent pricing is metered separately from your plan's credit pool, but Cursor doesn't publish per-VM or per-minute rates. What we know from community reports: a single agent run on a 50,000-line codebase can consume approximately 22% of a $20 Pro plan's monthly credits. Run 5 agent tasks in a day and you've exhausted your plan before Thursday.
For context: Cursor's Cursor Pro plan includes $20 of usage credits monthly. Pro+ at $60/month gives you $60 in credits. Ultra at $200/month is aimed at developers who've already hit the spending ceiling.
Even setting aside cloud agents, Cursor's token-based billing since the 2026 credit overhaul means heavy Agent mode use surprises people. Forum reports show real spending of $200–$1,800/month for power users who assumed the $20 headline covered unlimited agent work.
The head-to-head that matters: cost per productive agent-hour
If you're already paying Anthropic $60/month for Claude API access, Zed's value calculation is brutal in its simplicity:
- Zed Personal (free): bring your own Claude API key → $0 editor cost, agents run directly on your Anthropic spend
- Zed Pro ($10/month): adds unlimited Edit Predictions (Zeta2.1), $5 of monthly Zed-hosted model tokens, plus BYOK for everything else
For a developer already paying for Claude API directly, Zed parallel agents effectively have zero marginal cost on the editor side. You pay Anthropic for tokens; the editor is free or $10.
Cursor's $20 plan includes a $20 credit pool that covers both completions and agent calls. Once you go past that credit pool, you're paying overage. An active parallel-agent user will hit that ceiling.
The BYOK advantage extends to model flexibility. Zed lets you wire any ACP-compatible agent. Cursor's model picker is more curated — you choose from their supported list, and you're still going through Cursor's API routing even when paying per-token. If you want to run a local devstral-2 model for offline work (see the Devstral 2 + Mistral Vibe CLI review), Zed supports it natively. Cursor requires a workaround.
Where each one breaks
Zed's actual limits:
The browser agent gap is real. If your task requires visual verification — rendering a component, scraping a site, checking a deployed endpoint — Zed's local worktrees can't do it without you running a local server yourself. Cursor's cloud VMs handle this natively.
Tab completion quality is the second limit. Zeta2.1 (released May 8, 2026) improved acceptance rate 30% over Zeta v1 by adding LSP context. The "3
Top comments (0)