🤖 AI

SwarmResearch: Orchestrating Coding Agents for Open-Ended Discovery

SwarmResearch introduces an orchestrator-subagent framework that mitigates the convergence limitations of single long-running coding agents by using a Shepherd Agent to steer a population of context-isolated Search Agents, thereby achieving superior open-ended discovery through adaptive parallelism and higher-level exploration.

Original authors: Yuvraj Virk, Zack Edds, Chunqiu Steven Xia, Lingming Zhang

Published 2026-07-07

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Yuvraj Virk, Zack Edds, Chunqiu Steven Xia, Lingming Zhang

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 are trying to invent a new, super-fast way to bake a cake. You have a team of brilliant bakers (the AI coding agents), but you want them to find the best possible recipe, not just a slightly better one.

The paper introduces a new way to organize these bakers called SWARMRESEARCH. Here is how it works, using simple analogies:

The Problem: The "One-Track Mind" Trap

In the past, if you asked a single AI baker to improve a cake recipe, it would work like this:

It tries a new ingredient.
It tastes it. If it's good, it keeps it. If it's bad, it throws it away.
It does this over and over again, making tiny tweaks to the same recipe for hours.

The Issue: The baker gets stuck in a "local optimum." They keep perfecting a "chocolate cake" because it's already pretty good, but they never realize that switching to a "lemon tart" approach might be 10 times faster. They are too focused on the tiny details of the current path to see a completely new, better path. They also tend to forget their earlier ideas because they are constantly rewriting the same single notebook.

The Solution: The Swarm Approach

The authors built a system called SWARMRESEARCH to fix this. Think of it as a Research Farm with two types of workers:

The Shepherd (The Manager): This is the main AI. It doesn't bake the cake itself. Instead, it looks at the whole farm, sees what's working, and decides where to send help.
The Search Agents (The Bakers): These are the workers who actually do the baking.

Here is the magic of how they are organized:

Fresh Starts (The "Explorer" Bakers): Instead of one baker working on one notebook, the Shepherd sends out new bakers with blank notebooks. These "Explorer" bakers are told to ignore the old recipe and try wild, new ideas from scratch. They aren't stuck in the "chocolate cake" mindset.
Specialized Refiners (The "Optimizer" Bakers): If the Shepherd sees a really promising new idea (like a "lemon tart"), it sends a different type of baker to that specific branch. This "Optimizer" gets to see the detailed history of that specific idea so they can polish it to perfection.
Separate Workspaces (The Git Branches): This is the most important part. Every baker works in their own separate kitchen (a separate "git branch").
- If Baker A tries a terrible idea, they just throw away their kitchen. It doesn't ruin Baker B's kitchen.
- If Baker B discovers a brilliant new technique, the Shepherd can copy that kitchen to Baker C without Baker C having to delete their own current work.
- This prevents the team from accidentally deleting good ideas just because they are trying to fix a bad one.

How It Beats the Competition

The paper tested this system against other methods (like a single baker working for a long time, or a group of bakers sharing one big notebook).

The Result: On 13 out of 15 difficult puzzles (ranging from math problems to computer system optimizations), the Swarm found better solutions than the others.
Why? Because the Swarm didn't just "tweak" the existing solution. It was brave enough to try completely different approaches.
- Example: In one task, the old methods just adjusted the temperature of the oven slightly. The Swarm tried building a completely new type of oven.

A Real-World Example: Speeding Up AI

The authors used this system to try to make AI "think" faster (specifically, a technique called "speculative decoding").

The Old Way: The AI tried to make small edits to the code, like changing a variable here or there. It got a small speed boost.
The Swarm Way: The Swarm agents tried different strategies. One agent realized that instead of checking every single word one by one, they could check groups of words at once (like batching). Another agent realized they could use fewer "experts" to check the easy words.
The Outcome: The Swarm found a way to make the AI 4.58 times faster than the standard method, while the other methods only managed about a 2x speedup.

The Bottom Line

SWARMRESEARCH is a new way to manage AI researchers. Instead of letting one AI get stuck in a rut, it uses a manager to send out many different teams to explore different paths simultaneously. It keeps their workspaces separate so good ideas aren't lost, and it knows when to switch from "trying new things" to "perfecting the best thing."

It's the difference between one person trying to fix a car by tightening every bolt, and a team of mechanics who simultaneously try building a new engine, a new transmission, and a new chassis, then pick the best combination.

Technical Summary: SWARMRESEARCH

Problem Statement

Long-running coding agents, such as autoresearch frameworks, are capable of persistently discovering optimizations for open-ended problems. However, the authors observe a critical failure mode: these agents tend to converge rapidly onto a single high-level approach and subsequently spend extensive time performing low-level edits and micro-optimizations within that specific neighborhood. This behavior results in the agent missing superior, distinct approaches to the problem.

The authors hypothesize that this convergence is caused by two specific harness-level design choices in existing systems:

Context Accumulation: Agents accumulate long conversation histories filled with incremental refinements of a single approach, making substantial shifts in strategy unlikely.
Single Program State: Agents commit all improvements to a single editable program, effectively discarding alternative directions and turning the search process into a greedy local search.

Methodology: SWARMRESEARCH

