Xiaomi Releases MiMo Code: A Powerful Open-Source AI Coding Agent

The landscape of software engineering is undergoing a tectonic shift, driven by the emergence of highly autonomous, terminal-native developer tools. On June 15, 2026, Xiaomi’s MiMo AI division officially disrupted this competitive ecosystem by open-sourcing MiMo Code (v0.1.0), a robust, MIT-licensed, terminal-native AI coding agent. Designed to directly challenge closed-source, premium offerings like Anthropic’s Claude Code, MiMo Code is built as a highly optimized, advanced fork of the open-source OpenCode agent framework. By running entirely within the command-line interface (CLI), this tool eliminates context-switching friction by executing raw file modifications, triggering local compilers, and handling complex version control protocols seamlessly—all without requiring developers to manually copy-paste snippets into external IDE windows.

Solving AI Amnesia: The Engineering Behind the Ultimate AI Coding Agent

As any modern developer who practices “vibe coding” will attest, AI coding agents historically degrade over long-horizon tasks. When an AI coding agent runs for dozens or hundreds of execution steps, its context window rapidly fills up. As older decisions, variable definitions, and framework rules get compacted, compressed, or discarded entirely, the agent begins to hallucinate or force developers to repeatedly explain their project’s architecture from scratch.

Xiaomi’s MiMo Code addresses this limitation at the engineering level. The MiMo development team recognized that relying on a single model’s self-awareness to write its own notes is structurally flawed. Instead, MiMo Code decouples the record-keeping task entirely. The main agent is allowed to focus purely on code generation, testing, and execution, while an independent checkpoint sub-agent operates in the background to handle state tracking, indexing, and memory persistence.

This persistent memory system is structured across four distinct tiers:

• Project Memory (MEMORY.md): A persistent, human-readable Markdown file stored in the project’s root directory. The sub-agent continually updates this file with high-level architectural decisions, project conventions, and current goals.
• Session Checkpoints: Snapshots of the codebase taken before major agentic operations, allowing the system to roll back smoothly if a generated block introduces regression.
• Scratch Notes: Ephemeral files used by the sub-agent to draft pseudo-code, trace logic branches, and map imports before writing final code.
• Task Progress (SQLite FTS5): A local SQLite database integrated with the FTS5 full-text search engine. This allows the sub-agent to execute ultra-fast, cross-session keyword queries and semantic lookups over history, ensuring the agent instantly recalls past configuration changes.

Whenever the context window nears its maximum limits, the sub-agent synthesizes a clean, highly structured context summary, allowing the main model to flush older tokens safely and continue writing code indefinitely. According to telemetry collected during internal beta programs involving 576 professional developers, MiMo Code’s win rate on long-horizon tasks exceeding 200 execution steps climbed past 65%, a metric that outpaces conventional, single-context agents.

Framework Architecture: The Power of OpenCode and LLM Agnosticism

Unlike proprietary terminal assistants that lock users into specific cloud-based models or expensive subscription plans, MiMo Code is founded on the principle of LLM agnosticism. Because the tool is built as an open-source fork of the OpenCode framework under the permissive MIT license, developers maintain complete control over where their data goes and how much they spend on API compute.

This architectural choice allows the developer community to treat LLMs as commodities. If a team is working with proprietary IP that cannot leave local hardware, MiMo Code can be configured to run entirely locally using the Ollama framework. Pairing the tool with lightweight, local reasoning models—such as the highly capable Qwen 2.5 Coder series—gives teams a zero-cost, fully offline coding pipeline. For projects requiring high-end cloud reasoning, developers can easily hook the CLI into API endpoints from DeepSeek, GLM, Kimi, or any OpenAI-compatible provider. It even includes features to import Claude Code credentials, providing a drop-in replacement for Anthropic’s CLI while retaining the advanced memory engine.

Unlocking the Multimodal Edge with MiMo-V2.5

To accelerate adoption, Xiaomi is offering a massive incentive: free, registration-free access to its multimodal flagship model, MiMo-V2.5, for a limited time. Sporting a massive 1-million-token context window, MiMo-V2.5 represents a substantial shift in terminal debugging.

