← Latest papers
🤖 machine learning

Stronger-MAS: Multi-Agent Reinforcement Learning for Collaborative LLMs

The paper proposes AT-GRPO, a novel multi-agent reinforcement learning framework that introduces an agent- and turn-wise grouped optimization algorithm and a flexible training system to overcome the limitations of standard on-policy RL in collaborative LLMs, achieving substantial performance gains across planning, coding, and math tasks.

Original authors: Yujie Zhao, Lanxiang Hu, Yang Wang, Minmin Hou, Hao Zhang, Ke Ding, Jishen Zhao

Published 2026-02-02
📖 5 min read🧠 Deep dive

Original authors: Yujie Zhao, Lanxiang Hu, Yang Wang, Minmin Hou, Hao Zhang, Ke Ding, Jishen Zhao

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

The Big Idea: Teaching a Team to Work Together

Imagine you have a very smart but slightly clumsy robot (a Large Language Model, or LLM). You want it to solve complex puzzles, write code, or play games.

There are two main ways people usually try to make this robot better:

  1. The "Specialist" Team (Multi-Agent System): You give the robot a team of friends. One friend is the "Coder," another is the "Tester," and a third is the "Planner." They talk to each other to solve the problem. This works well because they have specific jobs.
  2. The "Practice Makes Perfect" Method (Reinforcement Learning): You let the robot try, fail, get a score, and try again. Over time, it learns from its mistakes to become a master at the task.

The Problem: Until now, these two methods didn't mix well.

  • If you try to teach the whole team using the "Practice" method, the training gets messy. The "Coder" and the "Tester" are talking to each other, so their prompts (instructions) are constantly changing. Standard training methods get confused because they expect everyone to be answering the exact same question at the same time.
  • If you just let them practice alone, they don't learn how to collaborate effectively.

The Solution: The authors created STRONGER-MAS (specifically an algorithm called AT-GRPO). Think of this as a new, super-smart coach that knows how to train a whole team of specialists simultaneously.


How It Works: The "Tree" Analogy

1. The Old Way (Parallel Sampling)

Imagine a coach asking 4 different students to solve a math problem.

  • Student A writes a solution.
  • Student B writes a solution.
  • Student C writes a solution.
  • Student D writes a solution.

The coach looks at all four answers and says, "Okay, Student A did the best."
The Flaw: In a team setting, the next step isn't just "solve the problem again." It's "Student A, here is what Student B wrote; now fix your answer." The context changes every time. If you just ask them to solve the original problem again, you aren't training them to work together.

2. The New Way (Tree-Structured Sampling)

The STRONGER-MAS coach uses a Tree approach.

  • Step 1: The team starts with a problem.
  • Step 2: The "Coder" tries 4 different ways to write the code. The coach grades all 4 immediately.
  • Step 3: The coach picks the best of those 4 codes.
  • Step 4: Now, the "Tester" sees that specific best code and tries 4 different ways to test it. The coach grades those 4.
  • Step 5: The coach picks the best test, and the cycle continues.

Why this matters: This ensures that when the coach compares the "Coder's" 4 attempts, they are all reacting to the exact same situation. This makes the learning fair and effective. It's like a coach saying, "Okay, everyone, look at this specific draft. Here are 4 ways you could improve it. Let's see which one works best."


The "Specialized vs. Shared" Debate

The paper also tested two different team structures:

  1. The "Shared Brain" (Role-Sharing): Everyone on the team uses the exact same brain (the same AI model). They just pretend to be different people by reading different instruction cards (prompts).
    • Result: Works great for simple games and planning.
  2. The "Specialized Brains" (Role-Specialized): The "Coder" has a brain trained specifically for coding, and the "Tester" has a brain trained specifically for testing. They never swap jobs.
    • Result: This was a huge winner for coding and math. The "Coder" got really good at writing code because it only ever practiced coding, and the "Tester" got really good at finding bugs.

The Takeaway: The paper found that you don't always need a specialized brain for every job. For some tasks (like simple games), one smart brain shared by everyone is enough. But for hard tasks (like writing complex software), having a dedicated expert for each role is much better.


The Results: From "Okay" to "Superhuman"

The paper tested this system on four types of tasks: Games, Planning, Coding, and Math.

  • Long-Horizon Planning (The Big Win): Imagine a game where you have to plan 10 steps ahead.

    • Before: A single robot trying to do this alone was only right 14% to 47% of the time. It got lost easily.
    • After: With the STRONGER-MAS team, they got it right 96% to 99.5% of the time.
    • Analogy: It's like going from a lost tourist with a crumpled map to a guided tour group where everyone knows exactly where to go.
  • Coding and Math: The team also got significantly better at writing bug-free code and solving hard math problems (improvements of roughly 4% to 18% over previous best methods).

Summary

The paper introduces a new way to train AI teams. Instead of training them as individuals or as a confused group, they use a Tree-Structured method that keeps the team's conversation focused and fair. This allows the AI to learn how to collaborate, resulting in massive improvements in solving complex, multi-step problems like planning routes, writing software, and solving math puzzles.

Drowning in papers in your field?

Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.

Try Digest →