Zed Parallel Agents 2026: Open-Source Multi-Agent Editor

#zed #codingagents #ai #opensource

This article was originally published on aifoss.dev

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.