Through its native support for multimodal inputs, developers are no longer restricted to text-based compiler outputs. For example, if a developer builds a web application using React and encounters a layout error, they can take a screenshot of the UI and pass it directly into the terminal interface. MiMo Code reads the visual representation of the DOM, cross-references it with the styling files in the workspace, and pinpoints CSS mismatches, alignment issues, or overlapping components in seconds. The integration also bundles 1,000 free daily web search queries, allowing the agent to fetch the latest documentation for rapidly evolving APIs on the fly without running out of context.

Deterministic Workflows: Max Mode, Goal Verification, and Core Modes

To keep the agent aligned with precise software engineering specifications, MiMo Code supports three primary operating modes:

1. Plan Mode: The agent acts purely as an architect. It scans the repository, identifies dependencies, and outlines a step-by-step strategy for the requested feature or bug fix without making actual changes to files.
2. Build Mode: The execution phase where the agent writes code, compiles the project, runs tests, and applies patches directly.
3. Compose Mode: A highly advanced multi-agent orchestrator. It delegates separate development tasks (such as writing database migrations and constructing frontend UI) to different sub-agents, merging them through verified Git workflows.

For critical refactoring or production-grade systems, developers can activate Max Mode. In Max Mode, rather than executing the very first code pathway it generates, MiMo Code samples five execution plans in parallel. It evaluates each plan mathematically, taking into account code complexity, security profiles, and test coverage. Once the optimal path is identified, the agent proceeds. When execution is finished, a secondary, isolated verification model verifies the final state of the environment. It runs the test suites and cross-references the actual output against the original project’s mathematical stopping conditions, preventing false positives and half-finished tasks.

Self-Evolution: Streamlining Workflows with /dream and /distill

MiMo Code introduces features aimed at self-improvement during downtime: /dream and /distill. These commands execute background asynchronous routines designed to reduce technical debt and optimize the agent’s memory:

The /dream command triggers a background refactoring pass. The agent analyzes the user’s active repository, searches for duplicated code blocks or anti-patterns, and attempts to dry up (DRY – Don’t Repeat Yourself) repetitive code sequences. Additionally, /dream prunes redundant conversational history from the SQLite database, consolidating past insights into permanent rules.

Meanwhile, /distill compiles the user’s developer profile. It evaluates past compiler commands, testing tools, build steps, and environment configurations to generate customized, reusable shell scripts and shortcut parameters. Over time, the terminal tool evolves into a highly tailored, deterministic co-pilot that mirrors the developer’s unique workflow patterns.

Installation and Configuration Blueprint

Deploying this open-source AI coding agent is straightforward across platforms. Developers on Unix-like environments can fetch and run the official installer script, while Windows users can utilize the Node package manager.

For macOS and Linux environments, run the following command in your terminal:

curl -fsSL https://mimo.xiaomi.com/install | bash

For Windows environments (requiring Node.js 18+), run:

npm install -g @mimo-ai/cli

Once installed, you can configure the agent by editing your opencode.json configuration file located at ~/.config/opencode/opencode.json on Unix, or in your user profile directory on Windows. A typical configuration to activate MiMo’s multimodal 1M-token engine looks as follows:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "mimo": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "MiMo",
      "options": {
        "baseURL": "https://api.mimo.xiaomi.com/v1",
        "apiKey": "YOUR_MIMO_API_KEY"
      },
      "models": {
        "mimo-v2.5": {
          "name": "mimo-v2.5",
          "limit": {
            "context": 1048576,
            "output": 131072
          },
          "modalities": {
            "input": [ "text", "image" ],
            "output": [ "text" ]
          }
        }
      }
    }
  }
}

The Democratization of Developer Environments

The launch of MiMo Code (v0.1.0) represents a defining moment in the evolutionary timeline of developer tooling. By providing a fully open-source, highly persistent alternative to proprietary platforms, Xiaomi has effectively lowered the barrier to entry for robust, agentic software development. By addressing the core bottleneck of memory degradation through explicit engineering, MiMo Code is no longer just a simple terminal utility—it has set a new benchmark for what a self-evolving, terminal-native programming partner can be.