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.27+ 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) — or any other OpenAI-compatible server or service with provider: openai (the OpenAI API by default, Mistral AI, Cerebras, Hugging Face, vLLM, LM Studio…: mm init asks its endpoint and the variable that holds its API key).

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 — step by step for macOS, Linux and Windows.

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 (or clears the box when nothing runs), F1 lists the keys. With sessions on, ↑ in the box brings back your earlier questions, from this session and the project's previous ones. /shell hands the terminal to your shell; exit brings the conversation back. 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 (with /memory and /docs when you turn them on); @file attaches a file for the model to read; with sessions.enabled: true in the YAML, Reload Agent brings the whole conversation back, and the Agent panel's thread history lists the project's past conversations so you can reopen one (it is not in the / menu).

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

• Create an agent: mm init (or mm --init) asks which server, which model (from the server's list), what the agent is for and which machine runs it, then writes a commented agent.yaml — the model's facts read from the server (window, the GGUF's sampling, the reasoning switch), a family table sourced from model cards and the measured demos, every value with its reason; --check proves the model answers, flags make it scriptable. For an OpenAI-compatible service (openai) it also asks the endpoint and the API key's variable, and lists the service's models when the key is set. See Create an agent with mm init and demos/open-ai-compliant/.
• 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; in the window, ↑ recalls your earlier questions to send them again; in an editor, its thread history lists them (session/list) and reopens one (session/load, session/resume). 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.
• Hooks: your own commands — in any language — run before a question reaches the model, before and after each tool call, after the turn, and around each hand-off to another agent; they can deny a call, stop or rewrite a question, add context, mask what leaves for another agent, replace what comes back, or log. displayHooks: true shows each hook that ran and what it decided, after the answer (an editor shows each one as a tool call). See Guard the agent with hooks, Control the hand-offs to other agents with hooks, demos/hooks/ and demos/hooks-ask/.
• Guard models: have every question checked by guard models (IBM's Granite Guardian), one agent per risk, before your assistant answers — a preGeneration hook asks them without the conversation history, and the assistant refuses or answers according to their verdicts. See Screen questions with guard models, demos/guard/ and demos/guards/.
• Plans: the built-in plan tool lets the agent turn a list of tasks into a tracked plan; mm shows its progress (📋 [2/3] …) after each plan action — per conversation, cleared by /new and /resume. See Manage plans and tasks.
• Save an answer: /save writes the last answer to a Markdown file; with saveAnswerTool: true, the model does it itself when you ask in your own words (save_answer). Never overwrites a file. See Save an answer to a file.
• Unload a model: /unload [model] frees a model from the server's memory — in the terminal, the window and an editor —, and the unload_model tool lets the agent do it itself, e.g. on another agent's model once it has answered; llmman, Ollama and llama-server in router mode. unloadModels: false turns both off. See Free a model's memory and demos/unload-models/.
• Search a documentation folder: /docs <words> searches the text files of the folders named in docSearch.dirs (.md, .adoc, .txt… — only the extensions listed) and returns the best passages with their path:line link, ranked with BM25 — no index, no model (docSearch.searchDocs); the search_docs tool lets the model do it before it answers (docSearch.autoSearchDocs); both off by default. See Search a documentation folder and demos/docs-search/.
• Search earlier sessions: with sessions on, /memory <words> searches the project's stored conversations (sessions.searchMemory), and the search_memory tool lets the model do it when a question refers to something decided before (sessions.autoSearchMemory); both off by default. The search matches words, not meanings. See Search earlier sessions and demos/memory-search/.
• Decision models: small models that answer questions about a text — a choice, a yes/no, a score — in a fraction of a second, through /v1/systemone (llama-server, llmman, Ollama). An agent file with a decision: block is a decider: run it with mm -p from a script or a hook, let it pick the skill before each question (skillRouting), drop the tool groups a request does not need (toolRouting), or approve read-only commands from a preToolCall hook (allow). See Ask a decision model, Decision models and the demos/decision-* folders.
• Type while it answers: a message sent during a turn is queued and runs once the turn ends, in order — in the line mode and the window; Esc (window) or /abort stops the turn. See the slash commands reference.
• Struggle signals: when the model loops, fails several tool calls in a row, breaks a tool call, stalls, runs out of turns or fills its context window, mm says so apart from the answer — a coloured badge in the window's footer, a line in the terminal, a paragraph in an editor. The window also shows the completion's duration (showCompletionTime). See Struggling models and demos/struggle-signals/.
• Download the models at start-up: autoPull: true pulls the models the agent will use that the server does not have yet — its own, its mmConfigs agents', its routing deciders' — with the progress on screen (llmman, Ollama, Docker Model Runner; llama.cpp gets advice instead). See Run mini-me with llmman and demos/auto-pull/.
• Models that take turns in memory: unloadModels: true on an mmConfigs entry unloads the asking agent's model before the hand-off and the asked agent's model after it, so two models are never loaded together. See Free a model's memory and demos/coding-helpers-unload-option/.
• Use mini-me from another program: drive mm -acp over ACP — demo.acp.sdk/nodejs/minime.js gives Node.js complete, stream, cancellation and a permission callback, with no dependency. See demo.acp.sdk/.
• Test a model: testing/ holds two benches run by mm itself — a coordinator agent gives small tasks to a candidate agent whose model is under test, checks each result with a command, and writes a Markdown report: the model as a working agent (testing/model-check/) and function calling alone, with tools declared in the agent file (testing/function-calling/). See testing/.
• 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.
• Release notes — what changed in each version, in English and French.
• guides/ — practical guides:
  • the agent settings for small models, in English and French: timeouts, maxTurns, maxOutput, agentsMd.maxChars, context compression, sampling — what each one does, its default, and how to set it for a small local model;
  • the keyboard shortcuts of the window (mm -tui), in English and French: typing, sending, stopping a turn, recalling questions, the pickers, pastes, permissions, the agent's questions, copy and mouse.
• 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.