# Zed: features, protocols, quickstart

## TL;DR

Zed is a Rust code editor from Zed Industries, and this entry covers only its agent features. Its multi-agent functions are a Threads Sidebar that runs several agent threads at once, ACP-based external agents such as Claude, Codex and OpenCode, terminal threads, and a subagent tool. Multi-agent work is one feature of an editor, not its purpose.

## Key facts

| Field | Value |
| --- | --- |
| Type | Harness |
| Languages / SDKs | Rust |
| License | unknown |
| Pricing model | [Open core](https://zed.dev/pricing) |
| Orchestration pattern | Other |
| GitHub stars | 91,099 (as of 2026-09-30) |
| GitHub forks | 10,846 |
| Last push | 2026-09-30 |
| Latest release | v1.21.0 |
| Repository | [zed-industries/zed](https://github.com/zed-industries/zed) |
| Website | [zed.dev](https://zed.dev) |
| Documentation | [zed.dev](https://zed.dev/docs) |
| Last verified | 2026-09-30 |

## Key features

- Three agent paths share the Agent Panel and Threads Sidebar: the native Zed Agent, External Agents connected through ACP, and Terminal Threads that run an agent CLI. ([source](https://zed.dev/docs/ai/agents))
- External Agents are installed from an ACP Registry; the docs name Claude, Codex, OpenCode, Copilot, Cursor and Pi Coding Agent, and each keeps its own auth, billing and configuration. ([source](https://zed.dev/docs/ai/external-agents))
- Parallel Agents runs several threads at once from the Threads Sidebar; each thread has its own agent, context window and history, and different threads can use different agents. ([source](https://zed.dev/docs/ai/parallel-agents))
- For threads that might edit the same files, a new Git worktree can be started as an isolated checkout, and setup can be automated with a create_worktree task hook. ([source](https://zed.dev/docs/ai/parallel-agents))
- The Zed Agent has a spawn_agent tool that starts a subagent with its own context window for a delegated task, and the parent reviews the result when it finishes. ([source](https://zed.dev/docs/ai/tools))
- Tool permissions decide which Zed Agent tools run automatically and which need approval, using per-tool defaults and regex allow and confirm rules. ([source](https://zed.dev/docs/ai/tool-permissions))
- Zed Agent terminal and fetch tool calls can run in an OS-level sandbox that limits filesystem writes, outbound network access and reachable hosts. ([source](https://zed.dev/docs/ai/sandboxing))
- Zed acts as an MCP client (Tools and Prompts) for the Zed Agent, and can forward configured MCP servers to External Agents over ACP. ([source](https://zed.dev/docs/ai/mcp))

## Architecture and orchestration pattern

Pattern: Other.

Zed is a native code editor written in Rust; its agent features are one area of it. The Agent Panel shows one conversation at a time and the Threads Sidebar lists all threads grouped by project. A thread is one of three types: a Zed Agent thread (Zed-configured models, tools, skills, instructions and MCP servers), an External Agent thread (an ACP agent process that owns its runtime, tools and auth), or a Terminal Thread (a CLI or TUI in a terminal that Zed organises as a thread).

Parallel work is independent threads. The docs say each thread works on its own with its own agent, context window and history, and threads do not exchange messages with one another. The only in-thread delegation documented is the Zed Agent's spawn_agent tool, where a parent starts a subagent and reviews its outcome. Threads that could touch the same files can be given separate Git worktrees, and the finished diff is merged through normal Git.

State is per thread: conversation history, checkpoints taken before each edit, and archived or restorable threads in Thread History. External agents keep their own memory and configuration, and Zed Agent profiles or permissions do not apply to Terminal Threads.

### Human in the loop

Tool permissions let a user require confirmation for Zed Agent tools, with regex rules that auto-allow or always-confirm particular commands. A running thread can be stopped, and for the Zed Agent a queued message can be sent with Steer so it interrupts at the next step (not available for external agents). Every Zed Agent edit gets a Restore Checkpoint button (external agents depend on their integration), and finished worktree changes are reviewed as diffs and merged through Git. External Agents and Terminal Threads use their own permission systems, not Zed's.

### Harnesses it can drive

- Claude Code ([evidence](https://zed.dev/docs/ai/by-company))
- Codex ([evidence](https://zed.dev/docs/ai/by-company))
- OpenCode ([evidence](https://zed.dev/docs/ai/by-company))

## Protocols

| Protocol | Support | Evidence | Note |
| --- | --- | --- | --- |
| MCP | Yes (checked 2026-09-30) | [link](https://zed.dev/docs/ai/mcp) | Client: Zed uses MCP to talk to context servers, supports the Tools and Prompts features (not Sampling or Elicitation), and forwards configured servers to External Agents over ACP. |
| A2A | Unknown (checked 2026-09-30) | — | Not found in the docs index (llms.txt) or GitHub code search (agent2agent returned nothing). Zed's ACP is the Agent Client Protocol between editor and agent, not A2A. |
| AG-UI | Unknown (checked 2026-09-30) | — | Not found in the docs index (llms.txt) or GitHub code search (ag-ui returned nothing); Zed is not in the AG-UI README integration list. |

## Best for

- Running several agent threads side by side in one editor, each on a different task or with a different agent (Zed Agent, Claude, Codex, OpenCode). ([shortlist](https://multiagentguide.top/best/parallel-coding-agents.md))
- Developers who already use Zed and want external coding agents through the ACP Registry rather than a separate app. ([shortlist](https://multiagentguide.top/best/coding-agents.md))
- Keeping agents from editing the same checkout by giving a thread its own Git worktree.
- Restricting a native agent with per-tool approval rules and an OS-level sandbox for terminal commands.

## Not for

- Orchestrating agents that must exchange messages or share a plan; threads run independently and Zed adds no team or messaging layer.
- Headless or server-side agent pipelines; the agent features live inside the desktop editor.
- Sandboxing External Agents or Terminal Threads; the sandbox applies only to Zed Agent.

## Quickstart

```sh
brew install --cask zed
```

Install not yet verified by this site.

```bash
# macOS (other platforms: https://zed.dev/download; Linux: curl -f https://zed.dev/install.sh | sh)
brew install --cask zed

# In Zed:
#  - open the ACP Registry with the action `zed: acp registry` and install Claude, Codex or OpenCode
#  - open the Threads Sidebar with cmd-alt-j (ctrl-alt-j on Linux and Windows)
#  - start a thread from the new-thread menu, then start a second thread with another agent
#  - for overlapping edits, create a Git worktree from the worktree picker in the title bar first
#  - tune approvals in settings under agent.tool_permissions (default, always_allow, always_confirm)
```

### Common pitfalls

- External Agents own their own authentication and billing; an API key set for Zed Agent does not configure Claude, Codex or other External Agents.
- Some Agent Panel features (thread restore, checkpoints, token display) depend on the External Agent integration, and thread import is not supported for some agents such as Cursor and Gemini CLI.
- Zed Agent profiles, tool permissions, skills and MCP settings do not apply to Terminal Threads.
- Agent sandboxing applies only to Zed Agent's terminal and fetch tools; on Linux it needs a non-setuid bwrap binary on PATH, and Windows sandboxes are weaker.
- In Zed v0.224.0 and later, tool approval uses `agent.tool_permissions.default` instead of the older `agent.always_allow_tool_actions` boolean.
- New worktrees start in detached HEAD; pick or create a branch before committing.

Official quickstart: https://zed.dev/docs/installation

## Pros

- Threads from the native agent, ACP agents and terminal CLIs sit in one sidebar and can run at the same time. ([source](https://zed.dev/docs/ai/parallel-agents))
- Git worktree isolation is built into the thread workflow. ([source](https://zed.dev/docs/ai/parallel-agents))
- Zed does not charge for External Agents; billing is between you and the agent provider. ([source](https://zed.dev/docs/ai/external-agents))
- Tool permissions and an OS-level sandbox give the native agent two independent limits. ([source](https://zed.dev/docs/ai/sandboxing))
- Zed Agent edits get checkpoints, and a queued message can steer the running Zed Agent at its next step. ([source](https://zed.dev/docs/ai/agent-panel))

## Cons

- The repository README says Zed's source is licensed primarily under GPL-3.0-or-later with Apache-2.0 components where marked, so GitHub reports no single license. ([source](https://github.com/zed-industries/zed/blob/HEAD/README.md))
- Multi-agent work is one feature of an editor: threads run independently and the docs describe no messaging or shared-plan layer between them. ([source](https://zed.dev/docs/ai/parallel-agents))
- MCP support covers Tools and Prompts; Discovery, Sampling and Elicitation are listed as contributions welcome. ([source](https://zed.dev/docs/ai/mcp))
- Agent sandboxing applies only to Zed Agent's terminal and fetch tools, not to External Agents or Terminal Threads. ([source](https://zed.dev/docs/ai/sandboxing))
- Zed Agent permissions, profiles and MCP settings do not carry over to Terminal Threads, which keep their own configuration. ([source](https://zed.dev/docs/ai/terminal-threads))

## Alternatives

- [OpenCode](https://multiagentguide.top/tools/opencode.md)
- [Cline](https://multiagentguide.top/tools/cline.md)
- [Claude Squad](https://multiagentguide.top/tools/claude-squad.md)
- [Container Use](https://multiagentguide.top/tools/container-use.md)
- [OpenHands](https://multiagentguide.top/tools/openhands.md)

## FAQ

### Is Zed a multi-agent tool?

It is a code editor that includes multi-agent features. The Threads Sidebar runs several independent agent threads, threads can use different agents, and the Zed Agent can spawn a subagent. There is no built-in team, handoff or messaging layer between threads.

### Can Zed run Claude Code, Codex or OpenCode?

Yes, in two ways. Claude Agent, Codex and OpenCode can be installed as External Agents through the ACP Registry, and the CLIs (for example Claude Code CLI or the opencode CLI) can run in Terminal Threads.

### Does Zed support MCP?

Yes, as a client for Tools and Prompts. The Zed Agent uses MCP servers configured in Zed, and Zed can forward them to External Agents over ACP.

### What is the license?

GitHub reports unknown because the repository has LICENSE-GPL and LICENSE-APACHE files. The README says the source is primarily GPL-3.0-or-later with Apache-2.0 components where marked.

### Is Zed free?

The editor has a free Personal plan that works with your own API keys or External Agents; paid Pro and Business plans add Zed-hosted models and organisation controls, per zed.dev/pricing.

## Sources

- [Zed repository README (licensing section)](https://github.com/zed-industries/zed/blob/HEAD/README.md)
- [LICENSE-GPL](https://github.com/zed-industries/zed/blob/HEAD/LICENSE-GPL)
- [LICENSE-APACHE](https://github.com/zed-industries/zed/blob/HEAD/LICENSE-APACHE)
- [Zed docs home](https://zed.dev/docs)
- [Zed pricing](https://zed.dev/pricing)
- [Docs: Installing Zed](https://zed.dev/docs/installation)
- [Docs: Agents](https://zed.dev/docs/ai/agents)
- [Docs: External Agents](https://zed.dev/docs/ai/external-agents)
- [Docs: Parallel Agents](https://zed.dev/docs/ai/parallel-agents)
- [Docs: Tools (spawn_agent)](https://zed.dev/docs/ai/tools)
- [Docs: Tool Permissions](https://zed.dev/docs/ai/tool-permissions)
- [Docs: Agent Sandboxing](https://zed.dev/docs/ai/sandboxing)
- [Docs: Model Context Protocol](https://zed.dev/docs/ai/mcp)
- [Docs: Agent Panel](https://zed.dev/docs/ai/agent-panel)
- [Docs: AI by Company](https://zed.dev/docs/ai/by-company)
- [Docs: Terminal Threads](https://zed.dev/docs/ai/terminal-threads)

## Unknown fields

license: GitHub reports unknown. The repository root has LICENSE-GPL (GNU GPL v3) and LICENSE-APACHE (Apache 2.0, Zed Industries) files and no single LICENSE file; the README states the source is 'licensed primarily under GPL-3.0-or-later, with Apache-2.0 components where marked'. Both LICENSE-GPL and LICENSE-APACHE are at https://github.com/zed-industries/zed/blob/HEAD/LICENSE-GPL and .../LICENSE-APACHE. protocols.a2a and protocols.agui: searched the docs index and GitHub code search; nothing found.

Corrections or removal requests: support@multiagentguide.top

---

Data as of 2026-09-30. Not affiliated with listed projects. HTML version: https://multiagentguide.top/tools/zed