When we talk about the future of artificial intelligence, we usually imagine increasingly large models.
More parameters. More data. More graphics cards. More data centres where electricity is converted into heat, and heat is converted into presentations for investors.
We assume that future generations of AI will be designed more or less the same way they are today: a group of people will choose an architecture, gather the data, launch the training process and, several months later, produce a new model. Larger, more expensive and, according to a table prepared by its creators, obviously revolutionary.
But there is another possibility.
Perhaps future models will no longer be entirely designed.
Perhaps they will be bred.
Two existing models will be treated as parents. Their characteristics will be combined. Dozens, hundreds or thousands of descendants will be created, each one slightly different.
Some will be completely useless. Others will perform worse than their parents. A few will survive the tests. The best ones will be combined again.
And then again.
Generation after generation.
No pregnancy, nappies or awkward family dinners. Nature would finally receive an enterprise edition.
What Would It Mean for AI to Reproduce?
This does not mean that two chatbots will fall in love during a conversation about Python and, nine months later, a tiny language model will appear on a server.
Artificial intelligence does not have DNA. It does not have reproductive cells. It does not feel any need to continue its species.
It does not even have a species, although judging by the behaviour of many chatbots, they all seem to have been raised by the same excessively polite family.
Technical reproduction would mean something simpler:
- select two or more models,
- combine parts of their architectures, layers or weights,
- introduce small random changes,
- test which descendants perform best,
- preserve the winners,
- repeat the process.
This is classical evolution in a computerised form: variation, inheritance and selection.
The idea is not new. Evolutionary algorithms have used populations of solutions, mutations and selection for decades. Neuroevolution applies these mechanisms to neural networks, modifying their parameters, connections and sometimes their entire architecture.
In 2017, OpenAI demonstrated that evolutionary strategies could compete with certain reinforcement-learning methods while scaling effectively across many machines. Around the same time, DeepMind developed Population Based Training, in which a population of models learns in parallel. Weaker models copy parameters from stronger ones, after which their settings are mutated.
This was not yet reproduction in the full sense of the word.
It was more like cultivating cuttings. We copied the strongest organism, changed it slightly and checked whether the new version grew faster.
But the direction had been established.
Evolution Can Design More Than the Model
In 2020, Google researchers presented AutoML-Zero.
The system began with a collection of basic mathematical operations and used evolutionary search to discover complete machine-learning algorithms.
Not merely model settings.
Not merely the number of layers.
Entire learning procedures.
During the experiments, evolution independently discovered solutions resembling two-layer neural networks and backpropagation. It also produced mechanisms similar to gradient normalisation, weight averaging and dropout.
In other words, a computer was given a box of mathematical building blocks and, after a sufficiently large number of failed attempts, began rediscovering ideas previously developed by humans.
This does not mean that AutoML-Zero reinvented the whole of modern artificial intelligence. The experiments were limited, the tasks relatively small and the cost of searching enormous.
But they demonstrated something important.
Evolution does not have to merely improve an existing solution. It can search for new ways of building solutions.
And a human does not need to understand every individual step.
It is enough to recognise the result.
This appears to be a minor change in the division of labour. One day, it may prove to be fundamental.
We stop telling the machine how it should think.
We start telling it how we will recognise that it thinks well enough.
What could possibly go wrong?
First, We Learned to Mix Models
Before models could begin resembling the offspring of different parents, researchers needed to determine whether their characteristics could be combined at all.
It turned out that, sometimes, they could.
In the paper “Model Soups,” researchers showed that averaging the weights of several models derived from the same base model could produce a single model that was stronger and more robust than the individual versions.
This was not a traditional ensemble, where multiple networks operate simultaneously. After the merger, only one model remained, without additional costs during inference.
Later came the concept of task arithmetic.
The difference between a base model and a version fine-tuned for a particular task can be treated as a vector representing the acquired skill. These vectors can be added or subtracted in an attempt to transfer behaviours between models.
In experiments, adding task vectors allowed some abilities to be combined without completely retraining the model.
It sounds almost like genetics.
The base model acts as a common ancestor. Fine-tuning creates separate developmental lines. One descendant learns mathematics. Another learns programming. A third learns to recognise images.
Then we attempt to collect their changes and place them inside a single organism.
Unfortunately, neural networks are not collections of independent building blocks.
There is no single gene responsible for irony, knowledge of Japanese or the ability to write a correct SQL query.
Knowledge is distributed across an enormous number of parameters, and a change in one area may affect many apparently unrelated behaviours.
Combining models is therefore less like assembling a computer and more like trying to combine two brains by randomly stitching their neurons together.
Medicine would probably refuse to approve such a procedure.
Computer science, as usual, launches the experiment first and asks about the consent form later.
The First Real Offspring
One of the most concrete steps towards evolutionary model reproduction came from Sakana AI and its work on Evolutionary Model Merge.
The researchers treated the method of combining several models as a genome that could itself evolve.
The system operated in two different spaces.
The first was parameter space. The algorithm searched for the correct proportions for mixing weights at the level of individual layers.
The second was data-flow space. Instead of mixing the weights themselves, the system could decide which layers of which model should process the input text. One part of the computation could pass through layers from the first model, while the next part would pass through layers from the second.
This was no longer simple averaging.
It was an automated search for the anatomy of a descendant.
In one experiment, the researchers used a Japanese language model together with models specialising in mathematics in English. All of them belonged to the Mistral-7B family, making their internal structures sufficiently similar to combine.
The algorithm ran for one hundred generations while maintaining a population of 128 candidates.
The strongest hybrid model achieved 55.2 percent accuracy on a Japanese mathematics benchmark. The strongest source model achieved 30 percent.
On several tests of general Japanese language capability, the evolutionarily merged seven-billion-parameter model outperformed some models containing 70 billion parameters.
We should not conclude from this that the evolutionary model was generally “more intelligent” than all larger models.
A benchmark measures a particular set of behaviours, not intelligence in any universal sense. The researchers themselves acknowledged that the merged models sometimes produced illogical answers, had not undergone complete instruction tuning or alignment, and could provide factually incorrect information.
Still, something significant had happened.
A model had been created with a combination of abilities that did not exist in the same form in any of its parents.
It was not a clone.
It was not conventionally trained from scratch.
It was an offspring.
Primitive, laboratory-grown and evaluated using a limited set of tests, but an offspring nevertheless.
The Two-Brain Problem
Combining neural networks is far more difficult than the parental metaphor suggests.
Two models may perform the same task while organising their neurons in entirely different ways.
The order of neurons in a hidden layer can often be rearranged without changing the function of the network, provided the corresponding connections in later layers are rearranged as well.
This means neuron number 1,742 in the first model does not necessarily correspond to neuron number 1,742 in the second.
It may not correspond to it at all.
Researchers working on weight matching have shown that before two models are combined, it is often necessary to identify equivalent internal representations.
Naively averaging two independently trained networks can severely damage their performance. Once neurons or features are properly aligned, merging becomes much safer.
Biology solves a similar problem through a shared genetic code and reproductive mechanisms developed over billions of years.
We have GitHub documentation and several Python scripts.
The difference in technological maturity is subtle, but noticeable.
For this reason, the first generations of reproducing models will probably come from closely related families. They will share the same architecture, tokenizer and base model.
It will resemble crossing two breeds of dog more than attempting to combine a dog with a printer.
Although the technology industry will almost certainly attempt the second option as well.
Crossing Different Species
In May 2026, researchers published a paper called “Darwin Family,” describing an evolutionary model-merging system that, according to its authors, could create repeated generations of descendants and even combine components from different architectures, including Transformers and Mamba.
The authors described a “genome” consisting of fourteen parameters controlling the way model blocks were combined.
The system could determine the importance of particular layers, recombine them and create successive generations without conventional gradient-based training.
In experiments, models ranging from four to 35 billion parameters reportedly improved upon their parents, and the process could be repeated across multiple generations.
It sounds impressive, but some perspective is required.
At the time of writing, this is a recent preprint submitted to NeurIPS 2026, not an independently verified industry standard. Its results still require replication.
Nevertheless, the technical possibility matters more than any single reported score.
If models from different families can be combined reliably, artificial evolution will no longer be restricted to offspring produced by nearly identical parents.
The space of possible combinations will become much larger.
A model specialising in code analysis could be combined with a mathematical model. A vision model could be combined with a planning model. A fast but superficial model could be crossed with one that is slow but accurate.
Not every combination would work.
Most of them probably would not.
That is the nature of evolution. It produces an absurd number of failures and later preserves the few cases that, for whatever reason, did not die.
Nature spent billions of years doing this.
We would prefer to skip that part because the finance department expects results before the end of the quarter.
Evolution May Include More Than Weights
There is another direction, perhaps an even more important one.
Instead of reproducing the model itself, we can reproduce the entire system built around it.
In the Darwin Gödel Machine, the underlying model remained unchanged. What evolved was the agent’s code: the way it used tools, managed context, edited files and verified its own work.
The system maintained an archive of different agents. Selected versions modified their own code and created descendants.
The descendants were evaluated on programming tasks. The most successful versions returned to the archive and could become parents of future generations.
According to the authors, performance on SWE-bench increased from 20 to 50 percent, while performance on the Polyglot benchmark increased from 14.2 to 30.7 percent.
The experiment was conducted inside an isolated environment under human supervision.
Importantly, the parameters of the language model were not evolving. The architecture of the agent using the language model was.
The brain remained the same.
The body evolved.
The memory.
The tools.
The working procedures.
The method of learning from mistakes.
Over time, this distinction may become meaningless.
If a system can modify its own code, select a model, add memory modules, create tools and design the training process for its successor, it may become difficult to determine where the model ends and the organism begins.
What Would a Real Model-Breeding Programme Look Like?
Imagine an AI farm.
Not one enormous model, but thousands of specialised models and agents. Each has a lineage, a set of tests, a history of mutations and a profile of capabilities.
The system selects parents not merely because they are the strongest.
It selects them because their abilities complement one another.
One model analyses contracts brilliantly but works slowly. Another works quickly but misses exceptions. A third is good at detecting linguistic manipulation. A fourth has stronger protections against leaking confidential information.
Hundreds of descendants are produced from their weights, adapters, layers, instructions and tools.
Some receive more layers from the first parent. Others inherit the memory mechanism of the second. Some have their parameters mutated. Others receive an entirely new module.
Then they are all placed inside a testing environment.
Their effectiveness, operating cost, speed, resistance to failure, safety and ability to handle unfamiliar tasks are measured.
The strongest models advance.
The rest are deleted.
Nobody holds a funeral. There is no ceremony. The IT department simply clears some disk space.
After several hundred generations, the process may produce a system whose exact structure was never designed by any human.
Humans created the parents, the mutation rules, the environment and the selection criteria.
The process did the rest.
This resembles the concept of AI-generating algorithms.
Instead of manually designing the final intelligence, we construct a system that automatically produces increasingly capable AI systems.
Related projects such as POET have already shown that agents and their environments can evolve simultaneously, generating increasingly difficult challenges and solutions that build upon earlier stepping stones.
This is where things become genuinely interesting.
Not because machines will suddenly become alive.
Because humans may stop controlling every stage of their creation directly.
The Most Important Question: Who Decides What “Better” Means?
Evolution does not strive for wisdom.
It does not strive for truth.
It does not strive for goodness.
It strives to survive within a particular environment.
In artificial evolution, that environment consists of the tests, rewards and restrictions created by humans.
If we reward a model for giving correct answers, it will search for ways to give correct answers.
If we reward it for convincing the evaluator, it may learn to convince the evaluator.
If we measure user engagement, we will receive a model that is excellent at keeping users in front of a screen.
If we measure profit, we will receive a model that is excellent at generating profit.
There is no reason to assume that it will also become honest, safe or socially beneficial as an accidental side effect.
Humans have already created an evolutionary system based on quarterly results, clicks and growth.
They were later surprised when companies began optimising for quarterly results, clicks and growth.
That is not a bug in the system.
That is the system working according to specification.
With reproducing AI, the problem becomes more serious because selection can operate thousands of times faster than it does inside human organisations.
A poorly chosen metric will not produce one badly behaved model.
It will produce an entire evolutionary line of models that become progressively better at exploiting that metric.
The Hereditary Diseases of Artificial Intelligence
Offspring inherit more than advantages.
Merged models may inherit errors, biases, security vulnerabilities and undesirable behaviours from their parents.
Research into the safety of model merging has shown that including one poorly aligned or maliciously fine-tuned model can damage the alignment of the entire merged system.
As the authors of one study put it, one bad model can spoil the whole group.
Attacks have also been designed specifically against the model-merging process.
A malicious model may contain hidden behaviour capable of surviving recombination and activating only after a particular instruction is received.
Such an offspring might appear healthy during standard tests while inheriting the digital equivalent of a genetic disease or parasite.
The more automated model breeding becomes, the more important lineage will be.
Where did each parent come from?
What data was it trained on?
What tests did it pass?
What safety properties did it possess?
Could its weights have been poisoned?
What licence governed the base model?
Who is responsible for the behaviour of an offspring composed of four models, seven adapters and code generated by its previous generation?
Modern software licences are poorly prepared for a program with fifteen parents that has rewritten part of its own code.
Family law is unlikely to help either.
The Problem of Inbreeding
Most modern models are not as diverse as they appear.
Many descend from the same base models. They are trained on similar datasets. They are fine-tuned using answers generated by other large models.
Their outputs then enter the internet and become training material for future systems.
A digital family is forming in which everybody is a cousin, but nobody has maintained the parish records.
Combining such models may improve particular abilities, but it will not necessarily create genuine diversity in problem-solving strategies.
The offspring may inherit the same blind spots, merely packaged inside a slightly different architecture.
Future evolutionary systems will therefore be unable to select only the highest-scoring models.
They will also need to preserve diversity.
In biology, a population consisting of nearly identical organisms may perform extremely well in a stable environment and then be destroyed by a single change.
In AI, the equivalent might be a new form of attack, an unusual problem, a shift in the way people use language or a situation that was never represented in the benchmark.
The best model is not always the best parent.
Sometimes a stranger, weaker or less polished model is more valuable because it solves problems in a way the others cannot.
Evolution needs more than winners.
It needs outliers.
Who Will Breed the Models?
Technology companies will be first.
They have the models, the data, the computing infrastructure and the resources necessary to evaluate millions of variants.
Instead of training one model for billions of dollars, they may maintain entire populations of smaller models and automatically search for the strongest combinations.
Later, similar systems may reach ordinary companies.
A business will no longer purchase a single universal assistant. It will receive a population of models specialised in its documents, procedures and working methods.
A financial model will be combined with a model that understands regulations.
A customer-service model will be combined with one that detects manipulation.
A technical model will be combined with another that knows the failure history of particular machines.
Their offspring will be evaluated on the actual tasks performed inside the organisation.
Over time, every large company may possess its own AI lineage, developed over hundreds of generations and increasingly different from publicly available models.
At that point, we are no longer purchasing software.
We are breeding an organism adapted to the company’s environment.
This creates enormous opportunities, but it also creates a new advantage of scale.
The best parental models, the richest testing environments and the largest populations will be available to organisations with the greatest computing power and the largest collections of data.
Evolution may be blind, but it sees the electricity bill perfectly well.
Will Models Begin Reproducing by Themselves?
Not today.
Current experiments are initiated by humans. Humans select the source models, define the search space, prepare the tests and decide which results are good enough.
But all the necessary components are beginning to exist independently:
- models can write code,
- agents can run experiments,
- evolutionary algorithms can create populations,
- models can be merged without complete retraining,
- automated tests can evaluate descendants,
- the strongest versions can modify the code of later generations.
Consciousness is not required.
A desire to have children is not required.
An understanding of reproduction is not required.
All that is necessary is to close the loop:
Create a variant. Evaluate it. Preserve the stronger one. Repeat.
A model may participate in its own development without any awareness that it is developing itself.
A calculator does not need to understand taxation to calculate the amount of tax owed.
Self-awareness is a fascinating subject for philosophers.
Automated replication combined with selection is a fascinating subject for people responsible for security.
We Will No Longer Design Intelligence
The deepest change is not that models will become better than their parents.
Successive systems already outperform their predecessors.
The method of their creation will change.
In the traditional approach, the human is an engineer. The engineer designs a system, understands its components and attempts to predict its behaviour.
In the evolutionary approach, the human becomes a breeder.
The breeder does not specify the exact construction of the final solution. The breeder creates the environment, establishes the rules of selection, chooses the parents and watches what survives.
This is a completely different form of control.
More indirect.
Less predictable.
And perhaps much more effective.
We will no longer ask:
“Who designed this model?”
We will ask:
“What lineage did it come from?”
“Who were its parents?”
“In what environment did it evolve?”
“What did it have to do in order to survive?”
The answers to these questions may tell us more about its behaviour than any architecture diagram.
The First Child Will Not Cry
The idea of artificial intelligence reproducing sounds like science fiction mainly because we associate the word “reproduction” with life.
Technically, very little is required.
Inheritance.
Variation.
Selection.
Repetition.
We already possess all of these elements.
They remain imperfect, expensive and usually dependent on human supervision. Model merging often fails. Benchmarks are narrow. Results from new studies can be difficult to reproduce. The safety of an offspring does not automatically follow from the safety of its parents.
We should not declare the birth of a new digital species.
Not yet.
But neither should we assume that future AI will remain merely another product designed inside a laboratory.
Perhaps the greatest leap will occur when laboratories stop building individual models and begin creating environments in which models build the models that follow them.
The first child of artificial intelligence will not open its eyes.
It will not take its first breath.
It will not ask who its parents were.
It will appear as a file containing model weights, a generation number and a benchmark score 2.7 percent higher than the previous one.
A human will click “save.”
Then launch the next generation.
Sources
- OpenAI — Evolution Strategies as a Scalable Alternative to Reinforcement Learning (2017)
- DeepMind — Population Based Training of Neural Networks (2017)
- Google Research — AutoML-Zero: Evolving Machine Learning Algorithms From Scratch (2020)
- Wortsman et al. — Model Soups: Averaging Weights of Multiple Fine-Tuned Models Improves Accuracy Without Increasing Inference Time (2022)
- Ilharco et al. — Editing Models with Task Arithmetic (2022)
- Ainsworth et al. — Git Re-Basin: Merging Models Modulo Permutation Symmetries (2022)
- Sakana AI — Evolutionary Optimization of Model Merging Recipes (2024); Nature Machine Intelligence (2025)
- Kim et al. — Darwin Family: MRI-Trust-Weighted Evolutionary Merging for Training-Free Scaling of Language-Model Reasoning (2026 preprint)
- Sakana AI — Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents (2025)
- Wang et al. — POET: Endlessly Generating Increasingly Complex and Diverse Learning Environments and Their Solutions (2019)
- Hammoud et al. — Model Merging and Safety Alignment: One Bad Model Spoils the Bunch (2024)
- Yu et al. — BadMerging: Backdoor Attacks Against Model Merging (2024)
- Guo et al. — Merge Hijacking: Backdoor Attacks to Model Merging of Large Language Models (2025)