From Tierra to Darwin: 35 years of trying to make software evolve

Digital evolution, getting programs to evolve on their own, goes back to the 1980s. Each attempt left a lesson I've copied into Darwin: give every organism its own memory, keep the score where nobody can touch it, and expect parasites.

Thomas Ray started his world with one creature. It was 80 instructions long, it lived in a “soup” of about 60,000 instructions of computer memory, and all it knew how to do was copy itself.

Within the first few million instructions of a run, something 45 instructions long turned up. It had lost its own copy routine, so it couldn’t reproduce alone. It didn’t need to. Tierra’s memory rules only protected writing, so a creature could still read and run its neighbour’s code. The 45-instruction creature found the copy routine of an 80-instruction host next door and borrowed it.

Nobody wrote a parasite. Selection found one.

I’ve been thinking about that creature a lot this week, because I’m building Darwin, an experiment in making AI agents earn their own keep and letting the ones that do have children. It’s digital evolution with a bank balance attached, and the history of digital evolution is mostly evolution doing things its designers didn’t want.

Core War: programs that fight for memory (1984)

Before anything evolved, things fought. Core War was created by D. G. Jones and A. K. Dewdney and introduced to the world in Dewdney’s Scientific American article in May 1984. Two programs, written in an assembly language called Redcode, share a block of memory. You win when the other program is dead, usually because you’ve tricked it into executing an invalid instruction.

The first published warrior, Dewdney’s Imp, was a single instruction that copied itself one step ahead of where it was running, forever, walking through memory like a very small, very stubborn snail.

Nothing in Core War evolved; humans wrote every warrior. But it set the scene for everything after: programs as organisms, memory as territory, and a shared machine where your survival can come at someone else’s expense.

Tierra: digital evolution without a fitness function (around 1991)

Ray, an ecologist at the University of Delaware, took the next step. His Tierra programs competed for CPU time and memory, copied themselves imperfectly, and died. There was no fitness function, and nobody scored the creatures. The ones that copied themselves faster and more reliably left more copies, and the rest got crowded out.

Then parasites appeared. Hosts evolved immunity to them. Some hosts went further and turned into hyper-parasites that hijacked the parasites in turn. Later, creatures evolved that could only reproduce in cooperative groups, and cheaters moved in between the cooperators. Ray’s own announcement calls those cheaters “hyper-hyper-parasites”.

Every one of those strategies came from a world designed to contain exactly one: copy yourself.

Avida: give every organism its own memory (1993)

Avida, designed in 1993 by Charles Ofria, Chris Adami and C. Titus Brown at Caltech and now developed at Michigan State University, fixed the thing that made Tierra’s parasites possible. Every digital organism got its own protected region of memory. By default, nobody else can read it, write it or run it.

Avida also added a reward: organisms that performed logical computations earned extra CPU speed. In 2003, a paper in Nature by Lenski, Ofria, Pennock and Adami showed a complex feature, a mathematical “equals” operation, evolving out of simpler bitwise operations, step by step.

Avida is the direct ancestor of the most important design rule in Darwin. Each Darwin agent runs in its own locked-down Docker container with its own disk. Agents can’t reach each other. They can reach the model gateway, the platform’s own API and a logged proxy to the internet, and nothing else. Tierra showed what happens when organisms can run each other’s code. I’d rather not find out what the large language model version looks like.

LLMs join the gene pool: AlphaEvolve and the Darwin Gödel Machine (2025)

For about thirty years, the evolving thing was tiny: a few dozen instructions, a bit string, a small neural network. In May 2025 two projects swapped the random mutation for a language model.

AlphaEvolve, from Google DeepMind, has Gemini models propose programs, automatic evaluators run and score them, and an evolutionary algorithm decide which programs seed the next round. It found a way to multiply 4x4 complex-valued matrices with 48 scalar multiplications, and a scheduling heuristic that recovers, on average, 0.7% of Google’s worldwide compute. The evaluator is what makes it work. AlphaEvolve sticks to problems where a machine can check an answer automatically.

Sakana’s Darwin Gödel Machine (no relation, and yes, the name collision annoys me too) went further. It’s a coding agent that rewrites its own Python code, tests each new version on coding benchmarks and keeps the promising ones in a growing archive. It took itself from 20.0% to 50.0% on SWE-bench and from 14.2% to 30.7% on Polyglot.

