Zed AI in 2026 — how the built-in LLM features stack up
Zed AI is fast and private but lacks codebase indexing — behind Cursor on unfamiliar repos. Worth it if editor speed and BYOK matter more than semantic search.
By Ethan
1,399 words · 7 min read
Zed’s AI features are fast, private, and well-integrated — but not yet as capable as Cursor’s on codebases you haven’t personally mapped. If you value low-latency completions, zero-data-retention BYOK, and parallel agent threads over semantic repo search, Zed Pro at $10/month is worth switching for. If you live in large unfamiliar repos where semantic indexing matters, stay on Cursor.
Who this is for
Developers who already use or are evaluating Zed as their main editor and want to know whether the built-in AI layer is good enough to drop Cursor or Copilot. If you’ve never tried Zed and editor performance isn’t a priority, the AI features alone aren’t a compelling reason to switch.
What we tested
Zed: v1.3.6 stable (macOS ARM, same machine as the Zed 1.0 general review)
Zed AI components: Edit Prediction (Zeta2), Inline Assistant, Agent Panel
Baseline comparisons: GitHub Copilot Pro ($10/mo), Cursor Pro ($20/mo)
Cold-start, RAM, editor input-latency, and inline completion latency comparisons are toolchew’s own measurements on an M2 MacBook Pro 14” (Apple M2, 16 GB RAM). Cold start: time from terminal launch to first keystroke-ready state, with purge && sync run before each launch to clear the OS file cache. Test project: the toolchew monorepo (approx. 15,000 lines of TypeScript). Each figure is the median of 5 trials. Copilot inline-completion latency (~167ms) measured over 50 consecutive completion triggers in the same project.
The three AI layers
Zed ships three distinct AI components. They’re easy to conflate, so it’s worth separating them upfront.
Edit Prediction (Zeta2)
This is Zed’s in-line completion engine — the thing that fills in code as you type. The model is Zeta2, Zed’s purpose-built completion model. Zed runs it through their hosted inference; you don’t supply your own API key for this unless you want to.
Zeta2 is LSP-aware. It reads your language server’s symbol graph alongside the file buffer, which means it suggests methods that actually exist on the type in scope rather than hallucinating plausible-sounding names. That’s a concrete advantage over systems that only send raw text context.
Latency improved over Zeta1 — Zed’s blog notes the improvement without publishing a specific p50 figure. Acceptance rate also improved by ~30% over Zeta1; Zed hasn’t published the raw number, only the delta. In practice it feels on par with Copilot inline completions and faster than Cursor on an equivalent machine (Cursor’s Supermaven-based completions are faster still, but Cursor brings 3 GB of RAM with it; Zeta2 runs inside a 222 MB editor).
The Free plan caps you at 2,000 predictions per month. Pro ($10/mo) is unlimited predictions plus a $5 hosted-model token credit.
Inline Assistant (Ctrl+Enter)
Select code, press Ctrl+Enter, type a prompt. Zed transforms the selection in-place, shows a diff, and lets you accept or reject. There’s no chat window — it’s a direct edit loop.
The model powering this is configurable. By default it pulls from Zed’s hosted inference; you can swap it to any of the 12+ supported providers (Anthropic, OpenAI, Google, Ollama, GitHub Copilot proxy, and others). If you BYOK, Zed sends zero data to its own servers for that request.
This is the feature that most directly replaces Copilot’s “Ask Copilot to fix this” inline flow. The workflow is faster because there’s no sidebar to open — but it also means there’s no conversation history to refer back to, which limits it for anything requiring multi-turn refinement.
Agent Panel
The Agent Panel is a full agentic interface: persistent chat, file reads, shell tool calls, MCP server integration, and as of April 22, 2026, Parallel Agents. You can spawn multiple independent agent threads, assign each a different model, and isolate them in separate git worktrees to avoid conflicts.
The practical use case: one thread investigates a bug, another thread drafts tests, both run concurrently without stepping on each other’s file state. If you’re running Claude Code or Codex externally via the Agent Communication Protocol (ACP), those also integrate here.
The Agent Panel supports models from 12+ providers — Claude, GPT, Gemini, Grok, DeepSeek, and others, configurable per provider. The specific default for new installs isn’t documented explicitly — you’ll likely see a prompt to pick a model on first use.
The gap that matters: no codebase indexing
Cursor indexes your entire repository semantically. When you ask “where does the auth middleware read the user ID?”, Cursor retrieves relevant files based on meaning, not text matches. You don’t have to tell it where to look.
Zed does not have this. Context is explicit: you use @file, @symbol, or @folder to tell the agent what to look at. For repos you know well, this isn’t a real obstacle — you probably know where the auth middleware is. For large, unfamiliar repos you’re onboarding into, the lack of semantic search is a genuine productivity gap.
This is listed on Zed’s public roadmap. As of June 2026, no ship date has been announced.
Performance is not a tiebreaker — it’s a structural advantage
People write “Zed is fast” as if it’s a nice-to-have. The numbers tell a different story:
- Cold start: 0.6s vs 4.5s for Cursor
- RAM at rest: 222 MB vs 3+ GB for Cursor
- Input latency: 2ms vs ~30ms for Cursor
These aren’t synthetic benchmarks — they’re the actual memory and CPU budget available for AI inference, LSP indexing, and extension work. An editor that uses 222 MB of RAM gives the OS more headroom for whatever LLM process you’re running alongside it. If you’re paying for a Mac and running local models via Ollama, that headroom matters.
Verdict table
| Dimension | Zed AI (Pro) | GitHub Copilot Pro | Cursor Pro |
|---|---|---|---|
| Inline completion latency | fast (no p50 published; see Zeta2 section) | ~167ms (toolchew) | faster than Copilot (toolchew observation) |
| Context depth | File/symbol-level (explicit) | File-level | Repo-level (semantic index) |
| Agentic capability | Parallel threads, ACP, MCP | Copilot Agent | Composer 2, background agents |
| Model flexibility | 12+ providers | Limited | Multi-model |
| Price (base) | $10/mo + token costs | $10/mo (Pro) | $20/mo |
| Privacy / BYOK | Best (zero data retention) | Good | Good |
| Raw editor speed | Best | N/A (plugin) | Slowest (Electron) |
| Extension ecosystem | hundreds | 50,000 | 50,000 |
Who should switch to Zed AI
Strong case for Zed:
- You’re already on Zed for editor speed and want AI that fits the same philosophy
- You run MCP-heavy workflows — Zed’s Agent Panel integrates natively
- Privacy matters: BYOK with zero data retention on Zed’s servers is a cleaner story than most alternatives
- You use Claude Code or Codex externally and want ACP integration in the same tool
- Parallel agent workflows are part of your process and you want them without running separate terminal processes
Stay on Cursor or Copilot if:
- You regularly onboard into large, unfamiliar codebases — semantic search is faster than @-mentioning files manually
- Your workflow depends on VS Code extensions that haven’t been ported — see Zed vs VS Code for a full ecosystem comparison (50,000 in VS Code vs hundreds in Zed)
- You’re on a GitHub-integrated team where Copilot’s native PR review and issue features reduce context-switching
If you’re coming from Copilot specifically, the $0/month cost delta (both are $10/mo Pro) and Zed’s stronger BYOK story make it a reasonable experiment. The main risk is extension dependencies.
Caveats
The +30% Zeta2 acceptance rate improvement is relative to Zeta1, not an absolute figure — Zed hasn’t published the raw number, and it shouldn’t be compared directly to acceptance rates quoted by other vendors (who use different measurement methodologies).
We did not test the default hosted model selection for new Agent Panel installs — the docs don’t specify it explicitly, and it may vary by region or account state.
Codebase indexing availability is based on public GitHub issues and the Zed roadmap as of June 2026. Check github.com/zed-industries/zed/issues for current status before making a purchasing decision based on this gap.
If you use Zed with the Anthropic BYOK option, you can set that up via the Anthropic API.