TL;DR: Zed’s Parallel Agents turn multiple AI threads into a native editor primitive — run Claude Code, Gemini CLI, and a local Ollama model side by side, each on its own task. It’s GPL-3.0, fast, and vendor-neutral via the open Agent Client Protocol. Use it if you want to orchestrate several agents without leaving one window; skip it if you live in the VS Code extension ecosystem.

	Zed Parallel Agents	Cursor	Claude Code (standalone)
Best for	Running multiple agents concurrently, FOSS-first workflows	Polished single-agent editing inside a VS Code fork	Terminal-driven autonomous coding
License	GPL-3.0 (editor), Apache-2.0 (GPUI)	Proprietary	Proprietary CLI
The catch	Windows is newer; smaller extension library than VS Code	Closed source, agent runs one thread at a time	One agent, no editor UI of its own

Honest take: If you care about open source and want to drive more than one agent at once — including local models — Zed is the only editor doing this natively in 2026. Cursor is smoother for a single agent, but it’s closed and single-threaded.

---

What Zed Parallel Agents actually is

Zed is a code editor written in Rust on a custom GPU-accelerated UI framework called GPUI. It hit version 1.0 on April 29, 2026, and it’s open source — GPL-3.0 for the editor, AGPL-3.0 for the collaboration server, and Apache-2.0 for the GPUI framework. It runs on macOS, Linux, and Windows (Windows support is the newest of the three but stable as of 2026).

Parallel Agents, shipped April 22, 2026, is the feature worth paying attention to. It lets you run multiple AI agents at the same time in a single editor window, each working on a different part of your codebase. Instead of asking one agent to refactor a module, then write tests, then update docs in sequence, you hand those three jobs to three threads that run concurrently.

Every other mainstream editor — Cursor, Windsurf, VS Code’s Copilot — treats the agent as a single foreground conversation. You wait for it to finish before you start the next thing. Zed made concurrency a first-class part of the editor instead of a workaround you build with multiple terminal tabs.

The ACP angle (why this matters for FOSS)

The reason Parallel Agents isn’t locked to one vendor is the Agent Client Protocol (ACP) — an open specification Zed created (with Google contributing the Gemini CLI reference implementation). ACP does for coding agents roughly what the Language Server Protocol did for language tooling: it decouples the agent from the editor, so you can switch agents without switching editors.

Any ACP-compatible agent shows up as a first-class participant in Zed. Documented integrations include Claude Code, OpenAI Codex CLI, Gemini CLI, OpenCode, Goose, Cline, and Auggie. Several of those are themselves open source, which means you can build a fully FOSS pipeline: Cline or Goose as the agent, a local model as the brain, Zed as the orchestrator. In January 2026 Zed and JetBrains co-launched an ACP Agent Registry so you can browse and connect agents from inside either IDE.

Local agents run as a sub-process of the editor and talk over JSON-RPC on stdio; remote agents can be hosted in the cloud and communicate over HTTP or WebSocket. Crucially, prompts and code sent through an external agent like Codex don’t touch Zed’s servers — that path is between you and whoever provides the model.

If you’re weighing open-source agents in general, our open-source coding agents state of 2026 breaks down where each one actually stands, and the Continue.dev vs Cline vs Aider shootout covers the editor-integrated options in depth.

How parallel agents work in practice

The control surface is the Threads Sidebar. Open it with cmd-alt-j on macOS or ctrl-alt-j on Linux/Windows. It groups your threads by project, each with a status indicator and the agent that’s running it, so you can launch, monitor, stop, and archive threads from one place.

A few things make the workflow usable rather than chaotic:

• Per-thread models. Each thread can use a different model. Put Claude on the hard refactor, a cheap hosted model on the boilerplate, and a local Ollama model on the throwaway script — at the same time.
• Per-thread file access. You control which files and repositories each thread can touch, so a docs thread can’t wander into your auth code.
• Git worktree isolation. If two threads might edit the same files, you can isolate one in a fresh Git worktree to avoid them stepping on each other’s changes.
• Fast switching. ctrl-tab cycles forward through recent threads; hold Shift to go backward. No need to open the sidebar for a quick jump.

To start a thread, run agent: new thread from the command palette or click the ✨ icon in the status bar. There’s also a Zed > Panel Layout > Agentic preset that puts the Agent Panel and Threads Sidebar on the left and your Project and Git panels on the right.

Here’s the rough loop once it’s set up:

1. cmd-alt-j            → open Threads Sidebar
2. agent: new thread    → spawn thread A (model: claude, scope: src/api/)
3. agent: new thread    → spawn thread B (model: ollama qwen, scope: tests/)
4. agent: new thread    → spawn thread C (model: gemini, scope: docs/)
5. ctrl-tab             → cycle between A/B/C while they run concurrently

Zed claims it holds 120fps even with multiple agents executing. In practice the editor stays responsive while agents churn in the background, which is the whole point — you keep editing while they work.

Running it with local models (the FOSS-first play)

This is where Zed earns its place on a FOSS site. Zed connects to Ollama and LM Studio as model providers, so you can run agents entirely on your own hardware with nothing leaving the machine. Zed’s own blog noted local model usage in its agent grew 3x in a ten-week window — the demand is real.

Point Zed at a local Ollama server in settings.json:

