MiniMax-M2 Series: Sparse, Agentic LLM

• MiniMax-M2 series is a family of Mixture-of-Experts language models using a mini-activation scheme to efficiently enable long-context, agentic deployment.
• It integrates executable-grounded data pipelines with verifiable workspaces, such as Docker and real browsers, to generate reliable agent trajectories.
• The series employs Forge, an agent-native reinforcement learning system with self-evolution capabilities that optimizes throughput under real-world cost and latency constraints.

The MiniMax-M2 series is a family of Mixture-of-Experts LLMs organized around the claim that “mini activations can unleash maximum real-world intelligence” (MiniMax et al., 26 May 2026). In the reported formulation, the series is designed end-to-end for agentic deployment and is defined by the interaction of three components: agent-driven data pipelines that generate large-scale, verifiable trajectories in executable workspaces; Forge, a scalable agent-native reinforcement learning system for long-horizon agent trajectories; and, in the latest M2.7 checkpoint, an early self-evolution capability in which the model autonomously debugs training runs and modifies its own scaffold (MiniMax et al., 26 May 2026). Across M2 through M2.7, the series is presented as translating a small per-token activation footprint into frontier-tier performance on agentic coding, deep search, office-task, and reasoning benchmarks.

1. Architectural configuration and mini-activation scheme

MiniMax-M2 is a decoder-only Transformer with 62 layers, hidden size 3 072, a 192 K native context window, and 229.9 B total parameters (MiniMax et al., 26 May 2026). Its sparsity is implemented through a Mixture-of-Experts (MoE) backbone in which each feed-forward block contains 256 fine-grained experts, but only 8 are activated per token. For a token representation $h$, per-expert gating scores are computed as

$$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$

where $\sigma$ is the sigmoid function and $b_i$ is a learnable expert bias for load balancing. The top-$K$ experts, with $K=8$, are selected by $g_i$, and only those experts process $h$ (MiniMax et al., 26 May 2026).

The defining quantitative property of the series is the gap between total and active parameters. Although the model has 229.9 B parameters, each token activates approximately $9.8$ B of them, yielding an activation ratio

$$r \;=\;\frac{9.8\times10^9}{229.9\times10^9}\approx0.0426\quad(\approx4.3\%).$$

The paper associates this with a substantial reduction in per-token compute while retaining the capacity of a much larger parameter budget (MiniMax et al., 26 May 2026).

Each block also includes a small Multi-Token Prediction (MTP) head trained to predict $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$0 future tokens jointly. At inference time, this head provides speculative candidates that the main model verifies in a single pass, with the stated purpose of increasing throughput (MiniMax et al., 26 May 2026). In the release progression, M2.5 expands MTP to $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$1 (MiniMax et al., 26 May 2026).

This architecture places the series within the broader MoE design space, but the paper’s emphasis is not only on conditional computation. It explicitly ties the sparse activation pattern to long-context, tool-enabled, agentic execution. A plausible implication is that the architectural objective is not merely parameter efficiency in the abstract, but stable deployment under real latency and cost constraints in 192 K-token episodes.

2. Executable-grounded data pipelines

The first major component of the series is an agent-driven data pipeline in which every trajectory is grounded in an executable workspace and judged by an artifact-aligned reward (MiniMax et al., 26 May 2026). The paper gives Docker sandboxes for code tasks and real browsers for web browsing as examples of such workspaces.

For software engineering, the paper describes a six-stage SWE pipeline. It begins by crawling and filtering real GitHub PRs, including description, diff, and tests. It then constructs agent-synthesized Docker environments via iterative build-and-test loops, tags PRs by task type such as bug fix, feature, and optimization, defines test-based verifiable rewards through Fail-to-Pass, Pass-to-Pass, and new-feature tests, applies model-based consistency checks between description and tests, and finally adds task augmentations including bug injection, commit merging, test-writing, and code-review tasks (MiniMax et al., 26 May 2026).

The AppDev pipeline is described as a “build-from-scratch” task generator using expert-in-the-loop meta-queries. Verification is handled by an Agent-as-a-Verifier (AaaV), which deploys the app, interacts with it via Playwright, and scores execution, interaction, and visual aesthetics (MiniMax et al., 26 May 2026). Terminal-Gym extends the same executable-grounding principle to terminal tasks by transforming StackOverflow threads into verifiable tasks through synthesized Dockerfiles, tests, iterative repair, query evolution, and difficulty calibration (MiniMax et al., 26 May 2026).

