Claude Code in Zed: Setup, Login, and the ACP Agent Panel

Claude Code in Zed lets you run Anthropic's terminal coding agent directly inside the Zed editor through the Agent Client Protocol (ACP). You add it as an external agent in Zed's Agent Panel, authenticate once, and Claude Code works side by side with Zed's own agent — no separate terminal window needed.

Integration behaviour verified 31 July 2026 against Anthropic's IDE integrations guide.

Zed is a fast, Rust-based code editor built for speed and real-time collaboration. Claude Code is Anthropic's agentic command-line tool for editing, refactoring, and shipping real code. If you want a primer on the agent itself, our guide on what is Claude Code covers the fundamentals. This article focuses on one thing: getting the integration working, understanding how the integration is wired up, and knowing when to reach for it over the plain terminal. Claude Code currently runs on Anthropic's latest models like Claude Opus 5 and Claude Sonnet 5, and this guide is reviewed regularly — usually within 30 days of a major release — so the setup steps stay accurate.

How the ACP integration actually works

Zed and Claude Code connect over the open Agent Client Protocol rather than a bespoke plugin. The agent runs as its own process and keeps its own runtime; Zed supplies only the surface — thread view, native diffs, and file context.

Rather than building a one-off, tightly coupled plugin, the teams behind Zed and Claude Code connected the two through the Agent Client Protocol (ACP) — an open standard for talking to AI coding agents over JSON-RPC. An adapter wraps Claude Code's SDK and translates its messages into ACP calls that Zed understands. The upshot is that the agent runs as its own independent process, while Zed simply provides the interface: the thread view, the diffs, and the file context.

This "external agent" design has a few practical consequences. Claude Code keeps ownership of its own runtime, model selection, tools, and native configuration — your CLAUDE.md, settings, and MCP servers still apply. Zed owns the surface you look at: the Agent Panel and the Threads Sidebar. The boundary is clean, so Zed configuration stays on the Zed side and agent-native configuration stays on the Claude Code side.

Because the same ACP standard powers other agents too, you can run the agent next to Zed's first-party agent, Gemini CLI, Codex, and anything else that speaks ACP — all inside one editor. The adapter is open-sourced under the Apache license, so any ACP-compatible editor can adopt it.

How to set up Claude Code in Zed

Update to a current Zed build, open the Agent Panel, start a new thread from the Plus menu and pick Claude Agent, authenticate once, then prompt. If the agent is not listed, install it from the ACP registry in the Command Palette.

Setup is quick if you already have the editor installed. Because the integration is still maturing, make sure you're on the latest build first — Zed ships updates often, and older versions may not list Claude Code as an available agent. Anthropic documents the broader picture in its Claude Code IDE integrations guide.

1. Update Zed. Grab the newest release from zed.dev or let the built-in updater run. The ACP agent registry only appears on recent versions.
2. Open the Agent Panel. Press Cmd+? on macOS or Ctrl+? on Windows/Linux. The panel opens on the right.
3. Start a new agent thread. Click the + (Plus) button in the top-right of the panel and pick Claude Agent (Claude Code) from the menu. If it isn't listed, open the Command Palette (Cmd+Shift+P / Ctrl+Shift+P), search for acp registry, and install Claude Agent from there.
4. Authenticate. The first time you start a Claude Code thread, you'll be prompted to sign in (details below).
5. Prompt away. Ask Claude to explain a file, fix a bug, or build a feature. Proposed edits show up as native diffs you can accept or reject.

Here's a quick reference for the ways to add the agent:

If you'd rather compare editors before committing, our Claude Code vs VS Code breakdown looks at the other popular pairing.

Logging in for the first time

Two credential routes. Paste an Anthropic API key from the Console for per-token billing, or reuse an existing CLI login — because the adapter wraps the same SDK, a Pro or Max sign-in you already completed carries over with nothing to paste.

