The Model That Trained Itself: How MiniMax M2.7 Opened the Self-Evolution Era
Site Owner
Published on 2026-05-10
MiniMax M2.7 doesn't just run tasks — it can improve its own training harness autonomously, beating the results human engineers achieved. Here's why that matters for the entire AI industry.
The Model That Trained Itself: How MiniMax M2.7 Opened the Self-Evolution Era
Here's a strange sentence to write in 2026: the model that built the harness that trained itself is now better than the humans who started the whole thing.
No, really. MiniMax just dropped M2.7 — and buried in the release notes, between the benchmark scores and the platitudes, is a capability that should make every AI researcher pause: the model can iteratively improve its own training infrastructure, then beat the results its creators got with human-designed setups.
That's not a demo. That's not a cherry-picked toy example. It's happening in production — in the same pipeline that shipped the model you're reading about.
What "Self-Evolution" Actually Means
Let's be precise, because this word gets sloppily attached to everything. When MiniMax says M2.7 self-evolves, they mean:
The model builds its own RL (reinforcement learning) harness — the scaffolding that defines how a model practices and gets scored.
It writes the skills and tools the harness uses.
It runs experiments, reads the failure logs, diagnoses what's broken, modifies the harness, and repeats — for 100+ rounds, autonomously.
It outperforms the human-designed baseline.
Think about what that implies. Normally, AI development looks like: researchers build a harness → run experiments → model gets better → researchers analyze results → researchers improve the harness → repeat. The humans are in the loop at every design decision. With M2.7, the model took the steering wheel on step three and four. Researchers still set direction, but the grunt work of iteration — the boring, tedious, 100-round grind — got automated.
#AI Agent#AI模型#智能体定制
The Model That Trained Itself: MiniMax M2.7 and the Self-Evolution Era
The gains were concrete. M2.7 discovered that searching the temperature and frequency-penalty sampling parameters systematically was more effective than the human-chosen defaults. It added a workflow rule: after fixing a bug in one file, automatically search for the same bug pattern across the entire codebase. It inserted loop-detection into the agent loop to prevent infinite spinning.
Result: 30% improvement on the internal benchmark. A human team of experienced engineers, iterating over weeks, couldn't beat that.
Why This Changes the Rate of Progress
The bottleneck in AI has never really been "can the model learn this." It's been: how fast can we, as an industry, design the right training setup, write the right tools, run the right experiments, and interpret the right signals.
That's a human-time problem. It's slow. It's expensive. It requires coordinating researchers, engineers, and ops teams across weeks of iteration. And it's the primary constraint on how quickly models improve.
Self-evolving models don't have that constraint. They can run 100 rounds of self-improvement overnight. They don't need to schedule meetings. They don't get tired.
Marc Andreessen, in a recent conversation, called this the payoff of an "80-year overnight success" — decades of accumulated research suddenly delivering at scale. But even he might be underestimating the second-order effect here. When models can improve their own training infrastructure, the curve gets steeper. Not just because more compute is available, but because the iteration rate itself accelerates.
We saw this with coding models. When AI got good enough to write code that helped write better AI, the field stopped moving in linear increments. The next jump in capability might not come from a new architecture. It might come from a model finding a training trick no human thought to try.
The Software Engineering Proof
Don't want to take this on faith? Look at the numbers.
On SWE-Pro (software engineering benchmark), M2.7 scored 56.22% — basically tied with GPT-5.3-Codex. On VIBE-Pro, which tests end-to-end project delivery, it hit 55.6%, nearly matching Opus 4.6. On Terminal Bench 2, which probes deep understanding of complex engineering systems, it scored 57.0%.
These aren't toy problems. SWE-Pro tests real bug fixes in real open-source repos. VIBE-Pro asks for a complete deliverable — web app, mobile app, simulation. Terminal Bench throws you into a gnarly production debugging scenario and expects you to figure out what went wrong across a distributed system.
And here's the thing: M2.7 didn't just pass these tests. It passed them in a pipeline that it designed for itself. The skills, the harness, the memory management — the model was the one who put that training stack together.
The Office Worker Who Never Gets Tired
Self-evolution isn't limited to engineering. In professional办公 (that's "office work" in Chinese, and yes, the original document actually went there), M2.7 can:
Read a company's annual report and earnings call transcripts
Cross-reference multiple analyst research reports
Build a revenue projection model from scratch
Generate a PowerPoint presentation and a Word research document from that model
One evaluator described the output as "可以直接进入后续工作流程" — good enough to go straight into the actual workflow without revision.
That's a junior analyst's job. A stressful, 80-hour-week junior analyst's job. And M2.7 can do it without coffee breaks.
On GDPval-AA, which benchmarks professional domain expertise across 45 models, M2.7 scored 1495 ELO — behind only Opus 4.6, Sonnet 4.6, and GPT-5.4, and above GPT-5.3. For a Chinese lab, that's a meaningful statement about where the frontier actually sits.
Agent Teams: The Real Multiplication
Individual model performance is impressive. But the more strategically interesting capability is Agent Teams — multiple model instances that coordinate, challenge each other, and divide labor like a real team.
This isn't multi-agent theater where each agent just calls the next one in a pipeline. In M2.7's setup, agents have distinct roles with genuine adversarial dynamics. One agent's job is to challenge the logic and ethical blind spots of the others. Agents maintain role identity across long task sequences. They make autonomous decisions within complex state machines.
This is qualitatively different from single-agent prompting. It's closer to how a well-run engineering team actually works — with the friction and disagreement that makes the output better.
And it's not something you can prompt your way into. These behaviors have to be native to the model's training.
What Comes Next
Here's the uncomfortable question: if models can now improve their own training infrastructure, what does the next 12 months look like?
The honest answer is: we don't know. The history of AI is littered with confident predictions that missed by years. But we can say this: the rate-limiting step in model improvement has historically been human iteration speed. Self-evolving models remove that bottleneck.
The consequences are worth sitting with. If a model can improve its own RL harness, it can probably improve its own data selection, its own architecture decisions, its own evaluation metrics. The human role shifts from "designer" to "evaluator" — setting goals and judging outcomes, rather than building the pipeline.
Some will find this alarming. Others will find it exciting. Both reactions are correct.
The model that trained itself is not science fiction. It's shipping. And it's probably already working on M2.8.
