# Zed — The open-source, GPU-native code editor built from scratch by Atom's creators — runs Claude Code, Codex and other agents via the open Agent Client Protocol it created. Free forever; Pro from $10/month.

> Source: The Agents Index — https://theagentsindex.com/zed (structured, researched, re-verified)
> Facts last verified: 2026-07-25

Zed is an open-source code editor built entirely from scratch in Rust — not a VS Code fork — by Nathan Sobo, Antonio Scandurra and Max Brunsfeld, the original creators of Atom, after GitHub discontinued that editor in 2022. It runs on GPUI, a custom UI framework rendering directly against the platform's graphics API instead of through Electron/Chromium, and reached its 1.0 release in April 2026. The core editor is open source (GPL-3.0-or-later, select components under Apache-2.0) with 87,000+ GitHub stars. Rather than build one closed-source agent, Zed created the Agent Client Protocol (ACP), an open standard letting any compliant editor run any compliant AI coding agent natively — since adopted by JetBrains. Zed Industries has raised $42M+, including a Sequoia-led $32M Series B (August 2025).

| Fact | Value |
| --- | --- |
| Website | https://zed.dev |
| Pricing | Free forever (Personal); Pro $10/month; Business $30/seat/month |
| API | No |
| Best for | Developers who want a fast, open-source editor and the freedom to run Claude Code, Codex, Gemini CLI or other vendors' own agents natively via the Agent Client Protocol Zed created, instead of being locked into one editor's built-in agent. |
| Not for | Teams that need VS Code's much larger extension ecosystem or a managed, Codespaces-style cloud development environment, or who want the single most mature, batteries-included proprietary agent (Cursor, GitHub Copilot) without assembling their own editor-plus-agent combination. |

## Pricing

| Tier | Price |
| --- | --- |
| Personal | $0 / forever |
| Pro | $10 / month |
| Business | $30 / seat/month |

## Verdict

Zed's real differentiation in this index isn't a single proprietary agent, it's the platform decision underneath every rival: Cursor and Windsurf both forked VS Code and built one closed-source agent into it; GitHub Copilot is tied to GitHub's own stack. Zed rebuilt the editor from zero in Rust for GPU-native performance, then open-sourced the connection layer itself — the Agent Client Protocol — so Claude Code, OpenAI Codex, Gemini CLI, GitHub Copilot and others run natively inside Zed as swappable External Agents, and JetBrains now speaks the same protocol in its own IDEs. That buys real vendor-independence and raw editor speed, but it's genuinely earlier-stage on ecosystem maturity: Zed's own extension catalog is, in its own words, "hundreds" of community packages against VS Code's much larger marketplace; remote development requires bringing your own SSH-reachable server (no managed, Codespaces-style cloud environment, and Windows isn't yet supported as a remote target); and its DAP-based debugger — documented as breakpoints, stepping and variable inspection — doesn't list the watch-window and data-breakpoint features VS Code's debugger has had for years. Pick Zed if editor performance and not being locked into one vendor's built-in agent matter more to you than ecosystem breadth; stay on Cursor or GitHub Copilot for the single most mature, batteries-included agent experience today.

## How it works

1. Zed is a native application built on GPUI, a Rust UI framework the team wrote from scratch that talks directly to the platform's GPU rather than rendering through Chromium/Electron like most competitors.
2. Its own first-party AI features — Zeta2 edit prediction, an Inline Assistant, and an Agent Panel — connect to any of ten-plus model providers (Anthropic, OpenAI, Google, Mistral, DeepSeek, Bedrock, OpenRouter, Ollama, LM Studio) or a user's own API keys.
3. For a full coding agent rather than inline completions, Zed runs External Agents — Claude Code, OpenAI Codex, Gemini CLI, GitHub Copilot and others — as separate processes communicating over the Agent Client Protocol (ACP), an open standard Zed created in August 2025 and JetBrains has since adopted for its own IDEs.
4. Real-time multiplayer features (shared screens, joint editing, chat) and Git/LSP/DAP-debugger integrations run alongside whichever agent is active, all inside the same window.

## Who it's for

- Developers who want GPU-native editor performance instead of an Electron-based IDE
- Teams standardizing on one editor while wanting to run different vendors' coding agents (Claude Code, Codex, Gemini CLI) without switching tools
- Open-source-minded engineers who want to inspect, self-build or extend the editor itself, not just the AI layer on top of it
- Anyone comparing multiple External Agents side by side in one interface instead of juggling separate terminal windows

## Strengths and weaknesses

