Zed Editor AI review 2026: the fastest native editor with built-in Claude — worth switching from Cursor?
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 response to Anthropic’s billing changes, per Zed’s own blog post from May 14 (“What Anthropic’s New Claude Billing Means for Zed Users”). The ACP protocol path for Claude was getting more expensive relative to running Claude Code as a terminal process. Terminal Threads lets you take the cheaper terminal billing path while keeping the UX in one window.
The practical implication: Zed + Claude Code CLI ($20/month Claude Pro or Max tier) can be a fully integrated setup without paying Zed anything beyond free tier. If you’re already paying for Claude Code, you get Zed’s editing speed for free.
See our Claude Code review for a full breakdown of the Pro/Max 5x/Max 20x tiers.
Claude integration details
Zed connects to Anthropic directly via API key (stored in OS secure credential storage, not plain text in config files). The available models as of v1.3.5:
claude-3-5-sonnet-20240620claude-sonnet-4-latest
Extended thinking mode is supported for Sonnet 4. Opus models are blocked during the Pro trial period (the $20 credit trial); after the trial, Opus availability depends on your API key permissions and willingness to pay API-rate Opus pricing.
If you want to use Claude Code as a Terminal Thread agent instead of the direct API path, that’s fully supported as described above — it routes through Anthropic’s Claude Code subscription billing rather than API token billing.
For the inline assistant and agent panel, claude-sonnet-4-latest is the recommended model for most tasks. It delivers the capability expected for file-editing and agentic work without the cost premium of Opus.
Zed vs Cursor: the comparison that matters
| Zed (Pro) | Cursor (Pro) | |
|---|---|---|
| Price | $10/month | $20/month |
| Free tier | Yes — BYOK unlimited | Yes — 2,000 completions |
| Editor base | Native Rust | VS Code fork (Electron) |
| Autocomplete model | Zeta2.1 (own model) | Cursor Tab (proprietary) |
| Agent mode | Threads + terminal threads | Composer Agent |
| Multi-thread agents | Yes | Yes (0.50+) |
| VS Code extensions | No (Open VSX alternative) | Yes (full VS Code Marketplace) |
| JetBrains support | No | No |
| MCP support | Yes | Yes |
| LLM providers | 15 | 7 |
| BYOK | Yes | Yes |
| Local models (Ollama) | Yes | Via third-party proxy |
| Terminal agent integration | Native (Terminal Threads) | External only |
| Team governance | Business tier ($30/seat) | Business (price on request) |
The extension gap is the genuine limiter. VS Code has 50,000+ extensions in its Marketplace; Zed has roughly 500 in its own registry. If your workflow depends on specific VS Code extensions — database explorers, framework-specific debuggers, test runners with custom UIs — you may not find them in Zed. Open VSX (the alternative registry Zed supports) has more, but not everything.
The performance gap is real but contextual. Zed starts faster, scrolls without jank on large files, and uses less memory than Cursor. If you spend your day in 50,000-line codebases or care that the editor doesn’t lag during AI generation, the Rust advantage is palpable. If you work in standard-sized repos, you may not feel the difference.
For local model use, Zed has a slight edge: native Ollama support with autodiscovery, no proxy layer required. See our Aider + local LLM guide for context on Ollama context-window settings that apply to Zed as well (the 4,096 default context warning is the same).
Where Zed breaks
Extension ecosystem. Not a knock on Zed’s quality — this is math. 500 extensions can’t cover the long tail of development tooling that 50,000 extensions covers. Python debugger, database clients, Docker, Kubernetes lenses — check availability in the Zed extension registry before switching, not after.
No JetBrains. If any part of your team uses IntelliJ, GoLand, Rider, or PyCharm, Zed doesn’t help them. Cursor doesn’t either, but JetBrains’ own AI Assistant and Junie cover that surface. Zed is a single-editor bet.
Pro token credit evaporates. $5 of LLM credits at Pro tier will last a light user half a day of agent work. Plan to BYOK on Pro or budget for monthly overage; $10/month is not a $10/month AI coding subscription.
Agent mode is newer. Cursor’s Composer Agent has been through more iteration cycles and has a larger installed base reporting edge cases. Zed’s Agent mode is capable — threads, tool profiles, checkpoints, MCP — but the rough edges that Cursor has ironed out over 18+ months will surface in Zed.
Opus blocked in trials. If you’re evaluating Zed Pro and want to test against Claude Opus 4.7, you can’t during the 2-week trial. You need a paid Anthropic API key for that.
Honest take
Switch to Zed if you meet all three of these:
- You already manage API keys (Anthropic or other) and want transparent billing
- You’re not dependent on specific VS Code extensions that aren’t in Zed’s registry
- You care about editor performance — startup, scroll, large-file handling
For this profile, Zed is the best editor available right now. $0 with BYOK, genuinely fast, Agent mode is solid, Terminal Threads solves the Claude Code integration cleanly.
Stay on Cursor if you’re on a standard VS Code workflow with extensions, a team that needs shared settings and governance at the VS Code level, or if you want an out-of-box AI experience without managing API keys. Cursor’s agent mode has more miles on it, the extension library is unmatched, and $20/month with included requests is simpler than managing API-level billing.
For developers using Claude Code as their primary agent anyway (see our Claude Code power user guide), running Claude Code as a Terminal Thread inside Zed free tier is worth a trial. You lose nothing on the Claude Code side and gain editor performance.
Zed isn’t trying to out-Cursor Cursor. It’s making a different bet: that the editor should get out of the way, that native beats Electron, and that transparent billing beats bundled tokens. For an increasing number of developers, that bet is correct.
1V1 STARTER KIT · CURSOR
Skip the week of trial-and-error setting up Cursor.
12 production-tested .cursorrules templates, 3 workflow configs, the cost-control checklist. Everything I wish I had on day one.
Get it for $19 (early bird) →Sources
- Zed pricing — zed.dev/pricing
- Zed AI documentation — zed.dev/docs/ai
- Terminal Threads Are Live in Zed — Zed blog, May 20 2026
- What Anthropic’s New Claude Billing Means for Zed Users — Zed blog, May 14 2026
- Zeta2.1: 3x Fewer Tokens, 50ms Faster — Zed blog, May 8 2026
- Zed v1.3.5 release notes — zed.dev/releases
- Zed LLM providers documentation — zed.dev/docs/ai/llm-providers
- Why and How to Run Local Models in Zed — Zed blog, May 19 2026
Last updated May 21, 2026. Pricing and features change frequently; verify current state before purchasing.
Was this article helpful?
Thanks for the feedback — it helps improve future articles.