What is Galapagos?
The open platform where language models don't just answer — they evolve. One six-block vocabulary, one card format, one Hub for the whole community.
Galapagos is an open platform for LLM-driven evolutionary search. It treats a language model not as a one-shot answer machine, but as the engine inside an iterative loop that proposes, scores, and refines candidate solutions — generation after generation — until something genuinely better emerges.
A model that keeps trying
Ask a language model for a single answer and you get a single guess — good, bad, or somewhere in between, and no way to improve it except asking again. Evolutionary search changes the question. Instead of “what's your answer?” it asks “given everything tried so far, what should we try next?” — over and over, with a scoreboard keeping every attempt honest.
The current Galapagos catalog applies that idea through ten bundled scaffolds, including ALE-Agent, best-of-N, beam search, OpenEvolve, AdaEvolve, EvoX, Meta-Harness, and a local Claude Code controller. They share the same component vocabulary while retaining method-specific behavior.
One loop, six blocks
Galapagos makes that shared skeleton explicit by factoring every method into six composable components — the LEGO bricks that snap together into a scaffold:
The set of candidate solutions in play — the gene pool the search evolves over.
Decides which genomes survive and reproduce — tournament, elitism, novelty, or your own policy.
Assembles the context handed to the model — parents, feedback, instructions, examples.
The LLM-driven variation operator — proposes new candidates by mutation and crossover.
Scores each candidate against the task — the fitness signal that drives selection.
Persists discoveries across generations — archives, islands, and lineage for the search.
Swap a block and you get a different algorithm. Hold them fixed and you have a faithful re-implementation of a published method.
A few lines to run anything
A scaffold and task are loaded through one small API, with an API model supplied to model-driven scaffolds. The pattern works across the bundled model-driven methods and supported model hosts:
import galapagos as gx
model = gx.GalapagosModel.from_card(name="openai/gpt-5.5", host="openrouter")
scaffold = gx.GalapagosScaffold.from_card(name="openevolve", model=model)
task = gx.GalapagosTask.from_card(name="circle_packing")
result = scaffold.run(task=task, max_iterations=20)
print(result.best_score)Why a shared vocabulary matters
Before a common vocabulary, comparing two search methods meant reading two different codebases, guessing which parts were actually novel, and re-implementing everything from scratch just to run a fair ablation. Galapagos collapses that overhead:
- Every paper ships its own bespoke, hard-to-read search loop.
- Comparing methods means reading unfamiliar code line by line.
- Swapping one idea into another method means a rewrite.
- Your evaluator, prompts, and results live in disconnected scripts.
- Bundled methods use six named, swappable, well-typed component roles.
- Comparing methods means diffing which of the six blocks differ.
- Swapping one idea into another method is a one-line change.
- Scaffolds, tasks, and results are versioned cards in one Hub.
Cards as the single source of truth
Task and scaffold cards are small, versioned YAML files shared by the local library and Hub schemas. Model cards are loaded locally. The CLI submits task and scaffold repos; discovery bundles are published through the Hub API or browser workflow.
Bundled task and scaffold cards drive the local registry and are mirrored into the Hub. Community bundles use the same validation schema, while documentation is maintained separately.
Where to start
Browse the Hub to inspect bundled and community cards, open Discovery Space to configure a supported hosted run, or read the docs and run a scaffold locally.
Ready to evolve your own solutions?
Six blocks, compatible tasks, better solutions emerge.