EvolveNet: Collaborative Harness Evolution for Agent Self-Improvement
EvolveNet introduces a collaborative framework for agent self-improvement that broadcasts a shared harness to local agents for independent evolution and then aggregates their program adaptations, thereby enabling knowledge transfer across isolated workloads without centralizing raw data.
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
Imagine you have a super-smart robot brain (a Large Language Model) that can write code, solve math problems, or plan trips. But this brain is frozen; you can't retrain it or change its internal wiring. To make it actually do things, you need to wrap it in a "harness"—a set of instructions, a script, or a program that tells the brain when to speak, which tools to use, how to check its own work, and what to do if it makes a mistake. Think of the harness as the robot's body and nervous system. A better body can make the same frozen brain perform miracles it couldn't do before.
For a long time, scientists tried to improve these bodies by gathering all the robot's mistakes and successes into one giant pile of data at a central headquarters. There, a single "optimizer" would try to evolve one perfect body for everyone. But in the real world, robots (or agents) are scattered everywhere: in different companies, with different databases, and in different environments. They can't always share their private data due to privacy rules or technical limits. This creates a puzzle: How do you make a shared, super-smart body for everyone if you can't bring all the experience to one place?
This is where the paper EvolveNet steps in with a clever new idea. Instead of gathering all the messy data to one spot, EvolveNet flips the script. It sends a "shared body" (the harness) out to all the different robots. Each robot tries to improve that body using its own local data and its own specific problems. Once they are done, they don't send their data back; they send back only the changes they made to the body. A central server then acts like a master tailor, stitching together the best parts of all these different modifications into one new, improved shared body, which is then sent back out to everyone.
The paper finds that this "collaborative evolution" works incredibly well. In tests across five different areas—like turning text into database queries, writing data science code, and solving competitive programming challenges—the shared body got significantly better at every task. For example, on a coding challenge called DS-1000, the accuracy jumped from 55.5% to 68.5%. Crucially, the paper shows that this improvement doesn't come from just picking the single best robot and ignoring the rest. Instead, it comes from combining the unique fixes discovered by different robots. One robot might fix a problem with a specific type of math library, while another fixes a logic error in a different area. The server's job is to figure out how to keep both fixes without them fighting each other. The researchers found that by using "scope-typed" rules—essentially telling the body, "Use this fix only when you're dealing with math, but use that fix only when you're dealing with maps"—they could merge these different skills into a single, super-capable agent.
The study also rules out the idea that you need to centralize all the data to get good results. It proves that you can keep data local and private while still building a smarter system together. However, the authors are careful to note that this isn't a magic wand that solves everything instantly. The process takes several rounds of trial and error, and the system relies on having some labeled data to check if the changes actually work. While the results are strong and measured across multiple real-world scenarios, the paper suggests that as these systems grow larger and run for more rounds, there might be new challenges, like the code getting too big or messy, that need to be managed. But for now, EvolveNet shows that by letting many agents evolve their own specialized skills and then carefully stitching them together, we can create a collective intelligence that is far smarter than any single agent could be on its own.
Drowning in papers in your field?
Get daily digests of the most novel papers matching your research keywords — with technical summaries, in your language.