Zed 1.0: An Open Agent Protocol Lands in a Rust IDE

What changed with Zed 1.0

After three years in beta, the Rust-built editor Zed reached version 1.0 on 29 April 2026. The headline feature is not a new chat panel or another bundled model. It is a documented, open specification called the Agent Client Protocol (ACP) that lets any external command-line coding agent plug into the editor as a first-class participant. Alongside ACP, the 1.0 release brings parallel agents in a single window, support for DeepSeek V4 and Claude Opus 4.7, and the open-weight Zeta2 edit-prediction model.

For builders evaluating IDEs in May 2026 — whether you are a product team in Bengaluru trying to standardise on a single editor, or a regulated-sector engineer in Manchester who cannot ship source code to a third-party API — Zed 1.0 changes the shape of the conversation. The interesting question is no longer "which IDE has the best agent?" It is "which IDE will host the agent you have already picked?"

• 1.0 milestone ends the perennial "is Zed production-ready?" question. The editor is now stable, versioned and supported.
• Agent Client Protocol is the genuine headline — an open spec that decouples the editor from the agent runtime.
• Parallel agents work concurrently on different parts of a codebase in one window, the way Cursor 3 popularised — but here the agents can be interoperable.
• Zeta2 is the first credible open-weight edit-prediction model, which matters for offline and regulated environments.
• Business plan adds org-wide model controls, per-member spend tracking and data policies for teams.

The Agent Client Protocol, explained without hand-waving

Most AI-first editors today bundle their agent. Cursor ships Cursor agents, Windsurf ships Cascade, GitHub Copilot Workspace ships its own runtime. The agent is a feature of the editor, not a separate process you can swap. That coupling is convenient — until you realise your team has standardised on one agent (often Claude Code) and the editor's bundled agent is a strictly worse experience for the work you actually do.

ACP breaks the coupling. It defines a documented interface between an agent client (the editor) and an agent runtime (Claude Code, Codex, OpenCode, anything else that implements the spec). The agent runs as a separate process. The editor speaks ACP to it. Each side has clear responsibilities: the editor exposes filesystem, language-server, linter, formatter and terminal capabilities; the agent decides what to read, what to write and what to run.

The closest mental model is the Model Context Protocol for tools, but one layer up. MCP standardised how an agent talks to its tools. ACP standardises how an editor hosts an agent. If you have followed our coverage of the AGNTCY interoperability standard or the broader agent-SDK wars, ACP fits the same pattern: open the runtime, let the ecosystem compete on agents rather than on lock-in.

Parallel agents, but interoperable

Zed 1.0's parallel-agent model is structurally similar to what we covered in our piece on Cursor 3 and the parallel-agent IDE paradigm. You can have multiple agents working on different parts of the codebase in a single window — one writing a migration, another refactoring tests, a third reviewing a pull request — without context bleeding between them.

The difference is what runs in each pane. Cursor's parallel agents are Cursor's own. Zed's parallel agents can be whatever ACP-compatible runtime you choose. You can have Claude Code in pane one and Codex in pane two if your team prefers the strengths of each. Each agent inherits the full editor surface — it can edit the filesystem, query the language server, run linters and formatters, and execute terminal commands in your local shell. The capability surface is identical; the runtime that decides how to use it is yours.

Zed vs Cursor vs Windsurf vs VS Code + Claude Code

For Indian and UK teams comparing AI-first IDE strategies in mid-2026, here is the practical landscape:

Editor	Agent model	Parallel agents	Open agent spec	Best for
Zed 1.0	External via ACP	Yes, interoperable	Yes (ACP)	Teams that have picked their agent and want a fast editor
Cursor 3	Bundled Cursor agents	Yes, proprietary	No	Teams that want the most polished out-of-the-box agent UX
Windsurf	Bundled Cascade	Limited	No	Solo developers comfortable in a Cascade-first workflow
VS Code + Claude Code	External CLI agent (no formal spec)	Via multiple terminals	Informal	Teams locked into VS Code extensions and Microsoft tooling
Amazon Kiro	Bundled Kiro agents	Yes	No	AWS-native teams (see our Kiro coverage)

