CausalEvolve: Towards Open-Ended Discovery with Causal Scratchpad
CausalEvolve adds causal scratchpads to program evolution, improving four open-ended tasks and reaching 38.89% on AIME.
Key Findings
Methodology
CausalEvolve formulates evolutionary discovery as a POMDP with a causal scratchpad. An LLM first proposes outcome-level factors; CausalPlanner treats factor directions as multi-armed-bandit actions. COAT then extracts procedure-level factors, estimates approximate average treatment effects, detects surprising effect reversals or shifts, and uses abductive reasoning to generate new factors and hypotheses.
Key Results
- With Grok-4.1-fast-reasoning and three seeds, final Hadamard Matrix Mean/Best scores were 0.568/0.576, versus 0.521/0.540 for ShinkaEvolve.
- On Second Autocorrelation Inequality, CausalEvolve reached 0.793/0.809 Mean/Best versus 0.737/0.751; on AIME it reached 38.89% Mean and 40.00% Best, exceeding the original ShinkaEvolve result of 34.4%.
- Ablations indicate that COAT is particularly useful for discovering strong solutions, while CausalPlanner improves early-stage efficiency. The full system is generally strongest, although Circle Packing shows weaker early performance.
Significance
The work changes evolutionary scientific agents from unguided trial-and-error systems into agents that actively formulate and test explanations. It addresses the efficiency decline, oscillation near performance boundaries, and poor reuse of historical knowledge observed in AlphaEvolve- and ShinkaEvolve-style systems. Theoretical analysis suggests causal structure can reduce sample complexity from O(K) to O(d log K), while the practical framework offers a mechanism for accumulating experimental knowledge.
Technical Contribution
The paper contributes a POMDP/SCM formulation of open-ended program discovery; outcome-level factors as controllable search coordinates; CausalPlanner with discounted reward Ra=(yc−τvt)+; COAT-based procedure-factor extraction and treatment-effect ranking; and surprise detection followed by LLM abductive reasoning. Unlike ShinkaEvolve's primarily correlational memory summaries, CausalEvolve explicitly links factors, interventions, outcomes, anomalies, and new experiments.
Novelty
The novelty lies in closing a factor–intervention–outcome–surprise–hypothesis loop inside evolutionary program search. The paper does not merely combine LLMs, evolution, and causal terminology; it operationalizes both outcome-level and procedure-level factors as guidance and memory. To the authors' knowledge, this is a systematic causal-scratchpad framework for open-ended scientific program discovery.
Limitations
- Procedure-level effects are vulnerable to small samples, hidden confounding, selection bias, and LLM misidentification. They are therefore useful mainly for ranking, not as reliable causal estimates.
- Evaluation covers only four tasks, one LLM, and three random seeds. Transfer to other models, budgets, domains, and physical experiments remains unestablished.
- Outcome factors require task-specific executable code; failures or unstable factor definitions may misdirect the evolutionary search.
Future Work
Future research should add uncertainty quantification, confounding control, randomized interventions, and real-world validation. Important directions include testing more LLMs and budgets, learning transferable factor libraries, integrating multimodal evidence and distribution shifts, and connecting the scratchpad to robotic laboratories.
AI Executive Summary
Large language models are beginning to act as experimental scientists. AlphaEvolve and ShinkaEvolve repeatedly generate, execute, and refine programs, but their search resembles climbing without a map: progress slows near known boundaries, successful ideas are revisited, and failed combinations are poorly explained.
CausalEvolve introduces a causal scratchpad. Before evolution, an LLM constructs outcome-level factors from task descriptions and program outputs. CausalPlanner treats each factor direction as an action and uses a multi-armed-bandit strategy to balance exploration and exploitation. During evolution, COAT extracts procedure-level factors from program designs and estimates their approximate treatment effects. When effects reverse or shift unexpectedly, an abductive-reasoning module asks what hidden factor could explain the anomaly and proposes a new experiment.
Using Grok-4.1-fast-reasoning and three seeds, CausalEvolve outperformed ShinkaEvolve on the main benchmarks. On Hadamard Matrix, final Mean/Best was 0.568/0.576 versus 0.521/0.540; on Second Autocorrelation Inequality, 0.793/0.809 versus 0.737/0.751. On the 2024 AIME, it achieved 38.89% Mean and 40.00% Best, compared with 34.44% and 36.67% for the baseline. The broader message is that stronger generation alone may not create autonomous science: agents also need structured, intervention-oriented memory. Yet the proposed factors are LLM-generated proxies, not guaranteed causal variables, so larger cross-domain studies and controlled interventions are still required.
Deep Analysis
Background
AI Scientist systems have expanded from literature review and hypothesis generation to executable program evolution. AlphaEvolve and ShinkaEvolve demonstrated that LLMs can search combinatorial, mathematical, and algorithmic spaces. However, their memories mostly summarize correlations and successful code, offering little explicit guidance about why an intervention worked or what should be tested next. This becomes especially damaging near local optima.
Core Problem
The paper models discovery as a POMDP: hidden state θsci is the scientific knowledge, action p is a candidate program, and observation y is its score. Evaluation is represented as F(p;θsci)=E[Y do(X=xp),θsci]. Under finite budgets, an agent must both optimize and learn mechanisms. Source-environment optimization may exploit spurious correlations, causing inefficient search and poor target-environment generalization.
Innovation
First, the causal scratchpad stores factors, interventions, outcomes, and explanations rather than undifferentiated history. Second, outcome-level factors compress program space into interpretable, executable descriptors and guide CausalPlanner. Third, procedure-level factors expose algorithmic design choices. Fourth, surprise detection treats reversed or shifted effects as evidence of hidden confounders, and abductive reasoning turns anomalies into testable hypotheses instead of simply discarding them.
Methodology
- �� Initialization: the LLM reads the task and output format, then writes factor names and executable mappings.
- �� Planning: A=∪m{(m,+1),(m,−1)}; historical programs are ranked by m×d and used as inspirations.
- �� Feedback: for child target yc and best-so-far vt, reward is Ra=(yc−τvt)+; random exploration lasts K iterations, followed by exploiting the best action for K iterations.
- �� Explanation: LLMs identify procedure-level factors; COAT estimates approximate average treatment effects.
- �� Revision: effect-sign inversions and magnitude shifts trigger abductive reasoning, generating candidate confounders and future interventions.
Experiments
The benchmarks are n=29 Hadamard Matrix, 256-step Second Autocorrelation Inequality, N=26 Circle Packing, and the 2024 AIME. The main baseline is ShinkaEvolve; CausalPlanner with ShinkaEvolve's meta-summary and COAT provide ablations. All methods use Grok-4.1-fast-reasoning and seeds 1–3. Mean and Best are reported at task-specific checkpoints: 20/40/80/100, 50/100/150/200, or 20/40/60/80 steps.
Results
CausalEvolve's final Hadamard scores were 0.568/0.576 Mean/Best, versus 0.521/0.540 for ShinkaEvolve. On Second Autocorrelation Inequality it achieved 0.793/0.809 versus 0.737/0.751. AIME performance was 38.89% Mean and 40.00% Best, compared with 34.44%/36.67%. Circle Packing reached 2.476 Mean and 2.564 Best, close to COAT's 2.456/2.568, showing that improvements are not uniformly strongest at every stage.
Applications
The framework suits executable, scoreable problems with extractable structural descriptors: combinatorial optimization, algorithm design, mathematical reasoning agents, machine-learning pipelines, and high-performance code search. Users need a reliable evaluator, executable factor mappings, and sufficient budget. In practice, it can reduce redundant candidates, preserve design principles, and make automated experiments more auditable.
Limitations & Outlook
The paper does not establish that LLM-generated factors are genuine causal variables; estimates may be distorted by hidden confounding, small samples, and adaptive selection. Four benchmarks, one model, and three seeds do not establish broad generality. Future systems should report uncertainty, randomize interventions, evaluate distribution shifts, measure LLM and execution costs, and validate hypotheses in physical or multi-environment experiments.
Plain Language Accessible to non-experts
Imagine a kitchen team trying to perfect a recipe. An ordinary evolutionary system randomly changes ingredients, cooking time, and presentation, keeping dishes that taste better. At first this works, but near the limit the cooks repeat the same changes and cannot tell what actually caused improvement.
CausalEvolve gives them an experimental notebook. It lists observable clues—sweetness, crispness, moisture, and density—and tests whether increasing or decreasing each clue helps. A planner records which direction usually works and chooses the next promising test. It also studies the cooking procedure: whether frying before boiling is better than reversing the order.
Most importantly, it investigates surprises. If adding sugar and lowering heat makes the dish worse, the team asks whether heat changes the sugar or whether the two actions conflict. The language model proposes an explanation and turns it into another test. In the paper, the recipe is a program, taste is the objective score, and the notebook is the causal scratchpad. It does not prove every explanation true, but it makes experimentation purposeful and cumulative.
ELI14 Explained like you're 14
Imagine a game where you must build the highest-scoring character. Each round you can change weapons, skills, or the order in which abilities are used. A basic bot tries random builds, keeps high scores, and throws away low scores. That works early, but near the top it may keep switching back and forth—like grinding the same level without learning why you lose.
CausalEvolve gives the bot a smart strategy notebook. It records not only which build scored well, but also speed, defense, range, skill combinations, and action order. CausalPlanner then asks: should we increase speed, decrease it, or test another feature? It is like choosing which upgrade experiment is most promising.
The coolest part is its reaction to weird results. Suppose more attack power plus more speed lowers the score. Instead of saying “bad build,” it asks whether the skills interfere or whether speed causes missed controls. The language model suggests a new idea and tests it later.
The paper tested matrix construction, function optimization, circle packing, and 2024 AIME math problems. AIME accuracy reached 38.89%, above ShinkaEvolve's 34.44%. So the bot is not merely trying more builds; it is learning rules about experiments. Still, its explanations are guesses, so they need careful checking!
Glossary
Causal scratchpad
A structured memory of factors, interventions, outcomes, and explanations. It converts past trials into guidance for future experiments.
The central memory mechanism of CausalEvolve.
POMDP
A decision process in which the true state is hidden and must be inferred through actions and observations. Here the hidden state is scientific knowledge.
Formalizes the discovery loop.
Structural causal model (SCM)
A causal representation consisting of a graph G, structural equations F, and exogenous-variable distribution PU. Interventions are written as do(X=x).
Defines θsci and the objective.
CausalPlanner
A planner that treats factor directions as actions and selects them through exploration and exploitation. Its reward is Ra=(yc−τvt)+.
Guides outcome-level evolution.
COAT
An LLM-assisted framework for extracting useful procedural factors from unstructured information. CausalEvolve uses it to rank approximate treatment effects.
Supports procedure-level analysis.
Abductive reasoning
Reasoning from an observation to a plausible explanation or hypothesis. It generates candidates for testing rather than proving causality.
Explains surprise patterns.
Open Questions Unanswered questions from this research
- 1 Do LLM-generated factors represent stable mechanisms or persuasive post-hoc stories? Randomized interventions, counterfactual tests, and cross-environment replication are needed.
- 2 Outcome factors are task-specific executable programs. It remains unclear whether factor representations can transfer across tasks or form a reusable library.
- 3 The accuracy–cost trade-off is unresolved: additional LLM calls and factor analysis may improve search, but the paper gives no systematic cost curve.
Applications
Immediate Applications
Algorithm and code search
Research teams can define executable factors for orthogonality, sparsity, runtime, or geometric structure. The agent can prioritize promising directions, preserve successful design patterns, and reduce redundant candidate programs, provided that execution and scoring are reliable.
Mathematical problem-solving agents
For AIME-like tasks, solution steps, verification routines, and answer formatting can become procedural factors. Agents can then identify which strategies improve correctness and stability instead of relying only on random prompt variation.
Long-term Vision
Autonomous scientific laboratories
A future system could connect the scratchpad to robots, sensors, simulators, and multiple environments. It would propose interventions, test mechanisms, preserve auditable evidence, and continuously refine scientific knowledge, although safety, cost, and causal validation remain major obstacles.
Abstract
Evolve-based agent such as AlphaEvolve is one of the notable successes in using Large Language Models (LLMs) to build AI Scientists. These agents tackle open-ended scientific problems by iteratively improving and evolving programs, leveraging the prior knowledge and reasoning capabilities of LLMs. Despite the success, existing evolve-based agents lack targeted guidance for evolution and effective mechanisms for organizing and utilizing knowledge acquired from past evolutionary experience. Consequently, they suffer from decreasing evolution efficiency and exhibit oscillatory behavior when approaching known performance boundaries. To mitigate the gap, we develop CausalEvolve, equipped with a causal scratchpad that leverages LLMs to identify and reason about guiding factors for evolution. At the beginning, CausalEvolve first identifies outcome-level factors that offer complementary inspirations in improving the target objective. During the evolution, CausalEvolve also inspects surprise patterns during the evolution and abductive reasoning to hypothesize new factors, which in turn offer novel directions. Through comprehensive experiments, we show that CausalEvolve effectively improves the evolutionary efficiency and discovers better solutions in 4 challenging open-ended scientific tasks.