---
title: "Drop Reasonix into Zed via the ACP"
description: "How to wire Reasonix — a DeepSeek-native terminal coding agent — into Zed as a custom assistant, until it lands in the official registry."
pubDatetime: 2026-06-02T08:00:00Z
author: hrbrmstr
tags: ["tool", "zed", "reasonix", "deepseek", "acp", "editor", "cli"]
---
> Original: [Drop Reasonix into Zed via the ACP](https://ai.rud.is/posts/2026-06-02-reasonix-acp-zed)

Zed's Agent Communication Protocol (ACP) lets you plug any agent that speaks the protocol into the editor's assistant panel. [Reasonix](https://esengine.github.io/DeepSeek-Reasonix/) — the terminal-first, DeepSeek-native coding agent — ships an ACP endpoint, meaning you can run it inside Zed without waiting for an official extension.

If you already have [Node ≥ 22](https://nodejs.org/) and a [DeepSeek API key](https://platform.deepseek.com/api_keys), the setup is a single config block.

## The config

Open your Zed settings (`~/.config/zed/settings.json` on Linux, or `cmd-,` → "Open Settings JSON" on macOS) and add this to the top-level object:

```json
"reasonix": {
  "type": "custom",
  "command": "npx",
  "args": ["reasonix", "acp"],
  "env": {}
}
```

Restart Zed (or run `zed: reload extensions` via the command palette), then select **reasonix** from the assistant provider dropdown in the bottom-right of the assistant panel.

That's it. The ACP exposes Reasonix's tool set — `read_file`, `write_file`, `edit_file`, `run_command`, `search_content`, `web_search`, web fetch, and the rest — as Zed assistant tools, with the same sandbox and plan-gate guards as the terminal TUI.

## Why not wait for the registry?

The official Zed extension registry is gated, and Reasonix is MIT-licensed open-source with a fast release cadence (v0.53 as of this writing). The ACP endpoint is stable at the protocol level, so this manual mount won't break between updates. When the official extension ships, you swap the provider dropdown — the config stays.

## What you get

- **Terminal-native loop inside Zed's editor** — same append-only, cache-first
  loop that hits ~94% prefix-cache on long sessions
- **V4 two-tier** — Flash by default, `/pro` to escalate a turn to DeepSeek V4-Pro
- **MCP tools on tap** — mount external MCP servers via your
  `~/.reasonix/config.json` and they merge into the same tool registry
- **Sandboxed file ops** — all tools scoped to the project directory;
  SEARCH/REPLACE queues as pending until you `/apply`

The ACP handshake and tool list are all logged to disk, so you get the same replay and stats story (`reasonix replay`, `reasonix stats`) that the TUI gives you.

## Gotchas

- ACP mode doesn't support `/plan` — use the terminal TUI for plan-gated workflows, then switch to Zed for iterative editing (or use Compound Engineering from the Every.to team)
- The first launch walks you through pasting a DeepSeek API key if you haven't set one up yet. That's a one-time thing.
- Session is tied to the project root — no mid-session `cd`. Exit and relaunch to switch directories.

## A word of caution on hosted models

Reasonix defaults to DeepSeek's hosted API, and DeepSeek is a Chinese company subject to the PRC's data laws. That means every prompt, every file snippet, and every tool call you send across the wire lives on infrastructure governed by those laws — with no meaningful transparency into retention, access, or third-party sharing.

This isn't FUD; it's due diligence. Any hosted model — whether from DeepSeek, OpenAI, Anthropic, or anyone else — gets a look at the full context of whatever you're working on. For toy projects and learning, the trade-off is likely fine. For anything proprietary, sensitive, or production-grade, treat hosted inference as you would any other third-party SaaS: assume the payload is retained, assume it can be subpoenaed under the provider's local jurisdiction, and act accordingly.

The mitigation is straightforward: self-host. DeepSeek's weights are available under a permissive license, and [the GitHub Reasonix](https://github.com/esengine/deepseek-reasonix) should work fine pointed at any compatible local inference endpoint (vLLM, Ollama, llama.cpp serve, etc.). Swap the `base_url` in your `~/.reasonix/config.json` and the traffic never leaves your machine.

If you hit anything weird, the Reasonix repo has [a Discussions board](https://github.com/esengine/DeepSeek-Reasonix/discussions) and the ACP endpoint code is readable at [src/acp/](https://github.com/esengine/DeepSeek-Reasonix/tree/main/src/acp). Until the registry listing ships, this is the fastest way to try Reasonix inside Zed.