M2.7 MiniMax: self-evolution of AI model

MiniMax M2.7: How an AI Model Became the Co-Author of Its Own Architecture

MiniMax has unveiled M2.7—the world’s first language model capable of recursively optimizing its own hardware, memory, and RL parameters through closed-loop agent cycles. This isn’t just another benchmark-updated release; it’s a paradigm shift: the model now participates in designing the very tools it uses to learn and perform tasks. The result? A 56.22% score on SWE-Pro, 1495 ELO on GDPval-AA, and 97% adherence when executing over 40 complex skills simultaneously. Crucially, all of this was achieved without manual architecture rewriting—some refinements were made autonomously, within the model itself.

Self-Evolution Architecture: When the Model Manages Its Own Engineering Stack

The traditional ML cycle (data collection → retraining → deployment) has been replaced by a recursive workflow where M2.7 acts as a research co-pilot. It doesn’t just generate code—it formulates hypotheses, conducts literature reviews, prepares datasets, runs experiments, and interprets anomalies. Humans remain the arbiters for critical decisions, while 30–50% of routine operations are automated.

The key component is the internal hardware, which M2.7 can modify on its own. It includes:

• Autonomous feedback collection from logs, MRs, and test results;
• Dynamic generation of evaluation sets tailored to specific tasks;
• Iterative refinement of memory mechanisms and skill implementations following the MCP (Model Capability Protocol);
• Self-checking for looping and adaptive adjustment of temperature/frequency penalties.

In one experiment, the model completed over 100 iterations of “failure analysis → change plan → correction → evaluation → comparison,” leading to a 30% performance boost on internal benchmarks. Importantly, these changes affected not only weights but also orchestration logic—for example, pattern detection for bugs across related files after fixing a single issue was added.

Low-Resource Self-Optimization: Evolution on a Single A30 GPU

To test the limits of autonomy, the team conducted an experiment on MLE Bench Lite—22 ML competitions from OpenAI—running on a single A30 GPU. The goal was to assess whether the model could achieve meaningful self-optimization under strict computational and memory constraints.

The agent architecture in this scenario included:

• Short-term memory based on markdown logs of iterations;
• A self-criticism mechanism after each round that generates corrective actions;
• A recursive learning chain leveraging accumulated experience (experience replay with quality filtering).

After 24 hours of operation (three independent runs), the model scored 9 🥇, 5 🥈, and 1 🥉, achieving an average reward share of 66.6%. This matches the level of Gemini-3.1 and falls only slightly short of GPT-5.4 (71.2%) and Opus-4.6 (75.7%). The fact that stable results were achieved in low-resource mode confirms that self-optimization doesn’t depend on infrastructure scale—it’s embedded in the architectural logic.

Production Debugging: From Alert to MR in Under 3 Minutes

M2.7 demonstrates systemic thinking that goes beyond code generation. Its approach to production debugging follows a strict sequence:

Alert in monitoring
↓
Metric correlation (latency, error rate, deployment timestamps)
↓
Statistical analysis of traces → root cause hypotheses
↓
Automatic database connection for hypothesis verification
↓
Search for missing index migration file
↓
Generation of non-blocking CREATE INDEX + risk explanation
↓
MR formation with unit tests and rollback plan

This pipeline operates in real-time and requires no prior prompting. The model uses an internal state machine to manage context, maintaining references to logs, DB schemas, and deployment history. The practical effect is a reduction in MTTR (Mean Time to Recovery) to under 180 seconds with full autonomy.

Agent Teams: Multi-Agent Functionality as Built-In Feature

M2.7 implements Agent Teams not through external orchestration (e.g., LangChain), but as a native architectural capability. Each agent in the team has a clearly defined role, access to its own memory domain, and a unique set of interaction rules. Key features include:

• Adversarial validation: one agent generates a solution, while another critiques it based on internal reliability and safety criteria;
• Protocol-based interaction: messages between agents pass through a standardized serialized format with signatures and TTL;
• State-machine recovery: if one agent fails, the system redistributes tasks without losing context.

This allows creating virtual mini-teams for full-stack development—from requirements analysis to MVP generation with CI/CD configuration and documentation.

What Matters

• M2.7 is the first model to recursively modify its own hardware, including RL parameters and memory mechanisms.
• In low-resource scenarios (single A30 GPU), the model achieved an average reward share of 66.6% on MLE Bench Lite—on par with Gemini-3.1.
• Production debugging is executed as a unified pipeline: from alert to MR with tests in under 3 minutes, without manual intervention.
• Agent Teams are implemented as built-in functionality rather than external orchestration—with adversarial validation and protocol-based interaction.
• The model supports over 40 complex skills simultaneously with 97% adherence, including working with legacy code and multi-level documentation.

Integration and Practical Applications

M2.7 is already available in three formats: as a cloud agent (agent.minimax.io), via the API Platform (platform.minimax.io), and as part of the Coding Plan—a subscription for developers. Key use cases include:

• Autonomous debugging of production services;
• Full-stack project generation “turnkey” with CI/CD and documentation;
• Financial analysis (TSMC case: from reading the annual report to PPT and Word reports);
• Creating interactive characters in OpenRoom—a platform where dialogue triggers visual and script changes.

A notable feature of OpenRoom: a significant portion of its demo code was written by M2.7 itself, highlighting the transition from tool to co-author.

— Editorial Team