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:3000 and 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 “3x fewer tokens, 50ms faster latency” is a measurable improvement. But developer surveys still consistently place Cursor Tab ahead on suggestion quality. If autocomplete drives most of your daily throughput — and for many developers it does — the Zeta gap will feel like a daily friction tax.

Plugin ecosystem is thinner. Cursor’s VS Code extension compatibility means it works with virtually every existing VS Code plugin out of the box. Zed’s extension ecosystem is growing but not equivalent.

Cursor’s actual limits:

The cost ceiling is the primary problem. A developer who runs parallel agents aggressively will find the $20 Pro plan exhausted quickly. The $60 Pro+ plan is the real entry point for serious parallel-agent use, and even that runs out.

Transparency on billing is broken. Cursor doesn’t publish per-run agent costs on its pricing page. You find out what it cost when the bill comes. For teams trying to control AI spend, that opacity is a red flag — not a pricing problem, a trust problem.

Cloud agents require internet. If you’re on a plane, working in a secure environment, or hitting Cursor’s API at peak saturation, your agents queue or fail. Zed’s local worktrees work offline with local models.

Switching from Cursor to Zed: what the setup actually looks like

Install Zed, open settings (cmd+,), and navigate to the AI settings panel. Add your Anthropic API key:

{
  "language_models": {
    "anthropic": {
      "api_key": "sk-ant-..."
    }
  }
}

Open the Threads Sidebar (cmd+shift+A on macOS). Hit “New Thread,” select Claude Sonnet 4.6 as the model, and pin the thread to your first worktree directory. Open a second thread, select a different model or the same one, pin it to a second worktree.

The first-run experience is smoother than expected — the main friction is remembering that Zed’s keybindings differ from VS Code’s. Muscle memory for cmd+P file opening still works; agent interaction is in the Threads pane rather than a Composer floating window.

If you’re running local models for privacy-sensitive work, pair Zed with OpenCode as your ACP agent. OpenCode connects to Ollama models and speaks ACP natively. See the OpenCode + Ollama setup guide for the full configuration walkthrough, including the file-write bug you’ll hit in OpenCode 0.1.x.

For hardware requirements on running local coding models, the runaihome.com local LLM hardware guide covers what VRAM tier makes local Ollama agents actually useful versus a bottleneck.

Who should switch, who shouldn’t

Switch to Zed if:

• You already pay for Claude API, Gemini API, or any other model directly — BYOK makes Zed free to run
• You work on large codebases where Cursor’s Electron overhead causes lag on file open
• You want more than 8 concurrent agents without hitting a hard cap
• You care about editor transparency (open source, Apache 2.0)
• Your team does real-time pair programming — Zed’s built-in multiplayer is the only production-grade option in any of these editors

Stay on Cursor if:

• Tab autocomplete quality drives most of your daily output — Cursor Tab remains the best
• You need browser-connected cloud VM agents for visual verification tasks
• You’re running CI-style tasks that need to keep running after you close your laptop
• Your team is standardized on VS Code extensions and you don’t want migration friction
• You need the managed model experience without dealing with API keys

The $10/month price difference is real money over a year ($120 saved), but it’s not the main reason to switch. The main reason to switch is the BYOK model and model flexibility. The main reason to stay is Tab completion quality and cloud VMs.

FAQ

Can I run Cursor and Zed in parallel during evaluation? Yes. They’re independent editors. Open the same project in both. Most developers keep Cursor running for Tab autocomplete while evaluating Zed’s agent capabilities.

Does Zed’s worktree isolation prevent merge conflicts? It prevents conflicts between agent threads working simultaneously, but you still need to merge the individual worktree branches into main yourself. Zed doesn’t automate the merge step — it just makes the concurrent-edit problem tractable.

Can Zed use Claude 4 Opus for agents? Yes, via BYOK with your Anthropic API key. The Zed Student plan excludes Claude Opus from hosted usage, but if you bring your own key, any Claude model is available.

Does the ACP standard work with Windsurf or VS Code? Not yet as of June 2026. Zed and JetBrains are the primary parties co-developing ACP. Windsurf and VS Code use different agent integration approaches.

What’s the practical limit on parallel Zed agents? Your API rate limits and your machine’s memory. Anthropic’s Sonnet 4.6 tier-1 rate limits allow substantial concurrent use. Four to six active Claude agent threads on a 16GB MacBook Pro M4 is feasible; eight threads starts to compete for RAM.

Sources

• Zed 1.0 — Zed’s Blog — April 29, 2026 release announcement
• Parallel Agents | Zed Documentation — Official parallel agents feature docs
• Zed Plans & Pricing — Free, Pro $10/mo, Business $30/seat/mo (verified June 4, 2026)
• Cursor Models & Pricing — Cursor Docs — Pro $20/mo, Pro+ $60/mo, Ultra $200/mo (verified June 4, 2026)
• Cursor 3.5 Cloud Agents — Cursor Blog — Cloud Agents launched May 20, 2026
• Zed Parallel Agents — Agent Client Protocol — ACP standard details, supported agents
• Zed Pricing Change: LLM Usage is Now Token-Based — Zed’s Blog — API list price +10% billing model
• Cursor Parallel Agents community discussion — Cursor Forum — Real-world cloud agent cost reports

Last updated June 4, 2026. Pricing and features change frequently; verify current state before purchasing.