- ✓ Built from scratch in Rust on GPUI rather than forked from VS Code/Electron — a genuinely different, GPU-native architecture behind the editor's speed.
- ✓ Created and open-sourced the Agent Client Protocol (ACP), now adopted by JetBrains for IntelliJ IDEA, PyCharm and WebStorm (co-launched ACP Agent Registry, January 2026) — runs Claude Code, Codex, Gemini CLI, GitHub Copilot and other vendors' own agents natively instead of locking users into one proprietary agent.
- ✓ The core editor is open source (GPL-3.0-or-later, Apache-2.0 for select components) with 87,000+ GitHub stars, and the Personal plan is free forever with unlimited BYOK usage.
- ✓ Backed by $42M+ across a Sequoia Capital-led Series B (August 2025) plus angel investors including Figma's Dylan Field and GitHub's Tom Preston-Werner — well-capitalized for a young challenger to Cursor and Windsurf.
- ✗ Zed's own extensions page describes "hundreds" of community extensions today — a much smaller catalog than VS Code's marketplace, so some frameworks and language tooling need manual setup.
- ✗ Remote development means bringing your own SSH-reachable server — there is no managed, Codespaces-style cloud environment, and Windows isn't yet supported as a remote-dev target.
- ✗ Zed's own debugger docs describe breakpoints, stepping and variable inspection over the Debug Adapter Protocol, but don't mention the watch-window or data-breakpoint features VS Code's debugger has had for years.
- ✗ Pro's $5/month in included token credits is thin for heavy use — the plan explicitly bills usage beyond that at "API list price + 10%," so active AI users should expect real variable spend on top of the $10 sticker price.
- ⚠ No managed, Codespaces-style cloud development environment as of mid-2026 — remote development requires the user's own SSH-reachable server.
- ⚠ Windows is not yet supported as a remote-development server target.
- ⚠ Extension catalog ("hundreds", per zed.dev) is far smaller than VS Code's marketplace.

## Key features

- **GPUI native rendering** — A Rust UI framework Zed wrote from scratch that talks directly to the platform GPU instead of rendering through Electron/Chromium, the architecture behind its startup and typing-latency speed.
- **Agent Client Protocol (ACP)** — An open, Apache-licensed standard Zed created (released August 2025) that lets any compliant editor run any compliant coding agent as a native External Agent; JetBrains adopted it for IntelliJ IDEA, PyCharm and WebStorm, co-launching a shared ACP Agent Registry in January 2026.
- **External Agents** — Claude Code, OpenAI Codex, Gemini CLI, GitHub Copilot, OpenCode and other agents run natively inside Zed's Agent Panel over ACP, each owning its own runtime, auth and model selection.
- **Zeta2 edit prediction** — A first-party, open-weight model powering inline next-edit suggestions, distinct from the External Agents and included in every plan.
- **Real-time multiplayer collaboration** — Shared screens, joint editing and in-editor chat, a direct descendant of the collaboration work the founding team originally built into Atom.
- **Native Git, LSP and DAP debugging** — Built-in Git staging/committing/diffs, Language Server Protocol support, and a Debug Adapter Protocol-based debugger with breakpoints, stepping and variable inspection across 11+ languages.

## Use cases

- **Editor performance at scale** — A developer working in large monorepos wants GPU-native rendering and Rust-level responsiveness instead of an Electron/Chromium-based editor slowing down as the codebase grows.
- **Running multiple coding agents side by side** — A team wants to try Claude Code, Codex and Gemini CLI in the same editor without three separate terminal windows — Zed's Agent Client Protocol runs each as a native External Agent in one Agent Panel.
- **Avoiding single-vendor agent lock-in** — An engineering org standardizing on an editor wants the freedom to swap or run multiple vendors' agents as pricing or quality shifts, rather than committing to one closed-source agent baked into the editor.

## Integrations

Anthropic, OpenAI, Google, Mistral, DeepSeek (first-party model providers) · Amazon Bedrock, OpenRouter, LM Studio, Ollama, Vercel (BYOK / local & routed model access) · Claude Code, OpenAI Codex, Gemini CLI, GitHub Copilot, OpenCode (External Agents via ACP) · MCP servers (extending agent context) · JetBrains IntelliJ IDEA, PyCharm, WebStorm (share the ACP Agent Registry, not Zed integrations per se)

## Sources

- https://zed.dev
- https://zed.dev/pricing
- https://zed.dev/extensions
- https://zed.dev/docs/remote-development
- https://zed.dev/docs/debugger
- https://zed.dev/docs/ai/external-agents
- https://zed.dev/blog/jetbrains-on-acp
- https://github.com/zed-industries/zed
- https://en.wikipedia.org/wiki/Zed_(text_editor)
- https://www.businesswire.com/news/home/20250820782241/en/Zed-Raises-$32M-Series-B-Led-by-Sequoia-to-Scale-Collaborative-AI-Coding-Vision