Reading notes on:

The evolution of LLMs is rapidly shifting from single-turn chatbots to long-horizon agentic systems capable of executing complex workflows. To address the dual bottlenecks of ultra-long context computational efficiency and high-stakes real-world reliability, the newly released MiniMax-M2 series (culminating in M2.7) proposes a compelling architectural and training philosophy: mini activations can unleash maximum real-world intelligence.

Below covers the architecture, the mathematics of their agent-native RL system, and the infrastructural breakthroughs that allow M2.7 to rival closed-weight frontier models.

1. Base Architecture: Fine-Grained MoE & Attention Dynamics

The flagship M2 is a 62-layer decoder-only Transformer boasting 229.9B total parameters, but it activates only 9.8B parameters per token. Pre-trained on 29.2T tokens, it supports a native context window of 192K.

Key Architectural Insights:

  • Sigmoid-Gated, Fine-Grained MoE: Instead of standard softmax routing, M2 uses 256 fine-grained experts (activating 8 per token) with sigmoid gating. Softmax imposes a zero-sum constraint; sigmoid allows multiple experts to activate simultaneously with high confidence, smoothing routing dynamics. Furthermore, M2 introduces learnable expert-specific bias terms to implicitly regulate utilization, drastically reducing the model’s reliance on auxiliary load-balancing losses.
  • Full Attention over Hybrid: The authors heavily experimented with hybrid Sliding Window Attention (SWA) to reduce memory costs. However, their extensive testing revealed that SWA significantly degrades performance on retrieval, multi-hop reasoning, and long-context agentic tasks exceeding 32K tokens. Consequently, M2 relies purely on full multi-head attention with Grouped-Query Attention (GQA).
  • Multi-Token Prediction (MTP): To enrich training signals and accelerate inference via speculative decoding, M2 predicts the next $K$ tokens jointly. M2 is initially trained with $K=1$, but expands to $K=3$ during continued pre-training. Insight: To prevent catastrophic loss spikes during expansion, the authors initialize the new MTP modules using weight copying from the main model, ensuring faster convergence and stable representations.

2. Reinforcement Learning: The Forge System & CISPO

A standout contribution of M2 is its agent-native reinforcement learning framework, “Forge,” designed to seamlessly handle long-horizon trajectories.

MDP Formulation for Agents: M2 elegantly draws the environment boundary at the LLM’s generation interface. The policy $\pi_\theta(a_t \mid s_t)$ outputs actions (reasoning, tool calls, or context management), and the environment executes these, returning an observation $o_t$ to form the next state via a transition function $s_{t+1} = f_{\text{trans}}(s_t, a_t, o_t)$. This abstracts the complexity of tools and multi-agent coordination entirely away from the policy optimization.

The CISPO Algorithm: M2 adapts Clipped Importance Sampling Policy Optimization (CISPO) with a unique mathematical formulation optimized for long agent trajectories. The objective function is:

\[J_{\text{CISPO}}(\theta) = \mathbb{E}_{(q,a)\sim D,\, \{o_i\}_{i=1}^G \sim \pi_{\theta_{\text{old}}}} \left[ \frac{1}{\sum_{i=1}^G |o_i|} \sum_{i=1}^G \sum_{t=1}^{|o_i|} \text{sg}\!\left(\hat{r}_{i,t}(\theta)\right) A_{i,t} \log \pi_\theta(o_{i,t} \mid q, o_{i,<t}) \right]\]

Here, $\text{sg}(\cdot)$ is a stop-gradient operator. The importance sampling ratio relies on a uniquely asymmetric clipping function:

\[\hat{r}_{i,t}(\theta) = \text{clip}\!\left( \frac{\pi_\theta(o_{i,t} \mid q, o_{i,<t})}{\pi_{\theta_{\text{old}}}(o_{i,t} \mid q, o_{i,<t})},\ 0,\ 1 + \epsilon_{\text{IShigh}} \right)\]

Expert Insight: Notice the zero lower bound. Unlike standard PPO, this allows the optimizer to aggressively down-weight actions that have become improbable under the current policy, maximizing stability.

Composite Agent Rewards: Agent trajectories are penalized not just for failing, but for wasting time. The step reward $r_t$ combines process, performance, and a specific wall-clock speed reward:

\[r_t = \alpha \cdot r_t^{\text{process}} + \beta \cdot r_t^{\text{speed}} + r_t^{\text{perf}}\]

where $r_t^{\text{speed}} = h!\left(\frac{T_{\text{completion}}}{T_{\text{baseline}}}\right)$. This mathematically incentivizes the model to discover parallel tool execution and efficient coding loops. To reduce variance, they use a reward-to-go formulation $G_t = \sum_{\tau=t}^T \gamma^{\tau-t} r_\tau$ combined with a trajectory-level baseline.

3. Engineering Innovations: Solving the “Impossible Triangle”

Scaling agent RL introduces an “impossible triangle” of competing goals: System Throughput, Training Stability, and Agent Flexibility. Forge solves these with two brilliant infrastructural optimizations:

  1. Windowed FIFO Scheduling: Agent completion times vary from seconds to hours, causing severe Head-of-Line (HoL) blocking in strict FIFO. Conversely, pure greedy scheduling causes early batches to over-index on easy tasks, leading to gradient oscillation. Forge uses a sliding window $W$ (e.g., $W=0.3N$) over the generation queue. Within the window, data is fetched greedily (fixing HoL blocking); across window boundaries, strict order is maintained (preserving data distribution).
  2. Prefix Tree Merging: Agent rollouts often share massive identical context prefixes. Instead of independent sample computation, Forge dynamically merges common prefixes into a tree during the forward pass. The shared prefix is computed exactly once before branching into individual responses, resulting in a 40× training speedup with zero mathematical approximation error.

4. Interleaved Thinking & Self-Evolution

M2 formalizes Interleaved Thinking—alternating reasoning ($r_t$) and action ($a_t$) tokens dynamically rather than front-loading all thought. Crucially, M2 enforces Reasoning State Persistence, defined as:

\[H_{t+1} = H_t \oplus [\text{assistant}(r_t, a_t)] \oplus [\text{tool}(o_t)]\]

By persisting the “thinking blocks” in the history window, the model continuously refines strategies through a “Plan-Act-Reflect” loop without needing to statically re-derive partial conclusions at every turn.

Self-Evolution (M2.7): Perhaps the most profound insight from the paper is M2.7’s capacity to autonomously steer its own pipeline. Equipped with an internal Model Iteration System, M2.7 successfully diagnosed metric anomalies, read logs, and rewrote its own agent scaffold. Tested objectively as an AI researcher on OpenAI’s MLE Bench Lite, M2.7 achieved a 66.6% medal rate, matching Google’s Gemini 3.1 Pro.

Conclusion

The MiniMax-M2 series proves that astronomical parameter counts are not strictly necessary to achieve frontier-level autonomous agency. By deeply co-designing the training data pipelines (via executable Docker verifications and Agent-as-a-Verifier routines), resolving RL scaling bottlenecks via prefix-tree merging, and strictly enforcing an interleaved cognitive loop, the authors successfully compressed real-world intelligence into an extremely efficient 9.8B active-parameter footprint.