To address these bottlenecks, the authors introduce SWARMRESEARCH, an orchestrator-subagent harness designed to facilitate open-ended discovery. The system is implemented as a set of skills compatible with popular coding agent tools (e.g., Claude Code).

Architecture

The system consists of two primary roles:

Shepherd Agent (Orchestrator): A global controller that manages a population of Search Agents. It maintains global context (summaries of all attempts, scores, and approaches) and strategically steers the search population.
Search Agents (Subagents): Individual agents responsible for ideating, implementing, evaluating, and iterating on solutions. They operate with local context specific to their assigned task.

Key Design Mechanisms

SWARMRESEARCH employs three specific mechanisms to maintain diversity and prevent premature convergence:

Git-Based Branching (Program Versioning):
- Unlike systems that edit a single program state, SWARMRESEARCH assigns every Search Agent to a new Git branch.
- The main branch contains only the baseline. Search agents branch off from either the baseline (for from-scratch exploration) or from a completed agent's commit (for iteration).
- This allows multiple competing high-level approaches to evolve independently. Promising but non-optimal solutions are not discarded but preserved in their own branches for potential future refinement or combination.
Tiered Context Management:
- Local Context: Search Agents operate with fresh or controlled context windows.
  - Explorer Agents: Start with fresh context windows, reading only the contents of their assigned worktree. This prevents them from being anchored to prior work, encouraging high-level exploration.
  - Optimizer Agents: Inherit the conversation history of their parent agent in addition to the worktree. This allows for deep, serial refinement when a specific approach shows promise.
- Global Context: The Shepherd Agent maintains a global view of all Search Agent activities (summaries and scores) but does not expose the full conversation history of all agents to every subagent. This prevents the "shared memory" convergence seen in other multi-agent systems where agents collectively abandon independent directions to refine the single best solution.
Orchestrator-Guided Scaling:
- The Shepherd Agent dynamically manages the search budget by varying the number of parallel agents and serial iterations based on the search depth.
- It can spawn waves of concurrent Explorers to fan out across the solution space and switch to spawning Optimizers when dominant solutions emerge.
- The Shepherd uses prompts to share minimal, relevant context (e.g., "ideas to avoid," "useful findings") without prescribing specific ideas, thereby maintaining idea diversity.

Evaluation and Results

The authors evaluated SWARMRESEARCH on 15 open-ended optimization tasks across three domains: Mathematics, Systems, and Heuristic Algorithms. They compared it against state-of-the-art baselines:

EvoX: An LLM-guided evolutionary baseline.
CORAL: A state-of-the-art multi-agent system using shared memory.
Fixed Scaling: A naive baseline executing $n$ concurrent agents for $k$ serial iterations.

Performance Metrics

Task Success: SWARMRESEARCH discovered better or comparable solutions to the baselines on 13 out of 15 tasks.
- It strictly exceeded EvoX on 13 tasks and matched it on 1.
- It strictly exceeded CORAL on 10 tasks and matched it on 2.
Granularity of Exploration: SWARMRESEARCH typically made 1.7× to 3.2× larger code changes (measured in lines of code changed per attempt) compared to baselines. This indicates a higher frequency of high-level approach exploration rather than low-level tuning.
Scaling Efficiency: In a comparison with optimal fixed scaling (testing various $(n, k)$ configurations), SWARMRESEARCH's orchestrator-guided scaling outperformed the best fixed configuration on 4 out of 5 tasks. The system successfully adapted parallelism at different search depths, allocating budget to wide exploration initially and deep serial iteration later.

Case Study: Speculative Decoding

The authors conducted a detailed case study on optimizing speculative decoding for LLM inference.

Goal: Maximize token throughput while preserving accuracy on reasoning-intensive tasks.
Results: SWARMRESEARCH achieved a 4.58× speedup over naive vanilla decoding with 60.6% accuracy (vs. 65.8% baseline).
Comparison: In the same timeframe (~12 hours), autoresearch achieved only a 1.80× speedup, and CORAL achieved 2.26×.
Discoveries: The system discovered systems-level optimizations (e.g., batching target forward passes, persistent thread pools for distribution construction) and adaptive expert counting (MoE) that were not present in the baselines. It also explored relaxed acceptance conditions, though some novel attempts (e.g., "comonotone sampling") were found to be incorrect upon rigorous review.

Significance and Claims

The paper claims that SWARMRESEARCH demonstrates that harness engineering—specifically the management of context and program versioning—is a critical factor in the success of long-running coding agents.

Divergent Discovery: By decoupling agents from long, convergent conversation histories and preserving alternative program states via Git branching, the system avoids the "greedy local search" trap common in single-agent or shared-memory multi-agent systems.
Autonomous Scaling: The orchestrator-subagent architecture allows for adaptive test-time scaling, dynamically adjusting the balance between exploration (parallelism) and exploitation (serial refinement) without manual hyperparameter tuning.
Limitations: The authors modestly note that the harness does not inherently enhance the creativity of the underlying LLMs; the explored approaches still tend to be variations of known methods. Furthermore, the strategic steering behavior of the Shepherd Agent is currently prompt-reliant, and the models tested sometimes struggle to synthesize complex strategic plans without explicit guidance.

The work positions SWARMRESEARCH as a minimal, interoperable base for future harnesses and training on open-ended discovery, emphasizing that structural design choices can significantly amplify the discovery capabilities of existing coding agents.