Sakana AI unveils MASS: one model that teams up with copies of itself to self-improve

Introduction

Sakana AI, the Tokyo-based AI lab, published MASS (Multi-Agent Self-Supervision) on October 12, 2026. It is a recursive self-improvement (RSI) method in which a single language model plays three roles at once: it executes the task, optimizes the workflow and evaluates the result. The release includes an arXiv paper, a detailed technical blog and open-source code on GitHub.

The question the authors tackle is simple to state and hard to solve: when a task is open-ended (a research project, a report, an analysis) and even human experts cannot assess everything quickly, the model itself may be the best supervisor available. But a model working alone tends to reinforce its own mistakes rather than correct them. MASS bets on organizing several copies of the same model as a team and using that team's collective work as a training signal.

For people building AI agents or automation for businesses in Japan, this matters in two ways: some of the ideas can be applied to your own workflows today, and the safety warnings apply to any system that grades its own work.

What MASS is

In MASS, the same model fills three roles:

• Agent (executor): solves the task and produces a workspace with code, results, plots and a report.
• Workflow optimizer: uses the evaluator's feedback to revise how the team divides the work, exchanges results and checks each other's work.
• Evaluator: compares two workspaces, picks the one that better satisfies the task and explains why.

A "workflow" here is a written plan, appended to the task prompt, that describes a team made of an orchestrator and subagents. Each workflow has four components: role (each subagent's responsibility), instruction (what it should do), contract (the information and checks it must return) and hop (the order in which subagents are called).

One example Sakana cites is a finance workflow in which the data specialist's contract requires explicit checks that there is no leakage of future information and that the training, validation and test periods are in the right order. That is exactly the kind of mistake that makes a backtest look great and be useless.

How the loop works

MASS alternates between two loops.

Inner loop: searching for a better workflow. For each training task, the system keeps a "champion", the best workflow found so far according to the model's own judgment. In each iteration, the team executes a candidate workflow, the evaluator compares the result with the champion's, and the optimizer proposes the next version based on the feedback history. According to the paper, this is an evolutionary search constrained by structural guardrails, and the optimizer's prompt prioritizes contracts and call order, in other words what information flows between agents and when.

Outer loop: learning from the best team. The champion workflow is run 18 times per task. The model itself compares and ranks the results (a Bradley–Terry model turns the preferences into scores), and up to 16 trajectories per task are kept: 15 for training and one for validation. The workflow text is removed from the orchestrator's prompt, and the model goes through supervised fine-tuning (SFT, with LoRA) on both the orchestrator and subagent conversations. The updated model then takes on all three roles again and the cycle restarts.

The idea is for the model to learn how to organize the work from the task itself, without being handed the workflow.

What was measured

The team ran two full cycles with the open-weights model Qwen3.6-27B, using the qwen-code coding agent. Training data came from 12 synthetic research tasks in finance, robotics and pharmacy: nine designated for training (eight ended up supplying data) and three held out for testing. To measure progress from outside the loop, GPT-5.5 and Claude Opus 4.8 assessed the results, and those judgments were not used by MASS.

The main numbers reported by Sakana and in the paper:

• Score per output token of 1.2 to 1.6 times the base model's after the second cycle, on four research benchmarks: MLR-Bench, DSBench, ScienceAgentBench and AstaBench.
• On the three synthetic test tasks, the win rate against the base model rose from 53.9% after the first cycle to 69.9% after the second.
• Training used only task-solving trajectories, yet the optimizer and the evaluator improved too. The evaluator's agreement with the external judges rose from 73% to 93%.
• Multi-agent trajectories yield more per training token: the student trained on them reached a 68.3% win rate against the base with 28.8 million supervised tokens, versus 64.0% for a single-agent student trained on 42 million, roughly 1.4 times more tokens.
• In the ablations, the speed bottleneck was the optimizer, not the evaluator: swapping only the evaluator for a stronger model helped a little; swapping both evaluator and optimizer helped a lot.

How to try the code safely

The github.com/SakanaAI/mass repository is described as a research implementation. A prudent path:

1. Start offline. The README says python3 -m mass plan --config configs/paper.json prints the configuration without executing anything, and the unit tests run with no GPU or model server.
2. Isolate the environment. MASS has agents write and run code. Use a separate VM or container with no access to your internal network and no production credentials. The repository ships a .env.example; do not put broadly scoped keys in it.
3. Size the hardware first. A real experiment requires serving the model with vLLM and allocating GPUs. The first-cycle SFT alone took about 19 hours on six NVIDIA H100 GPUs, not counting workflow search, trajectory collection and evaluation.
4. Check the license. As of this writing, we did not find a license file in the repository root (there is a NOTICE.md covering third-party software and data). Before any commercial use, confirm the terms with Sakana AI.
5. Read the implementation notes. The README itself warns that the code does not include every ablation in the paper, that some benchmark adapters are not packaged and that the current driver differs in some respects from the algorithm described in the paper.

Even without training anything, the lesson of contracts can be applied today: in your multi-agent flows, write down what each step must deliver and which checks it must prove before the next step starts.

Safety caveats: shared blind spots

The authors themselves make the most important warning. When the same model generates, evaluates and decides what becomes training data, a shared blind spot can let a flawed result be produced, accepted as an improvement and incorporated into the next model. If humans also miss the flaw, later updates may reinforce it. Sakana calls this a possible "Achilles' heel" of recursive self-improvement and argues for independent checks, constraints on autonomous actions and clear conditions for intervention.

For a business, the practical translation is: do not let the same model be the only judge of its own work in decisions that matter. Keep a separate evaluator, test sets the system never sees and human review at critical points.

What not to expect

• It is not a general coding gain. On Terminal-Bench 2.0 and SWE-bench Verified, score per token came in at 0.96 and 0.94 times the base, respectively. Sakana says transfer "remains uneven".
• Part of the gain comes from delivering more. On MLR-Bench, the increase accompanies more papers delivered; the paper itself says the evidence depends on how results are aggregated and does not establish a consistent gain across all tasks.
• The search is noisy. Strong iterations can be followed by sharp regressions, and two runs of the same workflow produced opposite outcomes.
• It is not a finished product. This is two cycles, a 27B model and synthetic tasks. It is research, not a plug-and-play tool.

Conclusion

MASS is an interesting step toward models that improve by using the teamwork of copies of themselves, and it comes with open code and honest numbers, including where there was no gain. For small and medium-sized businesses, the immediate value lies less in running the full cycle and more in the ideas: clear contracts between agents, evaluation kept separate from generation and extra attention to the blind spots of any system that grades itself.

Sources

• Sakana AI: Recursive Self-Improvement through Collective Intelligence (MASS)
• Sakana AI: MASS — blog técnico detalhado
• arXiv 2610.12176: Recursive Self-Improvement through Multi-Agent Self-Supervision
• GitHub: SakanaAI/mass

---

Want this for your business?

KGA IT helps small and medium-sized businesses set up AI assistants, automation and websites. The consultation is free and we reply within 24 hours. Plans start at ¥5,000/month.

• Phone: 080-9732-1062
• Email: kga-it@outlook.com
• Contact page: kga-it.com/en/contact