The honest read: if your team has already chosen Claude Code as the daily driver — and many have, especially after the /autopilot release with Opus 4.7 as default — Zed 1.0 is the editor most aligned with that choice. If you have not yet picked an agent and want the smoothest evaluation experience, Cursor 3 is still the safer first step.

Zeta2 and the open-weight edit-prediction story

Inline edit prediction — the grey-text suggestions that complete the next chunk of code as you type — has been a closed-model game. Cursor uses its own model, Copilot uses an OpenAI-derived model, JetBrains uses theirs. Zed has published Zeta2 as an open-weight model trained specifically for in-editor edit prediction.

For a regulated UK fintech that cannot send keystrokes to a third-party API, this is the first credible option to get smart inline completions on a self-hosted model. The same applies to Indian enterprises in BFSI and healthcare where data-residency rules make routing every keystroke to a US-hosted model a non-starter. You still pay the cost of running the inference somewhere — a modest GPU or even a high-end CPU is sufficient for edit prediction — but the data never leaves your network.

What the 1.0 release fixed under the hood

Three quieter improvements matter for daily use:

• Edits applied even when files change on disk. If your agent is editing a file while a build process rewrites it, Zed 1.0 reconciles the change rather than throwing the agent edit away. This is a long-standing frustration with agentic IDEs and the fix removes a real source of dropped work.
• Reliability improvements when the LLM edits a file. Diff application is more forgiving of whitespace drift, line-ending differences and minor reformat collisions. Fewer "I tried to edit this but it did not apply cleanly" loops.
• Per-agent capability scoping. Each agent can be granted or denied filesystem write, terminal access and language-server queries. For teams running multiple agents in parallel, this is the granularity you need to keep blast radius small.

The speed conversation, in proportion

Zed is genuinely fast. It is written in Rust, GPU-rendered, and noticeably snappier than Electron-based editors on the same machine. This matters more for keystroke-sensitive engineers — Vim users, anyone who works on a laptop without continuous power, anyone running multiple language servers simultaneously — than it does for Claude-first workflows where most of your time is waiting for a model anyway.

Do not let "Zed is fast" be the reason you switch. Let "Zed hosts the agent I have already chosen, on an open spec" be the reason. The speed is a pleasant bonus, not the headline.

Concrete patterns for Indian and UK teams

Two scenarios we are seeing among Builders this week:

Indian product team running Claude Code inside Zed via ACP without touching Cursor. A Bengaluru SaaS team had standardised on Claude Code from the CLI but wanted a proper editor surface for code review and refactoring conversations. They installed Zed 1.0, configured Claude Code as the ACP agent, and kept their CLI muscle memory intact. No Cursor licence, no second agent to maintain, one editor across the team.

UK regulated-sector team using Zeta2 locally for completions. A London-based health-tech firm cannot send patient-adjacent code to any third-party inference API under their DPA agreement. They run Zeta2 on a modest internal GPU server for inline edit prediction and keep substantive chat work to a private Claude deployment via Anthropic's enterprise tier. The result is in-editor productivity without breaking the data-residency model.

Where Zed 1.0 still has work to do

Three honest limitations:

1. Plugin ecosystem is thinner than VS Code's. If your daily workflow depends on an obscure VS Code extension, you may not find a Zed equivalent. The extension model is younger.
2. Windows support lags macOS and Linux. Not catastrophic, but if half your team is on Windows, do a real evaluation before standardising.
3. ACP is new. The spec is open and the reference implementations work, but the long tail of edge cases — auth flows, large-context streaming, multi-agent coordination — will only get hammered out as more agents adopt it.

The bottom line

Zed 1.0 is not the most polished AI-first IDE on the market. Cursor 3 still holds that position. But Zed 1.0 is the most open AI-first IDE — and given how quickly the agent runtime market is changing, betting on openness is a more defensible position than betting on whichever bundled agent happens to be best this quarter.

If you are a builder picking an editor in May 2026, the question to ask is not "which agent ships in the box?" It is "which editor lets me change my mind about the agent in six months without changing my editor?" Zed 1.0 is the answer with the cleanest story to that question today.

Primary sources: zed.dev/ai, the devclass release coverage, Zed's models documentation and the releasebot changelog feed.