{
  "language_models": {
    "ollama": {
      "api_url": "http://localhost:11434"
    }
  }
}

Then pull a capable coding model and assign it to a thread:

$ ollama pull qwen3-coder:30b
$ ollama list
# NAME                 ID            SIZE      MODIFIED
# qwen3-coder:30b      a1b2c3d4e5    18 GB     3 seconds ago

The honest caveat: agentic editing is demanding, and local quality scales hard with model size. A 7B model will plan poorly and loop on its own errors inside an agent. You want a 30B-class model or larger, which in turn wants real VRAM — a used RTX 3090 (24GB) is the practical floor for running a coding agent locally at usable speed. If you’d rather rent than buy, RunPod lets you spin up a bigger GPU by the hour for heavier runs. For build planning, runaihome.com’s local AI GPU guides are worth a look before you spend.

Pricing: free does almost everything

Zed’s Personal plan is free forever. It includes 2,000 accepted edit predictions per month and — this is the part that matters — unlimited use with your own API keys or external agents. Bring an Anthropic or OpenAI key, or run a local model, and you pay nothing to Zed.

The Pro plan is $10/month for unlimited edit predictions and access to Zed’s hosted models. Note that Zed’s hosted-model usage moved to token-based billing in 2026, so if you go that route, watch your token spend rather than assuming a flat cap.

Plan	Cost	Edit predictions	Agents / models
Personal	Free	2,000 / month	Unlimited with your own keys or local models
Pro	$10 / month	Unlimited	Hosted models (token-based) + your own keys

For a FOSS-first setup, the Personal plan plus a local Ollama model or your own API key is all you need. The paid tier is a convenience, not a gate.

How it compares to Cursor and Claude Code

Cursor is the polished incumbent: a VS Code fork with a mature single-agent experience and the entire VS Code extension library. It’s also closed source and single-threaded on agents — you run one agent conversation at a time. If you want the smoothest single-agent flow and don’t care about open source, Cursor is still excellent. We cover the proprietary editors in more depth over at aicoderscope.com.

Claude Code is a terminal-first autonomous agent. It’s powerful, but it has no editor UI of its own — which is exactly why it shows up inside Zed via ACP. The interesting move in 2026 isn’t “Zed vs Claude Code”; it’s “Claude Code as one of several threads running in Zed.” You can drive Claude Code in one thread and Cline or a local model in another, in the same window.

So the real differentiator is orchestration. If your work is genuinely parallelizable — multiple independent tasks across a repo — Zed is the only editor that treats that as a native primitive instead of asking you to juggle terminals. If your work is one focused task at a time, the parallel machinery is overhead you won’t use.

When NOT to use Zed Parallel Agents

• You depend on niche VS Code extensions. Zed’s extension ecosystem is growing but nowhere near VS Code’s. If your workflow leans on specific marketplace extensions, you’ll hit gaps.
• You only ever run one agent. Parallel Agents adds conceptual overhead — threads, worktrees, per-thread scopes. For single-task editing, it’s machinery you won’t touch, and Cursor or plain Claude Code may feel simpler.
• You’re on Windows and want maximum polish. Windows support is stable but the newest of the three platforms; macOS and Linux are the most battle-tested today.
• You expect frontier results from a small local model. Parallel agents multiply your model needs. Three concurrent 7B agents won’t out-think one good one. Local is a privacy and cost play, not a capability shortcut — match your hardware to the ambition.

Quick setup

# macOS / Linux
curl -f https://zed.dev/install.sh | sh

# then, inside Zed:
#   cmd-alt-j / ctrl-alt-j   → open Threads Sidebar
#   agent: new thread        → spawn a thread, pick its model and file scope
#   ctrl-tab                 → cycle between running threads

Add your API key or local provider in settings.json, spawn two or three threads with different scopes, and let them run. That’s the whole onboarding.

FAQ

Is Zed actually open source? Yes. The editor is GPL-3.0, the collaboration server is AGPL-3.0, and the GPUI framework is Apache-2.0. It was open-sourced in January 2024. The hosted model service is a paid add-on, but the editor and all features that use your own keys are free and open.

Do I need a Zed subscription to use parallel agents? No. The free Personal plan supports unlimited use with your own API keys, external ACP agents, and local models. You only pay for Zed’s hosted models or unlimited edit predictions.

Can I run parallel agents entirely on local models? Yes, via Ollama or LM Studio. Each thread can point at a local model. The practical limit is hardware — agentic work wants a 30B-class model, which wants 24GB+ of VRAM for reasonable speed.

Which agents work with Zed’s ACP? Claude Code, OpenAI Codex CLI, Gemini CLI, OpenCode, Goose, Cline, and Auggie are documented, with more in the Zed/JetBrains ACP Agent Registry. Several are open source.

How is this different from opening multiple terminal tabs? The Threads Sidebar gives you per-thread model selection, per-thread file/repo access controls, Git worktree isolation, and a single monitoring surface — none of which you get from raw terminal tabs running CLIs.

Sources

• Introducing Parallel Agents — Zed Blog
• Parallel Agents — Zed Docs
• Agent Client Protocol — Zed
• Zed team releases version 1.0 — The Register
• Zed (text editor) — Wikipedia
• Use a Local Model — Zed Docs
• Zed Pricing