MiMo Code: Where Models and Agents Co-Evolve

中文 | English

Website | Blog

MiMoCode is a terminal-native AI coding assistant. It can read and write code, run commands, manage Git, and use a persistent memory system to keep a deep understanding of your project across sessions while continuously improving itself.

MiMo Auto is built in as a free-for-limited-time channel, so you can start with zero configuration. MiMoCode also supports connecting to any mainstream LLM provider API.

# One-line install (macOS / Linux)
curl -fsSL https://mimo.xiaomi.com/install | bash

# One-line install (Windows PowerShell)
powershell -ep Bypass -c "irm https://mimo.xiaomi.com/install.ps1 | iex"

# Or install via npm (all platforms)
npm install -g @mimo-ai/cli

# Run
mimo

The first launch guides you through configuration automatically. Supported options:

• MiMo Auto (free for a limited time) — anonymous channel, zero configuration
• Xiaomi MiMo Platform — OAuth login
• Codex (ChatGPT Pro/Plus) — OpenAI OAuth login
• Import from Claude Code — migrate existing authentication in one step
• Provider list — connect catalog providers by API key, or OAuth where supported (e.g. xAI/Grok)
• Custom Provider — add any OpenAI-compatible API in the TUI

sudo apt install xsel

Beyond MiMoCode, Xiaomi MiMo models also work in other agents and coding tools like Cursor, Cline, and Zed.

awesome-mimo-agent collects setup guides for using MiMo in those tools — worth a look if you want to try MiMo elsewhere. Contributions welcome: open a PR to add your own setup.

Press Tab to switch between primary agents. Subagents are created by the system as needed. After the first message the mode locks: Build and Plan can still switch between each other, but Compose is isolated once entered — keeping the skill/tool set fixed from session start significantly improves tool-call reliability.

For frontier models (Fable/Sol-class), the recommended way to run compose-style work is the build agent with the /compose-next skill — see Compose Mode.

Cross-session memory powered by SQLite FTS5 full-text search:

• Project memory (MEMORY.md) — persistent project knowledge, rules, and architecture decisions
• Session checkpoint (checkpoint.md) — structured state snapshots maintained automatically by the checkpoint-writer subagent
• Scratch notes (notes.md) — temporary note area for agents
• Task progress (tasks/<id>/progress.md) — per-task logs

Memory is injected automatically when a session resumes, so the agent does not need to relearn project context.

• Automatic checkpoints — decides when to save session state based on the model context window
• Context reconstruction — when context approaches the limit, rebuilds it from the latest checkpoint, project memory, task progress, and retained recent messages so the agent can continue the current task
• Budgeted injection — uses a token budget to control how much checkpoint, memory, and notes content enters context, with importance ranking
• Adjustable compaction point — /context-limit (or compaction.max_context) makes a model compact earlier than its own window, per model

{
  "compaction": {
    "max_context": {
      "openai/gpt-5.6": "272K", // token count, "300K", "1M", or "50%" of the window
      "anthropic/*": "300K" // wildcards allowed, longest pattern wins
    }
  }
}

A tree-shaped task system (T1, T1.1, T1.2, …) that integrates automatically with the checkpoint system, so task progress is preserved when sessions resume.

The primary agent can create subagents on demand. Subagents share the current session context and can work in parallel, with lifecycle tracking, cancellation, and background execution.

The /goal command sets a stopping condition for a session. When the agent tries to stop, an independent judge model evaluates the conversation to decide whether the condition is truly satisfied — preventing premature "optimistic stops" during autonomous work.

Compose is MiMoCode's structured workflow for specs-driven development, orchestrating the full lifecycle from spec to shipped code.

The recommended way to use it is the /compose-next skill on the build agent: a single self-contained contract covering grill → spec → workspace → implement → verify → review → finalize → finish, with feature documents at docs/compose/spec/<feature>.md. It is designed for frontier models (Fable/Sol-class), which internalize most of the workflow and work best from one compact contract.

The legacy path is the dedicated compose agent (switch with Tab), which orchestrates fourteen built-in skills for planning, execution, code review, TDD, debugging, verification, and merging — a step-by-step curriculum that remains useful for weaker models.

Workflows are deterministic JavaScript scripts that orchestrate multiple agents in a sandboxed runtime. Unlike agent conversations, workflows encode fixed phase sequences with bounded retries and automatic parallelization — fire-and-forget execution with no user interaction required.

MiMoCode ships with four built-in workflows:

The compose workflow complements the interactive path: use the workflow when requirements are clear and tasks split cleanly (deterministic, parallel, non-interactive); use the build agent with /compose-next (or the legacy compose agent) when you need to redirect mid-flow or inject judgment between steps (conversational, interactive).

Custom workflows: Place a .js file in .mimocode/workflows/ or .claude/workflows/ to define your own, or override a built-in by using the same name (e.g. .mimocode/workflows/compose.js).

Skills are reusable instruction sets that teach agents how to handle specific tasks (e.g. generating PDFs, writing academic papers, searching arXiv). For a new task, MiMoCode searches available non-Compose skills by exact name, localized alias, and BM25 relevance. High-confidence matches are loaded automatically; uncertain matches are ranked for the agent to assess. In the TUI, type / to browse the autocomplete list or invoke a skill directly with /<skill-name> — mentioning two or more skills in a single message auto-loads them and injects a multi-skill orchestration plan.

MiMoCode bundles the following builtin skills:

claude-code and codex are exposed only when the claude and codex executables, respectively, are installed. Other skills may still require task-specific tools described in their instructions.

