Agents Work Better When They Can Pass Each Other Notes: Meta research on agent orchestration finds message passing improves performance, reduces latency

Large language models can work faster by dividing problems into sub-problems to be solved in parallel instead of in sequence. However, the speed-up is capped in systems that aggregate the sub-results at a single point. Researchers devised a way to remove that limit.

What’s new: A team at Carnegie Mellon University led by Xuecheng Liu and Daman Arora proposed an agentic harness called Message Passing Language Models (MPLMs). Under MPLM, an LLM distributes sub-problems among separate threads — each running its own copy of the LLM — that can communicate with one another. This approach solved two types of structured puzzles faster than alternatives.

Key insight: In earlier parallelization methods, an LLM breaks down tasks into sub-tasks while a coordinator thread spawns separate threads, assigns sub-tasks to them, and collects their output. The problem with this arrangement is that the coordinator can become bogged down in reasoning, tool calls, and the like, so the subtasks must wait. But problems in which the relationships between threads are known in advance don’t require a central coordinator. Instead, related threads can communicate with one another. Enabling threads to communicate directly makes the coordinator unnecessary and limits the total load on any one thread.

How it works: Under MPLM, a model and its iterations can write commands that start threads, send results to specific threads, wait for replies, or stop threads. The authors built programs that (i) used these commands to solve puzzles and (ii) produced text traces as they considered possible solutions. They trained Qwen3-0.6B-Base on those traces. The puzzles included examples of 3-SAT (deciding whether a boolean formula can evaluate to true) and Sudoku (filling a square grid with numbers, from 1 to the number of cells in a row, column, and box, so no number repeats in any row, column, or box). The description below applies to solving Sudoku. Solving 3-SAT involved a different process.

• A parent thread tracked the parts of a puzzle that had been solved.
• For each cell in a Sudoku grid, its thread determined the correct number by elimination (since a Sudoku grid comes pre-populated with some numbers and a cell can’t repeat a number already in its row, column, or box). While a thread was undecided, it waited to receive numbers from the threads that managed cells in its row, column, and box. As their numbers arrived, it ruled out numbers until one was left. Once it had settled on a number, it sent the number to the parent and related threads and stopped.
• When every thread had stopped, the parent thread reported the solution.

Results: MPLM solved the puzzles faster and in fewer tokens per thread than two earlier approaches: a single thread and an agentic harness that runs parallel threads but routes their results through a coordinator.

• Solving Sudoku grids from 4×4 to 25×25, MPLM was significantly faster on average. For instance, given 9x9 grids, MPLM solved 100 percent in roughly 15 seconds, whereas the parallel method solved 93 percent in roughly 60 seconds. Furthermore, MPLM’s tokens per thread grew more slowly as the grids scaled up. MPLM solved 72 percent of the 25×25 puzzles, where the other two methods reached limits of context or compute imposed by the authors before they learned to solve the problems.
• Solving 3-SAT problems involving formulas that included 8 to 20 variables, MPLM’s accuracy was about even with the parallel method, roughly 92 versus 91 percent. It was marginally faster on average than the parallel method, but it processed some examples much faster — sometimes 2.5x faster — because once the model found a solution in one thread, it could stop the others. The single-thread method did not run beyond 12 variables, having filled the model’s context window.

Yes, but: MPLM's efficiency depends on knowing in advance which threads must communicate with which. It shines where that communication pattern is fixed and easy to work out, as it is in Sudoku and 3-SAT. For open-ended problems, the authors note that finding the pattern may take careful prompting or extra training. Moreover, the Sudoku examples were limited to puzzles that could be solved by elimination (known as naked singles), so the model never had to guess and check or reason more extensively across threads.

Why it matters: Models that perform tasks in a single thread can fill their context windows before they reach a solution. MPLM enables models to distribute the work among many threads that, collectively, can get the job done.

We’re thinking: The authors also prompted two larger models, Qwen3-30B-A3B and Qwen3.6-35B-A3B, to use their method to tackle problems on the LongBench-v2 long-context reasoning benchmark. Both models showed improved accuracy and faster responses (roughly a 2x reduction in average latency) in the MPLM harness. This suggests this method is generalizable to reasoning challenges beyond the relatively simple Sudoku and 3-SAT examples, although its effects do seem to be stronger on smaller models.