This article was originally published on aicoderscope.com
The pitch for Zed is simple: your editor should not feel like running a browser. VS Code is Electron. Cursor is a VS Code fork, which makes it Electron too. Zed is native Rust, renders on the GPU, and was designed from scratch around the idea that 200ms typing latency is not a law of physics.
That architectural bet has become more interesting now that Zed ships serious AI features — its own autocomplete model (Zeta), a full agent mode with multi-thread support, 15 LLM providers, and as of May 20, 2026: Terminal Threads that let you run Claude Code or Amp as a sidebar agent alongside your existing editor context. At $10/month Pro ($0 with your own API keys), it's half the price of Cursor.
Whether that adds up to a genuine switch is the question this review answers.
What Zed actually is (and what it isn't)
Zed is a GPU-accelerated, multi-buffer code editor built by Zed Industries, written in Rust. It runs on macOS, Linux, and Windows. The current release is v1.3.5 (May 20, 2026).
It is not a VS Code fork. That matters for two reasons: first, it means the extension ecosystem (500+ extensions as of today, versus VS Code's 50,000+) is genuinely smaller. Second, it means the editing engine — keybindings, cursor movement, multi-cursor, buffer management — was designed without VS Code constraints. Developers coming from Vim or Helix tend to feel at home faster than those migrating from VS Code.
The AI layer sits on top of three primitives:
- Edit prediction (inline autocomplete via Zeta, Zed's own open-weight model)
- Inline assistant (select code → describe change → model rewrites in place)
- Agent mode / Threads (full agentic loops with file read/write, tool use, MCP servers)
A fourth primitive launched the day before this review was written: Terminal Threads, which runs external CLI agents (Claude Code, Amp, Codex CLI) as persistent sidebar threads with the same keyboard navigation as Agent threads. More on that in a moment.
Pricing: the $10 tier looks cheap until you do the token math
| Tier | Monthly | Zeta predictions | LLM credits | Notes |
|---|---|---|---|---|
| Personal | $0 | 2,000 accepted/mo | None (BYOK only) | Unlimited with own API keys |
| Pro | $10 | Unlimited | $5 included | Overage at API list price +10% |
| Business | $30/seat | Unlimited | None fixed | Usage at standard rates; org governance |
The free tier is the most honest free tier in AI editing right now. You get 2,000 accepted Zeta predictions per month — enough for light use — and unlimited usage if you bring your own Anthropic, OpenAI, or other API key. No watermarks, no feature gates, no "upgrade to use Agent mode." The only thing you lose at the free tier is the Zeta autocomplete budget.
Pro at $10/month includes unlimited Zeta predictions (the autocomplete model runs on Zed's infrastructure) and $5 in LLM token credits. The $5 credit sounds like a rounding error — and it is. A single afternoon of moderate Claude Sonnet 4 usage in Agent mode will clear it. Once you exceed $5, you're billed at the model provider's list price plus a 10% markup, with invoices triggered monthly or per additional $10 spent, whichever comes first.
The practical result: Pro at $10 is really a Zeta autocomplete subscription. If you want agent AI without surprise bills, you bring your own Anthropic API key and manage spending there directly. That's a reasonable trade-off for many developers — it gives you visibility and control over costs rather than an opaque subscription.
Cursor Pro at $20/month bundles 500 fast requests and unlimited slow requests, which is predictable. For developers who want predictable spend, Cursor wins on billing clarity. For developers who already manage API keys (anyone running Cline, Aider, or Claude Code), Zed's BYOK model is preferable.
Business at $30/seat adds org-wide model policies, data governance controls, role-based access, and unified spend visibility. No minimum seat count; contract pricing available at 25+ seats. This is meaningfully cheaper than Cursor Business (requires quoting) for small teams.
Zeta: the autocomplete model Zed built themselves
Most editors rent their autocomplete model from a provider. Zed trains their own: Zeta, an open-weight model published on Hugging Face, trained on open-source code only (no private repositories). Zeta2 improved acceptance rate 30% over v1 by incorporating LSP context — rather than guessing from token proximity alone, it fetches type definitions and symbol information from your language server.
Zeta2.1, released May 8, claims "3x fewer tokens, 50ms faster" — meaning the prediction requests are cheaper to run and the latency is lower. The 50ms improvement is meaningful in a 2,000ms keypress-to-suggestion loop; it's invisible in a 400ms loop. Whether this is perceptible in practice depends heavily on your hardware and network.
The limitation worth knowing: Zeta is an edit prediction model, not a next-token completion model. It specializes in "given what I'm about to change, what's the new content?" rather than open-ended code generation. For Tab-to-complete workflows, this is an advantage — predictions are more focused. For multiline generation of new code from a comment, you'll invoke the inline assistant or Agent mode instead.
For comparison, Cursor uses a proprietary Tab model they describe as a speculative edit model — conceptually similar to Zeta, trained on their own dataset. GitHub Copilot uses OpenAI Codex derivatives. The evidence that Zeta is markedly better or worse than Cursor Tab is anecdotal; no public head-to-head benchmark exists as of this writing.
Agent mode: threads, tool profiles, and MCP
Zed's Agent mode organizes work into threads in a sidebar panel. Each thread has an independent context window. Multiple threads run simultaneously — you can have one agent debugging a failing test while another documents an API endpoint. This is closer to Cursor's multi-agent setup (launched in 0.50) than to the single-session model in older Claude Code versions.
Context management is via @-mentions: @file, @directory, @symbol, @thread (reference a prior thread), @rules (project-level AI rules, similar to Cursor's .cursor/rules). You can attach images to threads if you're using a vision model.
Tool profiles control what the agent can do:
- Write — full tools: read files, edit files, run terminal commands
- Ask — read-only: no edits, no execution
- Minimal — no tools at all, just generation
- Custom — configure per-tool allow/confirm/deny
The confirm-by-default posture for tool execution is sane. For the destructive operations (file writes, shell runs), you get a diff view with per-hunk accept/reject. There's a checkpoint system that lets you revert to the state before any edit batch — equivalent to Cursor's checkpoint feature, which itself borrowed it from Devin.
MCP integration extends the tool set. Support level varies by model — not all 15 providers support tool use. Anthropic Claude, OpenAI GPT-5 variants, Google Gemini 3.1, and Mistral's tool-capable models work; some providers (DeepSeek, xAI Grok) may have partial support depending on which endpoint you hit.
Terminal Threads: running Claude Code inside Zed
The most novel feature in v1.3.5 — Terminal Threads — deserves its own section because it changes the economics of using Claude Code with Zed.
Before Terminal Threads, if you wanted to use Claude Code alongside Zed you opened a separate terminal window and tabbed between them. Now Claude Code (or Amp, or any CLI agent) runs as a persistent sidebar thread inside Zed, with the same navigation, notification, and context display as native Agent threads. You can have a Terminal Thread running Claude Code's agentic loop while your Agent Panel thread handles a different task, all within the same editor session.
This feature was built explicitly in
Top comments (0)