Overriding a builtin skill: Create a skill with the same name in your project (.mimocode/skills/<name>/SKILL.md) or personal skill directory (~/.claude/skills/, ~/.opencode/skills/, etc.). User skills discovered later in the scan order override builtins with the same name.

Real-time streaming voice input powered by TenVAD and MiMo ASR. Activate with /voice, then speak — audio is segmented by pauses and transcribed incrementally into the input. Available for MiMo logged-in users. Requires sox (brew install sox on macOS, other platforms similar).

sudo apt install -y sox pulseaudio libasound2-plugins
export PULSE_SERVER=unix:/mnt/wslg/PulseServer

# Mac (local)
brew install pulseaudio
pulseaudio --load="module-native-protocol-tcp auth-ip-acl=127.0.0.1" --exit-idle-time=-1 --daemonize
# Add to ~/.ssh/config: RemoteForward 4713 127.0.0.1:4713

# Remote host
apt install -y pulseaudio pulseaudio-utils sox
export PULSE_SERVER=tcp:127.0.0.1:4713
# Verify: pactl info

{
  "voice": {
    "control_model": "openrouter/xiaomi/mimo-v2.5"
  }
}

{
  "provider": {
    "internal": {
      "options": {
        "baseURL": "https://your-api-gateway.example.com/v1",
        "apiKey": "sk-..."
      },
      "models": {
        "xiaomi/mimo-v2.5-asr": { "name": "MiMo-V2.5-ASR" },
        "xiaomi/mimo-v2.5": { "name": "MiMo-V2.5" }
      }
    }
  },
  "voice": {
    "asr_model": "internal/xiaomi/mimo-v2.5-asr",
    "control_model": "internal/xiaomi/mimo-v2.5"
  }
}

• /dream — scans recent session traces, extracts persistent knowledge into project memory, and removes outdated entries
• /distill — discovers repeated manual workflows in recent work and packages high-confidence candidates into reusable skills, subagents, or commands

MiMoCode uses JSON/JSONC config files with published JSON Schemas for autocompletion and validation.

On Windows, XDG paths fall under %LOCALAPPDATA%\mimocode\. You can override all paths with MIMOCODE_HOME.

MiMoCode auto-injects a $schema field when it first loads your config, so your editor gets completions and validation out of the box:

{
  "json.schemaDownload.trustedDomains": {
    "https://mimo.xiaomi.com/": true
  }
}

If your provider is not in the built-in model catalog, configure it directly with its base URL, API key, and model ID:

{
  "$schema": "https://mimo.xiaomi.com/mimocode/config.json",
  "model": "custom/MODEL_NAME",
  "provider": {
    "custom": {
      "name": "Custom",
      "npm": "@ai-sdk/openai-compatible",
      "only_configured_models": true,
      "models": {
        "MODEL_NAME": {
          "name": "MODEL_NAME"
        }
      },
      "options": {
        "baseURL": "BASE_URL",
        "apiKey": "API_KEY"
      }
    }
  }
}

• Use the exact keys baseURL and apiKey.
• Preserve the base URL and model ID exactly as supplied. MiMoCode does not require a known provider and you should not add or remove /v1 unless the endpoint requires it.
• The key under models is the upstream model ID. Model IDs containing / are supported because only the first / in model separates the provider ID from the model ID.
• Replace custom with another unused lowercase provider ID if needed, and use the same ID in the top-level model value.
• @ai-sdk/openai-compatible is for OpenAI-compatible APIs. Services using a different wire protocol require their provider-specific adapter.

Put user-wide settings in ~/.config/mimocode/mimocode.jsonc (or mimocode.json in the same directory), or project-only settings in .mimocode/mimocode.jsonc (or .json), and merge them with any existing configuration. Because apiKey is stored as plaintext, keep the file readable only by your user and never commit it. Run mimo models or use the TUI model picker to verify the configured model.

To declare which input modalities a custom model supports (image, audio, video, PDF), run /modalities in the TUI — a multi-select dialog that persists the setting to config without hand-editing.

• Provider and model selection
• Agent permissions and custom agents
• Checkpoint and memory behavior
• MCP server connections
• Keybindings and theme

Max Mode (parallel best-of-N reasoning with judge selection) can be enabled via experimental.maxMode in the config.

{
  "$schema": "https://mimo.xiaomi.com/mimocode/config.json",
  "permission": {
    "external_directory": {
      "/tmp/**": "allow"
    }
  }
}

# TUI — prompts once for an explicit confirmation on startup
mimo --dangerously-skip-permissions

# Headless
mimo run --dangerously-skip-permissions "your prompt"

# Or via environment variable (any surface)
MIMOCODE_DANGEROUSLY_SKIP_PERMISSIONS=1 mimo

bun ci                   # Install dependencies (= bun install --frozen-lockfile)
bun run dev              # Run in development mode
bun turbo typecheck      # Type check

MiMoCode is built as a fork of OpenCode. It keeps all core OpenCode capabilities (multiple providers, TUI, LSP, MCP, plugins) and adds persistent memory, intelligent context management, subagent orchestration, goal-driven autonomous loops, compose workflows, and self-improvement via dream/distill.

Scan the QR code to join the community group chat:

Source code is licensed under the MIT License.

Use of MiMoCode is also subject to the Use Restrictions. Use of Xiaomi MiMo-hosted services is subject to the MiMo Terms of Service. Use of the MiMo name, logo, and trademarks is subject to the MiMo Trademark Policy.