Mini Me

No, no. We don't gnaw on our kitty.

Mini Me (mm) is a minimalist coding agent for local LLMs, written in Go, that runs in your terminal or inside an editor such as Zed.

What is mini-me?

Mini Me started as the preparation of a Tools-in-Action talk for Devoxx Belgium 2026, where I explain how an agent loop works with a single tool: bash. The model asks for a command, the agent runs it, the output goes back to the model, and so on until the model answers.

From there it grew into the coding agent I wanted for local models (Docker Model Runner, llama.cpp, llmman, Ollama): small enough to be read in an afternoon, and careful about what a small model does wrong:

• hallucinations — the agent shows the real output of every command before the model comments on it, and the prompt forbids stating anything a command did not return;
• silent failures — a failing command, a refused edit or a rejected permission goes back to the model as text, so it reads why and tries something else;
• endless loops — the same action with the same result, repeated, is detected and the model is told to change approach; if it keeps repeating anyway, the turn is stopped and the error is recorded in the session; a watchdog catches a connection that went silent.

What makes Mini Me a bit special is that it was designed from the start to be used from an editor through the Agent Client Protocol (ACP): the same loop runs in a terminal REPL, in a full-screen terminal window, and inside Zed.

Install

You need Go 1.26+ and a model server that can emit tool calls, through its OpenAI-compatible API: Docker Model Runner (provider: dmr, the default), llama.cpp's llama-server (llamacpp), llmman (llmman) or Ollama (ollama).

git clone https://git.rickub.com/bots-garden/mini-me.git
cd mini-me
./install.sh          # go build, then copies mm to /usr/local/bin
mm -h                 # the flags
mm --version          # which mm this is
mm --about            # what it is, in one screen

install.sh works only on macOS and Linux

Or download a binary from the releases page and put it on your PATH.

Then pick a configuration file. Copy one to agent.yaml in your project and adjust the model: and system: keys to taste:

For Ollama, see Run mini-me on Ollama and demos/ollama/.

Use

The base command is mm. Run it from the directory of the project you want to work on: that is where commands run and where files are read and written.

1. Terminal, line by line

mm                    # reads ./agent.yaml
mm agent.dmr.yaml     # or name the file

Type a question at the > prompt. Each command the model runs is shown with its output, and every turn ends with a recap (⚙ 2 command(s)). Useful commands: /help, /new, /compact, /quit.

2. Terminal, one window

mm -tui

The conversation above, a box to type in below. Enter sends, Ctrl-J adds a line, Esc cancels a turn, F1 lists the keys. With yolo: false in the YAML, the agent asks before running a command or writing a file — in the window, the line mode and an editor alike (yolo: true, the default, runs them unasked).

3. Inside an editor (ACP)

mm -acp

Speaks the Agent Client Protocol on stdin/stdout. You never run this one by hand: the editor launches it. See the next section.

Use with the Zed editor

1. Install mm on your PATH (see above).

2. In Zed, open settings.json and register the agent:

   {
     "agent_servers": {
       "mini-me": {
         "type": "custom",
         "command": "mm",
         "args": ["-acp"],
         "env": { "AGENT_CONFIG": "/absolute/path/to/agent.yaml" }
       }
     }
   }   
   

   AGENT_CONFIG must be an absolute path: Zed starts mm in the project directory, and a relative path would not be found. "type": "custom" is required.

3. Open the Agent panel, pick mini-me, and talk to it. Every bash, read_file, write_file and edit_file call shows up as a tool call, and file changes appear as real diffs. With yolo: false in the YAML, Zed asks you to allow each call before it runs; the shipped files say yolo: true, and the calls run unasked.

4. Handy things: Escape cancels a turn; /new and /compact are in the slash-command menu; @file attaches a file for the model to read; with sessions.enabled: true in the YAML, Reload Agent brings the whole conversation back.

5. When something looks wrong, open dev: open acp logs: the banner, warnings and the agent's [acp] … trail go there.

Other ACP editors

Anything that speaks ACP can host mm -acp the same way: JetBrains IDEs (IntelliJ IDEA, PyCharm, WebStorm…), Neovim (CodeCompanion, agentic.nvim, avante.nvim), Emacs (agent-shell), Visual Studio Code through third-party ACP extensions, Sublime Text and Qt Creator through their ACP plugins. The registration details differ; the agent side does not.

More features

• One prompt and exit: mm -p "…" — for scripts. See Run a single prompt.
• Other agents: list other mm agents under mmConfigs; you ask them with /ask-<name>, your agent calls them itself with its ask_agent tool, a script with mm --ask <name>. See Let your agent call other agents.
• Questions to you: the agent asks with its ask_user tool — pick one, pick several, type a text, yes or no — as numbered choices in the terminal, an arrow-key box in the window, a form or a dialog in an editor; a called agent's questions come up to you too. askUserTool: false turns it off. See Let the agent ask you questions.
• An agent that creates agents: ./mm -config agent.creator.yaml (Qwen3.8 27B), then "Create an agent that … with ". It reads the model's facts from llmman (skills/create-agent/model_facts.py: chat template, reasoning switches, tool-call format, sampling, context), asks what it is missing, writes a commented agent.yaml tuned to that model and checks that it loads and answers — the create-agent skill.
• Project instructions: an AGENTS.md in the project directory is added to the system prompt of every conversation. See Give the agent your project's instructions.
• Answers as JSON: declare the shape of the answer as Go types under structuredOutput, and mm -p "…" | jq works. See Get answers as JSON.
• MCP servers: their tools, wrapped as mm tools. See the MCP tutorial.
• Sessions: with sessions.enabled: true, /sessions lists the conversations of a project and /resume continues one. See Keep sessions and resume them.
• Trace: AGENT_TRACE=true mm … writes every request to the model and every response to .mm/traces/. See See the JSON sent to the model.
• Docker Sandboxes: the sandbox kit lives in its own repository, mini-me-kit; sbx/ explains how to use it (sbx run …), with two mixins (go-toolchain, cli-tools) and ready-made configurations — see sbx/README.md and Run mini-me in a Docker Sandbox.

Demos

The demos/ directory holds ready-made set-ups (most with a README explaining how to run them):

Learn more

• Documentation — tutorials, how-to guides, reference and explanations, in English and French.
• The skills/ directory: Markdown procedures the agent can load with its read_skill tool.
• agent.lsp.yaml: the same agent with a language server behind an lsp tool (definition, references, hover, symbols, diagnostics, rename) — see Navigate and refactor code with a language server.
• fetchContentTool: true in agent.dmr.yaml: the built-in fetch_content tool, which fetches a web page as Markdown (honouring its robots.txt) and can save it to a file without showing it — see Fetch a web page as Markdown.

License

MIT — see LICENSE.