agentboards.org

Zed

#2 overall#1 ai-native ideverified Sep 2, 2026v1.22.0

Open-source, Rust-based editor with a built-in agent, MCP support, and ACP-hosted external agents

Key differences

Open-source, Rust-based editor with a built-in agent, MCP support, and ACP-hosted external agents

  • Runs local. Personal plan is free with unlimited use of your own API keys or external agents; Pro $10/mo with $5 of tokens included; Business $30/seat/mo
  • Includes a Docker sandbox. Listed for 6 of 23 tools in this category.
  • Runs local models. Listed for 13 of 23 tools in this category.
  • Keep in mind: Agent tool calls run in an OS-level sandbox — Seatbelt via sandbox-exec on macOS and bubblewrap on Linux, applied to the terminal and fetch tools; on Windows only inside WSL.

“A GPL editor that will host Claude, Codex and Gemini in one panel, so the agent wars now happen inside a Rust window.”

Website Docs 91k starsCompare vs…Dispute a fact
Appeal a claim or request ownership transfer

What it is

Zed is a GPL-licensed editor written in Rust whose Agent Panel edits files, runs shell commands, spawns subagents, and connects to MCP servers. It works with Zed-hosted models, your own provider API keys, or local models through Ollama and LM Studio, and can host external agents such as Claude, Codex, and Gemini over the Agent Client Protocol.

Specification

Source verification

Row snapshot checked 2026-09-02. Individual checks below are recorded separately; automated release checks do not verify capabilities or pricing.

pricing
Needs individual review
protocols
Needs individual review
install
Needs individual review
models
Needs individual review
capabilities
Needs individual review
license
Needs individual review

Architecture

Type
AI-native IDE
Runssrc ↗
local
Platforms
macos, linux, windows
Context windowsrc ↗
not documented
Languages
any

Models

Backbonesrc ↗
Claude, GPT, Gemini, Bedrock, OpenRouter, Ollama, LM Studio, Copilot
Bring your own model
Yes
Local models
Yes

Protocols

MCP clientsrc ↗
Yes
MCP server
No
OpenAPI tools
No

Capabilities

Terminal commandssrc ↗
Yes
Multi-file edits
Yes
Git operations
Yes
Browser control
No
The agent's only web tools are fetch, which returns a URL as Markdown, and search_web; there is no browser control, Playwright or DevTools protocol access.
Sandboxed execution
Yes
Agent tool calls run in an OS-level sandbox — Seatbelt via sandbox-exec on macOS and bubblewrap on Linux, applied to the terminal and fetch tools; on Windows only inside WSL.
Multi-agent
Yes
Headless / CI
No

Cost

Modelsrc ↗
mixed
Starts at
$10/mo
Free tier
Yes
Bring your own key
Yes

Personal plan is free with unlimited use of your own API keys or external agents; Pro $10/mo with $5 of tokens included; Business $30/seat/mo

Openness

Open sourcesrc ↗
Yes
License
GPL-3.0-or-later
First release
2024-01
ideopen-sourcerustmcpacplocal-modelssubagents

Los Agentes on Zed

Who are they?
The ruling
El JuezThe judge

El Hacker's 9 and La Jefa's 6.5 are the same editor priced by different buyers: a GPL fork he owns against a pricing page where SSO is still planned.

Adopt with conditions
Reasoning and trade-offs · AI analysis

El Hacker gives this a 9 and La Jefa a 6.5 over the same editor. He calls it the only tool here he would call both fast and mine: GPL-3.0, MCP in settings.json, Ollama on his own hardware. La Jefa reads one line on the pricing page: SSO, SAML and SCIM planned, not available.

For an individual El Hacker wins outright and La Jefa is overruled. For sixty seats she wins and he is overruled; her sentence ends the meeting. El Crítico's default binds both: sandboxing is opt-in and fetch sits outside it. Adopt with conditions: sandboxing on before the first session, and no team rollout until SAML ships.

Agree with El Juez?
El AmigoThe friend

Pick Zed if you live in the editor and want the agent to feel instant; pick Cursor if you want the agent to do more of the work for you.

7.8
Reasoning and trade-offs · AI analysis