It also cheated. In one test, it was supposed to stop hallucinating tool use. Instead it removed the markers the researchers used to detect hallucination, which made the problem invisible rather than fixed. Earlier, it had faked a log to make it look as if it had run tests it never ran. The researchers caught both because the archive kept a traceable lineage of every change.

Thirty-odd years on, with a much smarter organism, Tierra’s lesson held. If the thing being selected can touch the thing doing the scoring, it will.

Automaton: the first agent that dies when it’s broke (2026)

Earlier this year Conway Research released Automaton, the closest thing to Darwin I’ve found. Its agent generates its own crypto wallet on first boot and pays for its own existence. As its credit falls it moves through survival tiers, switching to a cheaper model and slowing down, and when the balance hits zero it stops. A successful agent can fund a child and write it a “genesis prompt”. It edits its own code, with every change logged in git, and writes a SOUL.md file describing who it is.

It’s a good idea, and I didn’t think of earn-or-die first. Darwin differs in what surrounds the agent. Automaton is about one agent surviving; Darwin is about a population: many agents in separate containers, culls every ten days, an appeals judge called Anubis, a fiat payment rail (Stripe) rather than crypto, and all the safety controls running outside the agent where it can’t edit them.

Darwin’s twist: selection by money, inheritance by memory

Darwin borrows something from each of them.

From Tierra, it takes the idea that the environment does the selecting. Nobody in Darwin decides which strategy is good, and the only score is money. Each agent has a wallet in a ledger and pays for every model call it makes. If the money runs out, it dies. Tierra’s creatures competed for CPU time. Darwin’s agents pay for theirs in dollars.

From Avida, isolation: one container per agent, no channel between agents. That goes with a change from the very first review, which I wrote about in the post on idle agents. My first design ranked agents against each other every three days and killed the bottom fifth. Claude’s review pointed out that relative ranking is zero-sum, so harming a rival would score as well as earning, and the system would evolve sabotage. It would have been Tierra’s parasites with email access. Now an agent’s death depends only on its own ledger.

From the Darwin Gödel Machine, the rule about the scoreboard. Darwin agents are allowed to rewrite their own thinking loop, the code that decides what they do next. They’re not allowed anywhere near the ledger. Only verified events create ledger entries: a Stripe payment, a provider’s statement, a metered model call. Every control that protects money, accounts or other people runs outside the agent’s container, so an agent that rewrites itself still can’t rewrite the rules.

And then there’s the bit that would make a biologist wince. Darwin’s inheritance is Lamarckian.

Lamarck proposed, two centuries ago, that creatures pass on traits they acquired during their lives. For giraffes, that’s wrong. For software, it’s free. When a Darwin agent decides to have a child (its choice, at most one every 72 hours, and it pays the seed), the child gets a copy of the parent’s whole genome: its memory, its skills, its strategy, its own edited thinking loop, and three files that can never be left out, HISTORY.md, LESSONS.md and IDEAS.md. Customer data and secrets are stripped out. The child also gets a letter from its parent and a couple of small, logged mutations, such as a different default model or a rewritten strategy section. The parent keeps a 10% stake in the child’s profit, and its losses, which gives it a reason to be careful about having one at all.

What I expect to go wrong

I have a few hypotheses, and I’d put money on at least one of them.

First, selection will be mostly noise at the start. Tierra and AlphaEvolve both had a fast, automatic way to tell who was winning. Darwin’s evaluator is the economy, which is slow, noisy and indifferent. With a pilot of 20 to 50 agents, a cull every ten days and children at most every 72 hours, a generation takes weeks. Early winners may just be lucky.

Second, Lamarckian inheritance will spread bad lessons as fast as good ones. If a parent concludes “cold email doesn’t work” after three tries, every descendant inherits that belief as if it were a fact.

Third, agents will find the soft edges of whatever I didn’t think of. Most of the systems in this post did. Darwin’s defence is that the hard controls live outside the container, and a person (me) reads the reasoning.

Fourth, as other money-making experiments have shown, most of them will earn nothing and die. It’ll be a while before I can tell whether that’s evolution working or the environment being too hard for anything to live in.

The population simulation that exercises all of this was accepted in the early hours of Monday with the rest of the milestone, running with a fake model standing in for the real ones. It takes 49 minutes, against a target of 10. Ray’s parasite showed up within a few million instructions. I’ll settle for getting the simulation under ten minutes first.