Most AI coding assistants feel like plugins bolted onto existing editors. They're powerful, sure, but they're guests in someone else's house. You can decorate, maybe rearrange some furniture, but you're not touching the foundation.

Zed is different.

Built in Rust from the ground up, Zed was designed with AI as a core feature, not an afterthought. And after spending time with their agentic editing system, I think there's a lesson here for anyone building AI-powered developer tools: the infrastructure matters as much as the model.

The Speed Problem

When Nathan Sobo and the Zed team started building their AI assistant, they didn't start with prompts or fine-tuning. They started with a question: why does AI-assisted editing feel slow?

The answer was obvious when they spelled it out. Most AI coding tools work like this: you select some code, send it to an API, wait for a response, then apply the edit. Each round trip adds latency. Each context switch breaks your flow.

Zed's approach is fundamentally different. Their agents run at 120fps—same as the editor itself. When you delegate work to a Zed agent, it's not making API calls in sequence. It's batching operations, applying changes incrementally, keeping the editor responsive the entire time.

This isn't a small optimization. It's a different mental model. The agent isn't a separate tool you invoke. It's part of the editing experience.

What "Agentic" Actually Means in Zed

Zed's agentic editing isn't about autonomous agents running wild in your codebase. It's about collaborative agents—AI systems that can read your code, propose changes, and apply them, but always with your oversight.

From what I've seen in their agentic editing documentation, the key innovations are:

  1. Inline transformations — You don't just get a diff to review. The agent can make targeted changes directly in your code, preserving your project's style and conventions.

  2. Massive context — Zed was built to handle large codebases efficiently. Their assistant panel can load entire modules, understand dependencies, and make informed changes without you manually copying relevant files.

  3. Tool use — The agent can run commands, search files, navigate your project—everything you'd do manually, but orchestrated.

JosĂŠ Valim, creator of Elixir, tried Zed's agent and reported that it delivered complete features while preserving his project's coding standards. That's the dream, right? An AI that writes code like you'd write it.

Why Rust Matters Here

You might wonder: why does the editor being written in Rust matter for AI features?

Here's my take as someone still learning Rust: Rust gives you predictable performance. No garbage collection spikes, no hidden background threads eating your CPU. When you're building a real-time AI system that needs to stay responsive while processing code, that matters.

Zed's team has talked about how their text handling, project indexing, and AI processing all share the same async runtime. The editor doesn't pause while the AI thinks. They're happening in parallel.

This is the same reason I'm building my own tools in Rust. When performance matters—and with AI, it always does—you want a language that gives you control.

What This Means for the Future

I've written before about agent runtimes and how AI agents solve code problems.

We're moving past the era where AI coding meant "paste code into ChatGPT, copy the result back." Tools like Zed, Cursor, and the upcoming generation of AI-native editors are building infrastructure where AI is always available, always fast, and always working with you rather than for you.

The difference between "AI assistant" and "agentic editing" isn't semantic. It's about whether AI is a feature you enable or a fundamental part of how you write code.

I'm curious to see where this goes. If Zed's approach catches on—and the early reviews from developers like Amos Wenger and José Valim suggest it might— we'll see more editors treating AI as infrastructure, not integration.

The Rust ecosystem gets faster this way. The AI gets faster too. And developers like me get tools that finally feel like they were built for how we actually think.