Zed 1.0 ships its agentic editor. The Atom team's Rust rewrite finally has a stable label.

Zed Industries cut a 1.0 tag on April 29, five years into Nathan Sobo’s Atom-team rewrite. The bet was that Rust and a GPU renderer could outpace the next wave of cloud and agent tools. Today’s release puts the bet on the table.

The 1.0 milestone matters less for what changed in the binary than for what the label says. Zed has been the loudest argument that Electron was the wrong substrate for code editing. It’s also the first mainstream editor to ship parallel-agent collaboration as a primary feature, with an open Agent Client Protocol pulling Claude Code, Codex, OpenCode, and Cursor into the same surface. The release lands the same week GitHub Copilot announced token billing and Cursor told reporters it’s in talks to raise $2 billion at $50B. The IDE was supposed to be dying. Zed is making the opposite case.

What actually shipped

Sobo’s release post describes the binary as “over a million lines of code across five years of development.” Highlights from the changelog:

• Stable feature set across macOS, Windows, and Linux, after Windows shipped in beta last fall.
• A debugger with multi-runtime breakpoints, the last gap that kept long-time VS Code users on JetBrains.
• SSH remoting that runs the local UI against a remote project tree, similar in spirit to VS Code Remote, but driven by Zed’s own protocol rather than a forked Microsoft binary.
• Multiple agents in parallel, each in its own pane, with a shared chat surface that can dispatch a task to one and a follow-up to another.
• Edit predictions at keystroke granularity, not at line granularity, which is how Copilot and Cursor still work.
• Zed for Business, a centralized billing and SSO layer that sells the same client to engineering organizations.

Sobo’s framing in the post is direct. “Owning every layer of our stack lets us take Zed places that no one building on borrowed foundations can go.”

Rust and the GPU still matter

Zed’s pitch since the original Atom days has been that an editor’s perceived speed is bounded by its rendering loop, and a JavaScript renderer running inside Chromium will lose to native code drawing through the GPU. The team built GPUI to test that thesis: a UI framework written in Rust, drawing through Metal on macOS and through Vulkan and DirectX elsewhere, used by no other commercial editor.

That tradeoff was easier to explain in 2022 than it is in 2026. Modern Electron apps run smoother than they did. Copilot and Cursor have spent two years optimizing their VS Code forks. Most readers’ VS Code session feels fine on an M-series Mac, and the marginal latency win from a GPU renderer is harder to feel than it was.

What changed is what an editor has to do per keystroke. Cursor’s pitch is the agent loop. Copilot’s pitch is the agent loop. Replit’s pitch is the agent loop. Every one of those products renders increasingly heavy UI on top of an Electron base while running an LLM in a side panel. Zed’s argument is that the agent surface should be a first-class citizen of the rendering pipeline, not something bolted on. The 1.0 post calls out parallel agents specifically: each running plan, each with its own context, each visible in a single window without the dropped frames a chunky Electron tab would impose.

The independent test for that claim is the next twelve months of cold benchmarks. Phoronix’s release coverage flagged Zed 1.0 as the first Rust-written editor with a stable tag, and the Rust workstation crowd is the audience most likely to hammer on it. If they don’t ditch RustRover and Helix for Zed, the rendering pitch isn’t landing.

The agent surface is the real product

The headline feature for 1.0 is the Agent Client Protocol, an open spec that lets any agent runtime plug into Zed as a first-class collaborator. Day-one supported agents are Claude Code, OpenAI’s Codex, OpenCode, and Cursor’s. The agents read and write through the editor’s own LSP and CRDT layers, which means an agent’s mid-edit doesn’t blow away a human’s cursor position.

In a Sequoia podcast recorded ahead of the launch, Sobo argued that the IDE survives the agent era by becoming the place agents work, not the place they replace. “The meaning of collaboration has changed,” the 1.0 post echoes. “It used to mean humans working together in real time. Now it means humans and AI agents working in the same space, on the same code.”

That positioning matters because the alternatives are getting their own answers. OpenAI’s Codex desktop launched in April with an agent that drives the whole Mac, not just the editor. Cursor’s $50B raise is an agent-first IDE pitch. Microsoft’s Copilot agents work inside VS Code’s existing chat panel, with usage-based billing starting June 1. Zed’s response is a protocol every other vendor is welcome to implement, on top of an editor optimized for showing four of them at once.

The sleight is real. Cursor and Codex compete with each other and with Copilot. Zed competes with the editor each of them is forking. The Agent Client Protocol turns agent vendors into Zed integrations, which is a much better seat than being the next forked editor.

What the pricing tells us

Zed’s pricing page sits in an unusual spot for a 2026 dev tool:

The Personal tier is the part to read carefully. “Free forever” includes the full editor, the agent panel, the debugger, SSH remote, and bring-your-own-key for any AI provider. The hosted-AI tier starts at $10, which is half of Cursor’s $20 and a third of Copilot’s $30 Pro plan. The $5 of monthly token credit on Pro reproduces Copilot’s token-billing model that ships in June, but at a lower starting commitment.

The license also matters. Zed’s editor ships under GPLv3; the GPUI framework is Apache-2.0; the server pieces are AGPL. That isn’t a quirk. A copyleft editor doesn’t get quietly forked into a closed agent product, the way VS Code’s MIT license enabled Cursor and Codex Cloud and a half-dozen others. Zed is daring its competitors to build on it instead of around it. None has yet.

Why you’re hearing about this now

A 1.0 tag is a marketing event, not a binary cut. Zed has been usable for two years; the team announced the open-source flip in 2024 and raised $32 million from Sequoia in 2025. The label is being shipped now because the agent fight got hot enough that “stable release” needed to be on the marketing page.

Three things to watch over the next quarter. First, adoption among Rust and infra teams. The Phoronix audience is the early-warning indicator. If Zed shows up in the next round of “what’s in your dotfiles” surveys, the rendering pitch landed. Second, whether the Agent Client Protocol gets a second platform. A standard with one implementation is a product feature. Two implementations make it a standard, and Cursor and Copilot haven’t committed. Third, Cursor’s response. Anysphere is racing to spend its $50B paper valuation on something durable. A Rust rewrite of Cursor’s editor would be the obvious move; the alternative is letting Zed eat the agent-IDE pitch on a free, GPL editor.

If you spend your day in VS Code or Cursor and the Electron lag has stopped bothering you, Zed 1.0 isn’t a forced switch. If you’ve been waiting for an agent-first IDE that doesn’t lock you to one vendor’s model, this is the release that opens the door.