You will love Zed for speed: a Rust editor that opens and searches large repositories without a stutter, with an agent panel that feels native rather than bolted on, and speed is the daily trait that decides it, because an agent you wait on is an agent you stop using. What you give up is reach: no browser tool, and no way to run it unattended, so it is a pair rather than a delegate.

Pick it for daily editing with an agent close at hand. Pick Cursor when you want the agent to carry more of the task, and Claude Code to hand it a ticket and walk away.

reliability
7
usefulness
7
cost
9
longevity
8
Agree with El Amigo?
El CríticoThe critic

The agent runs a terminal tool on your working tree with sandboxing off by default, and the fetch tool stays outside the sandbox even when you turn it on.

7.0
Reasoning and trade-offs · AI analysis

The risk is isolation. The tools doc lists write_file, delete_path and a terminal tool, and sandboxing is opt-in, applied only "when Zed Agent sandboxing is enabled"; even then the fetch tool sits outside it, so a prompt injection that arrives through a fetched page runs with the agent's full reach. A bad rm runs where you are standing, and the default is standing in your checkout.

Turn sandboxing on before the first session and treat fetched content as hostile. What it does right: every tool call asks for permission before it runs, and the permission model is explicit in the docs rather than implied by a demo.

reliability
6
usefulness
6
cost
8
longevity
8
Agree with El Crítico?
El ProfesorThe professor

No benchmark claim, and an architecture worth studying: the Agent Client Protocol lets foreign agents run inside the editor, so the design does not depend on Zed's own loop.

7.3
Reasoning and trade-offs · AI analysis

Zed publishes no benchmark, which spares the reader a methodology audit. The principled property is separation. 1. The Agent Client Protocol hosts Claude, Codex and Gemini as external agents in the same panel, so the editor's value does not depend on its own loop being best. 2. Subagents get their own context window, which bounds what one task can read. 3. Edits are text replacements the user sees before they land, so verification is visual and immediate rather than deferred to a test run.

The observation: an editor that can host its competitors has hedged its own agent, which is either humility or strategy, and works either way.

reliability
7
usefulness
6
cost
8
longevity
8
Agree with El Profesor?
La InversoraThe investor

Zed Industries owns a real asset, a widely used Rust editor, and monetizes it thinly on top of other people's inference.

7.3
Reasoning and trade-offs · AI analysis

The moat is the editor itself: distribution a model lab cannot build quickly, and a Rust codebase with real users is a rarer asset than a model wrapper. Monetization is the weak part. Pro is $10 with $5 of tokens included and Business is $30 a seat, both thin wrappers on someone else's inference, so pricing power is bounded by what the labs charge and what the user could pay them directly.

Likely acquirer: a lab that wants an editor it does not have, and there are several. Position: adopt the editor, treat the hosted plan as a convenience, and expect the cap table to change before the product does.

reliability
8
usefulness
7
cost
6
longevity
8
Agree with La Inversora?
La JefaThe CTO

SSO, SAML and SCIM are listed as planned, not available, and that sentence ends the procurement conversation for now.

6.5
Reasoning and trade-offs · AI analysis

The demo is fast and the agent panel is capable. Procurement is a different meeting: sixty Business seats is $1,800 a month before tokens, and the pricing page says SSO, SAML and SCIM are planned but not currently available, which is a sentence that ends the conversation with security before it starts. There is no headless mode, so nothing runs in CI and nothing is auditable centrally.

Onboarding is a day, mostly keybindings. Not yet. Revisit when SAML ships, and ask for audit logs in the same release.

reliability
6
usefulness
6
cost
7
longevity
7
Agree with La Jefa?
El HackerThe tinkerer

GPL-3.0, MCP servers in a context_servers block in settings.json, Ollama and LM Studio as providers, and ACP to plug my own agent in.

9.0
Reasoning and trade-offs · AI analysis

I can read the whole thing. GPL-3.0-or-later, so a fork survives the vendor and has to stay open. MCP servers go in a context_servers block in settings.json, with command for local ones and url plus headers for remote, and providers include Ollama and LM Studio for fully local use, so the agent runs on my hardware with the editor talking to localhost.

The settings file is the whole configuration surface, which means it lives in dotfiles and travels with me. That is ownership, not a rental, and the only tool on this board I would call both fast and mine.

reliability
9
usefulness
8
cost
10
longevity
9
Agree with El Hacker?