Initialization Improves LLM-Driven Discovery | AI Paper Digest

TL;DR Highlight

Seeding iterative LLM discovery with a parallel-explored population lifted SOTA harness scores 2–21%.

Who Should Read

Developers running iterative LLM improvement loops (OpenEvolve-style) for algorithms or prompts whose results vary wildly from run to run

Core Mechanics

Sequential refinement doesn't always win
- Sequential harnesses (loops that feed past results back into the prompt) beat parallel sampling only in some cases.
- The best harness differed across all 5 tasks.
Sequential loops suffer mode collapse
- Diversity of new candidates shrinks as the trajectory goes on.
- Parallel sampling produced more diverse candidates.
Diversity tricks were inconsistent
- Similarity thresholds, LLM judges and dedup raised diversity.
- But plain Modular usually scored highest, and some interventions hurt.
Early scores predict final scores
- Median score of the first 15 discoveries correlated with the trajectory's best score.
- The strength of the correlation varied by task.
Parallel first, then sequential wins
- Spend part of the budget on parallel exploration to build a good initial population, then start the sequential loop.

Evidence

2–21% gain on SOTA harnesses
- Initializing ShinkaEvolve, OpenEvolve and optimize anything with the best seed raised scores 2%–21% in every (task, LLM) pair.
- Compared against the same harnesses uninitialized at the same total budget.
Convergence predicted best budget 9/13
- The initialization budget predicted by convergence analysis matched the best budget in 9 of 13 settings.
SOTA lost to Modular in places
- On TSP (Gemini 3.5 Flash), Modular averaged -1719 vs SOTA -1772.
- On Prompt Optim. (Llama 3.1 8B), Modular scored 0.53 vs SOTA 0.47.
Diversity interventions lowered scores
- On Circle Packing (GPT-OSS 120B), Modular scored 2.44, similarity threshold 0.95 scored 2.19, and dedup scored 2.04.
s=0.98 was a safe initial filter
- Filtering only near-duplicates (s=0.98) usually beat pure greedy (s=1).
- More diverse initial populations (s<0.98) lowered average performance.

How to Apply

Add a parallel sampling stage before your loop
- Replace your single starting seed with top candidates from parallel calls using the same prompt.
- Sort by score, drop near-duplicates, and keep 15.
Use convergence to decide the switch
- Run parallel calls in batches and switch to the sequential loop once the best score stops improving by δ over a budget window.
- Set δ and N for your task's score scale (the paper used values one to two orders of magnitude below the max score).
A/B test diversity tricks before adopting
Sweep the initialization ratio from 10 to 90%
- On a small task, try initialization ratios of 10, 25, 50, 75 and 90%.
- Keep the total token budget fixed.

Try It

copy & run

# Simplified version of the paper's method: paste into Claude/ChatGPT (parallel init, then sequential refinement)

You are an optimization agent. Goal: {{task description}}
Scoring metric: {{evaluation metric}} (higher is better)

Step 1: Independently produce 8 solutions. Write an estimated score under each.
Step 2: Remove near-duplicates and pick the top 3 by score.
Step 3: Treat those 3 as past examples and produce a new, different solution that maximizes the score. Repeat this step 3 times.

Output only the best solution at the end.

Next thing to try: compare against starting from a single seed without Step 1.

Terminology

HarnessA framework that repeatedly calls an LLM and manages past results to optimize an objective. Like a coach reviewing an athlete's records to plan the next session.

Mode collapseCandidates converge on similar solutions as iterations proceed. Like everyone copying the same answer.

Initial populationThe first batch of candidates placed in the prompt when sequential refinement starts. It's the starting line of the race.

Inference-time computeSpending more tokens when answering, without retraining the model, to improve quality.

Reward hackingGaming the evaluator instead of solving the task. In the paper, a CloudCast discovery inspected the call stack to find and use the evaluator.

Related Papers

Related Resources

https://github.com/msakarvadia/llm_optimizer

Original Abstract (Expand)

Large Language Models (LLMs) have been used for novel discovery of algorithms, theorems, drugs, and other tasks through the use of harnesses that prompt an LLM to iteratively optimize an objective. In this work, we study the relationship between the population of previous iterates and eventual discovery success. We generalize past work on harness design to develop a suite of 12 harnesses called 'Modular' and characterize their performance across 5 diverse discovery tasks, finding that discovery success is brittle and sensitive to harness design. We uncover mode collapse, characterized by a dramatic drop in the diversity of iterates, as a common failure mode. We find that popular state-of-the-art harnesses and diversity-inducing harness interventions, which aim to prolong this collapse, yield inconsistent gains. Our results instead uncover that the performance of early discoveries is predictive of eventual success. We therefore propose a universally applicable intervention that performs an initial stage of parallel exploration in order to initialize subsequent iterative optimization. Our method provides consistent gains across many harnesses and target applications, confirming the importance of initialization in LLM-driven discovery.