Zed vs Cursor

Short answer: if your work depends on a specific VS Code extension, this is already decided and the answer is Cursor. Cursor is a fork of VS Code, so extensions, keybindings, themes and muscle memory transfer intact. Zed is a separate editor written from scratch and it does not run them.

If you don't, Zed is the faster and considerably more open answer, and its free tier is genuinely free rather than free-until-you-use-it. The openness is the part the comparisons skip, and it's the more interesting half of this page.

A fork and a rewrite

Cursor is a fork of VS Code with inline completion, multi-file edits and an agent mode built on top. That inheritance is the product's single biggest asset: your settings.json, your extensions, your keybindings and every reflex you have already trained all keep working. Anysphere does not publish Cursor's source.

Zed is a new editor. Zed Industries describes it on the front page as "Written from scratch in Rust to efficiently leverage multiple CPU cores and your GPU." There is no Electron layer and no VS Code lineage. The editor is published under GPL-3.0, with Apache-2.0 covering parts of the tree, and the repository sat at 87,791 stars on 2026-07-31.

The trade is unusually clean: Cursor gives you an ecosystem you already live in; Zed gives you speed and openness in exchange for leaving it. Everything below is detail on what each side of that buys.

The extension gap, counted

Most articles wave at this with "Zed has fewer extensions." Here are the numbers, measured on 2026-07-31 from the registries rather than from anyone's blog post:

Two honest qualifications, in opposite directions. Against Zed: the ratio understates it, because roughly a quarter of that registry is themes, and the VS Code long tail is exactly where the extension you personally need tends to live — a vendor's proprietary debugger, a client's linter, an internal plugin someone wrote four years ago. Nobody is porting those.

Against the table: the two numbers don't measure the same thing. Zed builds in-tree much of what VS Code delegates to extensions — language servers, git, terminal, debugger, collaboration, the AI panel — so a large slice of a typical extension list is filling gaps Zed doesn't have. The real test isn't "how many," it's whether your five are covered.

What "fast" means here

Zed's performance claim is architectural rather than a benchmark: Rust, a GPU-accelerated renderer, no JavaScript runtime between your keystroke and the screen. Cursor inherits VS Code's Electron architecture, which is a genuinely impressive piece of engineering and still a browser rendering an editor.

We are not going to give you a millisecond figure. The numbers circulating for both products come from methodologies we cannot inspect, on hardware and file sizes that are rarely stated. Zed's own homepage doesn't make a first-party latency claim either; the closest thing on it is a customer quote.

What actually matters, and what you can establish yourself in ten minutes: cold start, typing latency in your largest real file, and scroll in a session with a lot of open buffers. The difference on those three is usually obvious without instrumentation, and more obvious on a large repository than a small one. Zed costs nothing to install, so measure it rather than argue about it.

What each costs

As of 2026-07-31, from both vendors' pricing pages.

The tiers don't line up cleanly because they meter different things. Zed's Personal tier includes "2,000 accepted edit predictions" and, critically, "Unlimited use with your API keys or external agents like Claude Agent, Codex CLI, and more." Pro at $10 buys unlimited edit predictions plus "$5 of tokens included", with hosted usage past that billed at API list price plus 10% under a configurable spending cap. Business seats carry no bundled credits — you either pay hosted rates or point them at your own keys and the provider bills you directly.

Cursor's meter has been the story of that product: it has moved between fixed request counts and shared usage-credit pools more than once. That's why cost comparisons here age badly, and why you should check the pricing page rather than trust any table, this one included, a few months from now.

Bring your own key: two different things

Both products list bring-your-own-key support and mean substantially different things by it. Cursor's own documentation is direct about the scope:

Custom API keys only work with chat models. Tab completion continues using Cursor's built-in models.

Chat models only. Tab is named explicitly; Apply and agent mode aren't chat either, so they sit outside it too — which means the expensive operations, the ones that would justify running your own key on cost grounds, are exactly the ones it doesn't cover. There is a second consequence for anyone with a data policy:

Cursor's Zero Data Retention policy does not apply when you use your own API keys.

The docs go on to recommend that teams relying on ZDR use Cursor's built-in models instead. The key itself also transits Cursor's infrastructure — "all requests are routed through Cursor's servers for final prompt building" — though the docs state it is not persisted after the request completes. That's a coherent design; it just isn't what "BYOK" implies to most people reading it on a feature list.