For agentic cowork domains, including deep search, office tasks, spreadsheets, and slide decks, each domain is paired with its own runnable workspace, scaffold perturbations, and artifact-aligned rubrics or pairwise comparisons, and only ground-truth–verified trajectories are accepted (MiniMax et al., 26 May 2026). The reported pipeline therefore treats data generation not as static corpus collection but as a verification-centered process in which reward assignment is anchored to executable outcomes.

This suggests a methodological distinction from training regimes that rely primarily on static instruction-response pairs. Here, the trajectory is meaningful because it can be executed, inspected, and scored against an artifact. A plausible implication is that the series is optimized for settings where correctness is externally testable rather than only preference-labeled.

3. Forge: agent-native reinforcement learning infrastructure

The second major component is Forge, a scalable agent-native RL system that is explicitly formulated as an MDP in which the LLM $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$2 is the policy and everything else, including context management, tools, and external code, is the environment (MiniMax et al., 26 May 2026). This decomposition places the LLM inside a broader action-observation loop rather than treating tool use as a purely prompting-level phenomenon.

Forge uses the CISPO objective, or Clipped Importance Sampling Policy Optimization:

$$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$3

with asymmetric clipping of the importance ratio $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$4 (MiniMax et al., 26 May 2026). The paper also states that training is mixed-domain: reasoning, coding, agentic, and general-conversation tasks are interleaved at every step to avoid catastrophic forgetting (MiniMax et al., 26 May 2026).

A substantial fraction of the reported system contribution lies in infrastructure. Windowed-FIFO scheduling restricts training-batch admission to completed trajectories inside the head window of a generation queue, balancing strict FIFO for distributional consistency against greedy scheduling for throughput (MiniMax et al., 26 May 2026). Prefix-tree merging exploits shared prefixes in long-context multi-turn trajectories so that the shared prefix is computed once for a tree of completions, delivering up to $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$5 speedups with zero approximation error (MiniMax et al., 26 May 2026). Inference optimizations include co-trained MTP speculative decoding, disaggregated prefill/decode for MoE, and a global L3 KV cache pool with cost-aware routing (MiniMax et al., 26 May 2026).

Forge is further described as a decoupled architecture. The Agent Side, which may be white-box or black-box, produces $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$6 tuples. A Middleware layer, consisting of a Gateway Server and Data Pool, connects agents to the LLM engine. The Training/Inference Side then runs rollouts and policy updates independently (MiniMax et al., 26 May 2026). This clean training-inference-agent decoupling is presented as a mechanism for supporting arbitrary agent harnesses while preserving scalable rollout and optimization.

The technical significance of Forge, within the paper’s framing, is that long-horizon agent trajectories are treated as first-class RL objects. Rather than adding RL on top of a generic language-model stack, the system is built around multi-turn, tool-mediated interaction traces whose structure is already reflected in scheduling, batching, caching, and rollout semantics.

4. Checkpoint progression and self-evolution

Across M2, M2.5, and M2.7, the core MoE backbone remains fixed at 229.9 B total parameters with 9.8 B activated per token, while the post-training pipelines and RL stages co-evolve (MiniMax et al., 26 May 2026). The base M2 checkpoint is described as pre-trained on 29.2 T tokens, with full attention, fine-grained MoE, and initial MTP. M2.5 adds the SWE and AppDev pipelines, expands MTP to $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$7, and introduces the first mixed-domain RL curricula. M2.7 incorporates Terminal-Gym and advanced cowork domains, refines Forge scheduling, and enables self-evolution (MiniMax et al., 26 May 2026).

The self-evolution component is the defining addition in M2.7. The paper states that M2.7 inaugurates a Model Iteration System in which the model diagnoses failed runs, debugs its agent scaffold code, tweaks configurations, and re-runs experiments (MiniMax et al., 26 May 2026). This occurs in a dual-loop workflow: human researchers define high-level goals and review major steps, while the model executes autonomous debugging loops that absorb 30–50% of daily iteration effort (MiniMax et al., 26 May 2026).

A specific reported instance is an on-the-fly 100-round autonomous scaffold optimization, including loop detection and parameter tuning, which delivered a 30% in-house performance gain (MiniMax et al., 26 May 2026). The paper interprets this as evidence that M2.7 can improve the infrastructure that shapes its next iteration.

This suggests that the series is moving from a static model family toward an iterative agent-model system in which the model participates in the refinement of its own experimental harness. A plausible implication is that the boundary between model optimization and agent engineering becomes less rigid in later checkpoints.