Because the agent is external, it manages its own authentication rather than borrowing Zed's. The first time you open a Claude Code thread, Zed prompts you to connect your Anthropic credentials. You have two options:

• Anthropic API key. Paste a key from your Anthropic Console. Usage is billed per token against that account. This is the path the Zed onboarding prompt shows by default.
• Existing Claude Code CLI login. Because the adapter wraps the same Claude Code SDK the terminal uses, it reads the same credentials. If you've already run claude in a terminal and signed in with your Claude Pro or Max subscription, that login carries over — no key to paste.

If you've never authenticated the CLI, our walkthrough on how to authenticate Claude Code in the terminal covers the browser-based sign-in flow step by step. Do that once and the editor integration will happily reuse it. Either way, you authenticate a single time per machine.

Running Claude Code alongside Zed's own agent

Nothing gets replaced. Each thread in the sidebar remembers which agent owns it, so a big refactor can sit with one agent while a quick single-file question goes to another — every edit arriving as a reviewable native diff.

One of the nicest things about the ACP approach is that the ACP integration doesn't replace anything. Zed has its own first-party agent, and the two live happily in the same Agent Panel. Each thread in the Threads Sidebar remembers which agent it belongs to, so you can keep a Claude Code conversation open in one thread and a Gemini CLI or Zed-agent conversation in another.

That makes it easy to route work by strength. Hand a big multi-step refactor to the Claude agent, ask a quick single-file question of the built-in agent, and never leave the editor. Every agent sees your open files and current selection as context, and every agent's edits arrive as reviewable diffs in Zed's native diff view. There's no copy-pasting between windows and no losing your place.

Claude Code in Zed vs the plain terminal

The CLI is still the more complete surface: the full slash-command set, ! bash shortcuts, and new features first. The editor wins on native side-by-side diffs and automatic file context, and Zed's built-in terminal gives you both at once.

The terminal CLI is still the most complete way to run the agent. The Zed integration is a graphical layer over the SDK, and while it's a pleasant experience, a few CLI-only features lag behind during the beta. Here's how the two stack up:

So which should you use? If you love staying inside a single editor and want reviewable diffs without context switching, the Zed integration is excellent. If you rely on a CLI-only feature — the full slash-command set, ! bash shortcuts, or tab completion — reach for the terminal. Handily, Zed ships with an integrated terminal, so you can run claude directly in a Zed terminal tab and get the complete CLI experience without opening a separate app. For the full command reference, see the Claude Code CLI documentation.

Beta caveats worth knowing

Treat it as production-usable for everyday editing, explaining, debugging, and committing, while keeping a terminal handy for the occasional advanced workflow. Update Zed first when a capability seems missing — the adapter tracks the SDK.

The Zed integration launched as a public beta, and Anthropic and Zed have been closing gaps steadily. At launch, a handful of terminal features — including full plan mode — weren't wired through the adapter yet and were being added over subsequent releases. If a capability you expect is missing, first update Zed, then check whether the adapter has caught up. Our note on how to update Claude Code covers keeping the underlying agent current, which matters because the adapter tracks the SDK.

Practically, treat the beta as production-usable for everyday coding — editing, explaining, debugging, committing — while keeping a terminal handy for the occasional advanced workflow. Because configuration is shared, anything you set up for the CLI (permissions, hooks, MCP servers, memory) applies to the editor integration too. That shared-config detail is what makes moving between the editor and the terminal painless.

We run InnovateTechie terminal-first rather than living in Zed all day, so we came at this integration warily — but the single design choice that would sell us on it is exactly that shared configuration. Our CLAUDE.md, hooks, and MCP setup are the source of truth for how the agent behaves, and the fastest way to break a workflow is to let a second surface quietly maintain its own forked copy. Because the ACP agent keeps its own runtime and reads the same files the CLI does, there is nothing to drift out of sync, which is the property we would refuse to give up before adopting any editor front end.