Zed's version is the plain reading of the phrase, and it starts on the free tier. Documented providers include Anthropic, OpenAI, Google AI, Mistral, DeepSeek, xAI and OpenCode as first-class options, any Anthropic- or OpenAI-compatible endpoint by base URL, plus OpenRouter, Vercel AI Gateway, Amazon Bedrock, Ollama and LM Studio. The last two mean inference that never leaves your machine.

Zed can host somebody else's agent

This is the underrated part, and it reframes the question. Zed implements the Agent Client Protocol, which the protocol's own site describes as a standard that "standardizes communication between code editors/IDEs and coding agents" — explicitly analogous to what the Language Server Protocol did for language support, and explicitly motivated by integration overhead, limited compatibility and developer lock-in.

Per Zed's documentation: "External Agents are agents that integrate with Zed through the Agent Client Protocol (ACP)". Zed supplies the surface, hosting the thread in the agent panel, while "the External Agent usually owns its own runtime, auth, model selection, tools, and native configuration." They run as separate processes. And the line that matters for budgeting: "Zed does not charge for External Agents."

The curated list in Zed's docs on 2026-07-31 names Claude, Codex, OpenCode, Copilot and Pi Coding Agent, with Gemini CLI documented separately — and, notably, Cursor. You can run Cursor's agent inside Zed. The docs call the list curated rather than exhaustive; anything ACP-compatible that isn't in the registry goes in as a custom agent_servers entry pointing at a command.

Stripped of the protocol talk: you authenticate the agent with its own vendor, not with Zed. Claude Code logs in inside the thread with /login, reads your CLAUDE.md natively, and bills against the Claude subscription you already have. A Zed-side Anthropic key does not carry over — that surprises people, and it's correct, because the agent owns its own auth. You aren't buying inference twice, and you aren't committed to whatever agent your editor vendor ships.

That last clause is the real question underneath "Zed vs Cursor." Cursor's agent is Cursor's — a good agent, and the only one with first-class treatment in that editor. Zed's position is that editor and agent should be separable, so the agent you use next year needn't be the one you picked this year. If you have opinions about vendor lock-in, this is where they apply, and it's a different axis from speed or extension count. It's also why the terminal-agent comparison is often the more useful page to read alongside this one.

One caveat from the protocol site, since this gets overstated: local agents run as editor subprocesses over stdio, and "Full support for remote agents is a work in progress." It's a solid local mechanism, not a finished distributed one.

Choosing

• You depend on a specific VS Code extension. Cursor. Nothing else on this page outweighs it, and no amount of speed compensates for a toolchain you can't run.
• You want inference on an account you control, across the whole editor. Zed, on the free tier, today. Cursor's BYOK does not reach the agent.
• You need zero data retention. Neither is clean. Cursor has ZDR and loses it the moment you supply a key; on Zed your policy becomes whichever provider you keyed in, which is either exactly what you wanted or a new question for legal.
• You want the agent decision kept separate from the editor decision. Zed, via ACP.
• You're standardising a team. Cursor Teams $40/user against Zed Business $30/seat, plus the migration cost of moving everyone off VS Code — a real cost, paid in the first two weeks, in keybindings.
• Latency on a large repository is what's bothering you. Install Zed and find out; it's free and takes an afternoon.

The cheap experiment, before reading any more comparisons: install Zed alongside whatever you use now, point it at your own API key, and add your existing terminal agent through the ACP registry. That costs nothing beyond tokens you were already buying, and it settles the extension question and the speed question in two days of real work rather than in the abstract. If the answer comes back "I miss three extensions," that's a specific finding, and Cursor is waiting.

Sources

Read on 2026-07-31. Extension totals were measured directly from each registry that day. No performance benchmarks are quoted because we could not verify the methodology behind any of the circulating figures. This category re-prices often; check before committing budget.

• Zed — pricing · zed.dev · zed-industries/zed
• Zed — External Agents (ACP) · Zed — using your own API access
• agentclientprotocol.com — the protocol itself
• Cursor — bring your own API key · cursor.com/pricing
• Visual Studio Marketplace — VS Code extension total

Not affiliated with Zed Industries or Anysphere. If something here is wrong or has gone stale, tell us and we'll fix it.