5. Benchmark profile and reported results

The paper reports benchmark results for MiniMax-M2.7 against M2.5 and “the strongest closed-weight frontier baselines,” listed as Claude Opus 4.6, Sonnet 4.6, GPT 5.4, and Gemini 3.1 Pro (MiniMax et al., 26 May 2026). The reported benchmark domains are agentic coding, deep search and browsing, office-tool and cowork, and reasoning and knowledge.

In agentic coding, the reported scores for M2.7 are 56.2 on SWE-bench Pro, 76.5 on SWE-bench Multilingual, 52.7 on Multi-SWE-bench, 57.0 on Terminal-Bench 2.0, and 66.6 medal rate on MLE Bench Lite (MiniMax et al., 26 May 2026). In deep search and browsing, M2.7 is reported at 77.8 on BrowseComp, 75.2 on Wide Search, and 64.3 on RISE (internal). In office-tool and cowork, the reported scores are 50.0 on GDPval-AA, 46.3 on Toolathlon, 62.7 on MM Claw, 63.3 on MEWC v2 (Excel), and 57.0 on Finance Modeling Pro. In reasoning and knowledge, the reported scores are 94.2 on AIME 2026, 89.8 on GPQA-Diamond, 76.0 on IFBench, 72.0 on AA-LCR, and 81.8 on MMLU-Pro (MiniMax et al., 26 May 2026).

The paper also reports monotonic improvement across all eleven shared benchmarks from M2 to M2.5 to M2.7, with the steepest gains in newly supported domains: deep search gains of $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$8 on BrowseComp, $$g_i = \sigma\bigl(w_i^\top h + b_i\bigr)\quad (i=1,\dots,256),$$9 on Toolathlon, and $\sigma$0 on MLE Bench (MiniMax et al., 26 May 2026). It further states that each release yields steady gains on every benchmark, with the largest jumps where new task families were introduced, citing deep search, tool use, and MLE engineering (MiniMax et al., 26 May 2026).

These reported results are central to the paper’s argument that the gain is not attributed to architecture alone. The progression is explicitly tied to the co-evolution of data pipelines, RL curricula, scheduling, and self-evolution. A plausible interpretation is that the benchmark profile is being used to support a systems-level thesis: sparse activation becomes competitively useful when paired with executable-grounded supervision and agent-native optimization.

6. Deployment orientation, trade-offs, and interpretation

The paper frames “mini activations for real-world throughput” as a design principle (MiniMax et al., 26 May 2026). By activating only approximately $\sigma$1 of parameters per token, the model is said to achieve frontier capacity at a fraction of compute cost and latency. Combined with MTP speculative decoding, prefix merging, and KV caching, the system is reported to sustain high token-per-second throughput even in 192 K-token episodes (MiniMax et al., 26 May 2026).

The reported deployment scope is explicitly agentic. The series has been deployed end-to-end in production-grade code repair and full-stack app development pipelines; in multi-step web research agents interfacing via real browsers; in office-automation cowork bots authoring reports, spreadsheets, and slide decks under executable scaffolds; and in autonomous ML engineers iterating on model training, with MLE Bench Lite cited as a case study (MiniMax et al., 26 May 2026).

The trade-off emphasized in the paper is a compute-versus-performance Pareto enabled by MoE sparsity. At approximately 10 B active weights, M2.7 is described as matching or outperforming dense models in real-world agentic tasks, making it practical to host large-context, tool-enabled agents under tight latency and cost budgets (MiniMax et al., 26 May 2026). Within the paper’s own framing, this is the operational meaning of the series title and subtitle.

A likely misconception is to treat the series as merely an MoE scaling result. The text instead assigns equal weight to three elements: sparse architecture, executable-grounded agent data, and Forge-based RL, with self-evolution added in M2.7 (MiniMax et al., 26 May 2026). Another possible misconception is to reduce the contribution to benchmark chasing. The paper’s recurring emphasis on executable workspaces, artifact-aligned reward, white-box and black-box agent support, and deployment pipelines suggests that the intended object is an integrated agent system rather than an isolated LLM.

Taken on its own terms, the MiniMax-M2 series is best understood as a sparse, long-context, agent-oriented LLM family whose defining claim is that a small activation footprint can be leveraged into high real-world capability when paired with verifiable trajectory generation, agent-native RL infrastructure, and model-assisted iteration of the surrounding scaffold (MiniMax et al., 26 May 2026).