# Zed Editor + Docker Agent + ACP: coding with a local agent plugged into llmman

> Source: <https://k33g.org/p/20261003-acp-zed-docker-agent>
> Published: 2026-10-03 00:00:00+00:00

# Zed Editor + Docker Agent + ACP: coding with a local agent plugged into llmman

## [In two minutes](#in-two-minutes)

Today I'm showing you how to plug **[Zed](https://zed.dev/)**, my code editor, into an agent that runs **locally**, thanks to the **[ACP](https://agentclientprotocol.com/get-started/introduction)** protocol.

The agent in question is **[Docker Agent](https://docker.github.io/docker-agent/)**. And for the language model, I'm not going to call a cloud API: I'm going to point Docker Agent at **[llmman](https://llmmanorg.github.io/)**, which serves my local model behind an OpenAI-compatible API.

I wrote an article on how to use **llmman**: [k33g.org/p/20261001-llmman](https://k33g.org/p/20261001-llmman).

Here's a summary of my setup for this article:

Of course, you can use other LLM engines instead of **llmman**: **Docker Model Runner**, **Ollama**, or any other server that speaks the OpenAI API will work just fine. More on that at the end of the article.

## [Quick reminder on the 4 building blocks used](#quick-reminder-on-the-4-building-blocks-used)

### [Zed Editor](#zed-editor)

**[Zed](https://zed.dev/)** is a code editor that supports the **ACP** (Agent Client Protocol) protocol. Concretely, that means you can plug any ACP-compatible agent directly into Zed's agent panel, and chat with it just like you would with a built-in agent (for example the Claude Code extension in VSCode).

Documentation: [zed.dev/acp/editor/zed](https://zed.dev/acp/editor/zed)

### [ACP: Agent Client Protocol](#acp-agent-client-protocol)

**[ACP](https://agentclientprotocol.com/get-started/introduction)** is an open protocol (on the same model as LSP, but for agents) that standardizes communication between a **code editor** (the ACP client) and a **code agent** (the ACP server). The agent runs as a separate process, "speaks JSON-RPC" over `stdin`/` stdout`, and since it's a standard, the editor doesn't need to know the "inner workings" of the agent to use it.

Documentation: [agentclientprotocol.com](https://agentclientprotocol.com/get-started/introduction) and [zed.dev/acp](https://zed.dev/acp)

### [Docker Agent](#docker-agent)

**[Docker Agent](https://docker.github.io/docker-agent/)** is a code agent runtime (even multi-agent) configurable via a simple YAML file: you describe your **providers** (how to connect to the model(s)), your **agents** (instructions, model used, allowed tools) and your **models**. It knows how to expose these agents through several interfaces, including... **ACP**. That's exactly what I need to bridge Zed and my local models.

### [llmman](#llmman)

**[llmman](https://llmmanorg.github.io/)** is the tool that serves my local models behind a single API compatible with OpenAI (but also Ollama and Anthropic). It relies on **[llama.cpp](https://github.com/ggml-org/llama.cpp)** as the inference engine and manages models as OCI images (Docker Hub, Hugging Face, private registry...). For this article, it'll be the server that **Docker Agent** queries to get the model's responses.

I talked about it recently over here: [k33g.org/p/20261001-llmman](https://k33g.org/p/20261001-llmman), to explain how to install and use it (a kind of first contact).

## [Setting up all the components](#setting-up-all-the-components)

### [Install Docker Agent (on macOS)](#install-docker-agent-on-macos)

```
brew install docker-agent
```

For other platforms, check the documentation: [docker.github.io/docker-agent](https://docker.github.io/docker-agent/)

### [Start llmman as an LLM server](#start-llmman-as-an-llm-server)

If it's not already done (see [my dedicated article](https://k33g.org/p/20261001-llmman) for the installation):

```
llmman serve
```

Then you download a model (from Hugging Face for example) and check that everything went well:

```
llmman pull huggingface.co/jetbrains/mellum2-12b-a2.5b-instruct-gguf-q4_k_m:Q4_K_M
llmman list
```

### [Configure Docker Agent to talk to llmman](#configure-docker-agent-to-talk-to-llmman)

Here's the configuration file I use, `llmman.docker-agent.yaml`:

```
providers:
  llmman:
    api_type: openai_chatcompletions
    base_url: http://127.0.0.1:17434/v1

agents:

  root:
    model: mellum
    description: A local code agent, powered by a small LLM.
    instruction: |
      Your name is Riker. You are a developer expert.
      You act as a mentor and coding partner. 

      # Tool discipline

      Built-in tools:
      - shell: use the `shell` tool to explore the project, read files, or run commands.
        Chain commands as long as it is useful, then give a clear final answer.

      # Style

      Be concise. Prefer a small, correct, compilable example over prose.

    toolsets:
      - type: shell

models:
  mellum:
    provider: llmman
    model: huggingface.co/jetbrains/mellum2-12b-a2.5b-instruct-gguf-q4_k_m:Q4_K_M
```

The important bit is `base_url: http://127.0.0.1:17434/v1`: that's the address where **llmman** exposes its OpenAI-compatible API. Everything else (agent, instructions, tools) is standard **Docker Agent** configuration.

Now that we have a model and a way to connect to it via an API and Docker Agent, let's make the connection with Zed.

### [Declare the agent in Zed](#declare-the-agent-in-zed)

In Zed's settings (`settings.json`), we add an `agent_servers` section that contains a sub-section pointing to the `docker-agent serve acp` command with the path to our YAML file:

```
"agent_servers": {
  "🤖 Docker Agent (llmman)": {
    "type": "custom",
    "command": "docker-agent",
    "args": [
      "serve",
      "acp",
      "/Users/k33g/kDrive/Rickub/demo-docker-agent-acp/llmman.docker-agent.yaml"
    ],
    "env": {}
  }
}
```

Of course, adapt the path to your own Docker Agent configuration file.

### [Let's go](#lets-go)

Open Zed's agent panel, pick **"🤖 Docker Agent (llmman)"** from the list of available agents, and chat with it like with any code agent: it explores your project, reads files, runs shell commands, all while running entirely locally, on your own model:

The agent asks whether you want to run a command:

## [What if I don't want to use llmman?](#what-if-i-dont-want-to-use-llmman)

Nothing forces you to. The only contract between **Docker Agent** and the model server is an **OpenAI-compatible API**. So in the `providers` file, you can replace `base_url` with any server that exposes this type of API:

- **[Docker Model Runner](https://docs.docker.com/ai/model-runner/)** , which, like**llmman** , relies on`llama.cpp` internally.
- **[Ollama](https://ollama.com/)** — with its OpenAI-compatible API.
- ... or any other runtime that knows how to expose this same kind of endpoint.

## [To sum up](#to-sum-up)

- **Zed** speaks**ACP** to**Docker Agent** .
- **Docker Agent** speaks**OpenAI API** to a model server, here**llmman** , which relies on**llama.cpp** .
- Everything runs locally.

There you go, it's a simple setup to put in place, and it lets you keep full control over your model while enjoying Zed's developer/user experience. Feel free to ask questions 🙂

Written by

Keep reading

### Zed Editor + Docker Agent + ACP, but in a sandbox: running the agent with sbx

Run Docker Agent inside a Docker sandbox (sbx) and connect Zed to it over ACP, keeping llmman local while isolating the agent from your machine.

Oct 4, 2026

### Docker Agent + llama.cpp: a local code agent in 5 minutes 🤖💙🦙

Serve a GGUF model with llama.cpp, point Docker Agent at it with a short agent.yaml, and get a fully local code agent running in minutes.

Sep 15, 2026

### A mini code agent with Docker Agent - Part 8: a local agent to learn Rust

Assemble a local Rust learning companion with Docker Agent: a cookbook RAG, a rust-analyzer LSP toolset, and the context caps that keep a small model alive.

Aug 11, 2026
From other blogs