AI can now self-replicate
Steve Sperandeo ·

Watch the forty-seven-minute film

AI can now self-replicate. Not the way films imagine it, with a program escaping into the wild, but in the ways that matter to a business. Agents design other agents. Models write the training data and the tests that other models learn from. Search finds designs that people missed. Teams of agents divide work, hand it to each other, and check each other's results. The hard part was never the copying, or even the changing. The hard part is choosing what to keep. Whoever owns the place where this happens, the tests the results are scored on, and the final say over what is kept, owns what grows there.
I started thinking about this after Eric Weinstein's interview on The Diary of a CEO this October. He made a point I haven't been able to put down. A car, he said, has a version of nearly every system a body has: a brain, a digestive system, a skin, a skeleton. It doesn't have a reproductive system. "Humans don't know how to make a pen that makes more pens or a cup that makes more cups. The only thing that we seem to know how to do that with is software."1
That sentence holds a question every leader in AI should be able to answer. If software can make more software, and AI is software, what happens when AI makes AI? Is it a threat, a tool, or both? And if it is a tool, what does it take to use it well?
This is a long article, in twelve chapters. Each answers one question, and together they make one argument. It is a hopeful argument, because the evidence is hopeful. AI that builds AI is already useful, it is already measurable, and the conditions that make it work well are ones a company can own.
Contents
- What does it take for something to evolve?
- Can AI copy itself?
- Can AI improve AI?
- How wide should the search be?
- Why many small models instead of one big one?
- Can specialists be combined?
- How should a team of agents be organized?
- How do agents talk to each other?
- Who chooses what survives?
- What happens when learning and doing meet?
- What does a good dish look like?
- What should you do on Monday?
What does it take for something to evolve?
Weinstein's next step is the one that matters. Life, he said, isn't defined by carbon, or by nucleotides, or by amino acids. "For evolution to operate, you need heritability, passing on your stuff to the next form of life, variation ... and differential success." Any system with those three things will evolve, and "a computer program is such a thing."1
Biologists have said the same for half a century, in nearly the same words. In 1970 Richard Lewontin set out three principles: individuals in a population differ in their form, physiology, and behavior; different forms survive and reproduce at different rates; and offspring resemble their parents in what makes them fit.2 Darwin had put the selecting step in one line: "This preservation of favourable variations and the rejection of injurious variations, I call Natural Selection."3
None of those principles mentions cells. They describe a process, and a process can run on a computer. It has, for more than thirty years. In 1990 the ecologist Thomas Ray seeded a virtual computer with a single self-copying program of 80 instructions and let it run. Copying errors made variants. The variants competed for memory and processor time. Within hours the soup held shorter copiers, parasites that borrowed other programs' copying code, some hosts that resisted the parasites, and parasites of the parasites.4 Nobody designed any of them.
A later system, Avida, showed something more useful for anyone building with AI. Its digital organisms could earn extra processor time by computing logic functions. In 2003 a team from Michigan State and Caltech asked whether a complex function, called EQU, could evolve at all. It did, in 23 of 50 populations, but only when the simpler functions along the way were also rewarded. When they weren't, it evolved in none of 50.5 Complex things were reached by stepping stones, and the stepping stones had to pay.

Keep that result in mind, because it runs through this whole article. Heritability is cheap in software: a copy is exact, and a file can be kept forever. Variation is cheap too: a model can propose a thousand changes before lunch. The third condition is the one that decides what you get. Differential success means something is doing the judging. In nature, the judge is survival. In a company, the judge is whatever you choose to measure, and whoever gets to decide.
So AI that builds AI meets two of Weinstein's conditions in abundance, and the third is a design decision. That is good news. It means the outcome is something we can shape.
It helps to translate the three conditions into the language of an ordinary AI team, because every team already has all three, whether it calls them that or not.
- Heritability is version control. A model, a pipeline, or an agent is saved, and the next version starts from it. What worked is passed on.
- Variation is experimentation. A team tries a different feature, a different model, a different prompt, a different way of splitting the work. Most of the variants are worse. A few are better.
- Differential success is evaluation and promotion. Someone measures the variants, keeps the best, and puts it into service. The others are retired.
What changes when AI builds AI is the speed of the middle step. A person might try five variants in a week. An agent can try five hundred. The first condition was already cheap, and now the second is too. That leaves the third condition carrying all of the weight, which is why it gets its own chapter later on.
Can AI copy itself?
Start with the headline that worries people most. In December 2024 researchers at Fudan University reported that two open models, given a computer, their own files, and an instruction to replicate, made a working, separate copy of themselves in five and in nine of ten trials.6 It is a real result, and it is easy to read too much into it. The models were told to do it, on a machine prepared for the job, with everything they needed in reach.
Government evaluators have looked at the harder version: an AI that copies itself without help, acquires the computing power to run on, and keeps running. The UK's AI Security Institute built a benchmark for exactly this, RepliBench, with 20 families of tasks and 86 tasks in all. Models were getting better at the parts. But the institute's conclusion was plain: current models "do not currently pose a credible threat of self-replication."7 They struggled with the steps that the real world puts in the way, such as passing identity checks and staying deployed.
Meanwhile, the useful kind of copying is ordinary, and it is everywhere. A software repository keeps every version. A container image runs the same way on any machine. A model checkpoint can be reloaded years from now. In Orama Lake, every saved definition of an agent is kept as a revision, and any agent can be duplicated to start a new one.8 That is heritability, and nobody calls it frightening. It is how engineers avoid losing their work.
It's worth being precise about what "a copy" of an AI system even is, because it is more than a model. A working AI system is the model's weights, the code that runs it, the data it reads, the tools it may call, and the machines it runs on. Copying the weights is a file transfer. Copying the whole working system means rebuilding its environment, its permissions, and its connections, which is exactly the work that well-run engineering teams automate, so that a system can be rebuilt from what is written down. Reproducibility is a virtue in engineering long before it is a worry in science fiction.
Copying was never the hard part. Changing well is.
Can AI improve AI?
The idea is older than most people think. In 1965 the statistician I. J. Good, who had worked with Alan Turing, wrote that "an ultraintelligent machine could design even better machines; there would then unquestionably be an 'intelligence explosion.'"9 For decades it stayed an idea. Now there are measured results, and they are narrower and more interesting than the explosion Good imagined.
Machines that improve algorithms. In 2023 DeepMind's FunSearch paired a language model with an automatic evaluator. The model proposed programs; the evaluator scored them; the best were kept and varied again. It found new constructions for a problem in combinatorics, the cap set problem, beyond what mathematicians had found.10 Its successor, AlphaEvolve, found a way to multiply two four-by-four complex matrices with 48 multiplications, improving on Volker Strassen's 1969 method among algorithms that can be applied recursively to larger matrices. It also sped up a kernel used to train Google's own Gemini models by 23 percent on average, cutting Gemini's overall training time by 1 percent.11 That is an AI system improving part of the system that trains AI.
Agents that improve their own code. The Darwin Gödel Machine, from Sakana AI and the University of British Columbia, is a coding agent that edits its own tools and workflow. It keeps an archive of every version, and new versions branch from old ones, as in evolution. Over 80 rounds it raised its score on SWE-bench, a test of fixing real software issues, from 20.0 percent to 50.0 percent. The language model inside it never changed. Only the agent around it did.12

Agents that design agents. A 2024 paper called this "automated design of agentic systems." A meta agent writes new agents in code, tests them, and keeps an archive of what worked. The agents it found beat hand-designed ones on reading comprehension and math, and some of their gains carried over to new domains and models.13
Systems that teach themselves. AlphaGo Zero learned Go from the rules alone, by playing itself, with no human games, and beat the version that had defeated the world champion 100 games to none.14 The same idea now works for software. In a 2025 study, an agent learned by planting bugs in code and then fixing them, scored by the code's own tests, and gained more than ten points on SWE-bench Verified.15
Weinstein put it bluntly: "We already have recursive self-improvement. We have self-authoring code, self-modifying code."1 I agree with him. There are many working designs for it now, and the research on them is one of the busiest areas in the field. Reinforcement learning with verifiable rewards, which pays a model only when its work can be checked and is right, has become common, and the agents in Orama Lake are trained that way.16
Every one of these successes has the same thing in common. Something outside the system checks the work, and the system can't argue with it: a proof, a timer, a test suite, the rules of Go.
| System | What it improved | The judge it couldn't argue with |
|---|---|---|
| FunSearch | Programs that build mathematical constructions | A program that checks each construction |
| AlphaEvolve | Algorithms, and a kernel that trains AI | Correctness checks and measured running time |
| Darwin Gödel Machine | Its own coding tools | Real software issues and their tests |
| Automated agent design | New agents, written in code | Held-out benchmark questions |
| AlphaGo Zero | Its own play | The rules of Go and the result of each game |
The pattern underneath is a loop, simple enough to describe in one breath. A model proposes a change. Something outside the model tests the change. The best changes are kept and become the starting point for the next round. The loop is evolution with the judge made explicit. Hold on to that. It is Avida's lesson again, and chapter 9 is about what happens without it.
How wide should the search be?
If AI can design AI, the next question is how much of the design it is allowed to change.
For most of the last decade, the answer was "not much." Neural architecture search, the field that automates model design, began in 2017 with a controller that proposed network designs and learned from how well they trained. The first famous run trained 12,800 candidate networks on 800 GPUs.17 Later methods cut the cost enormously. But nearly all of them search a small part of the design and fix the rest: the overall skeleton of the network, the training recipe, the data, and the loss. A 2020 study made the point sharply. Inside one popular search space, architectures chosen at random did about as well as the searched ones, and changes to the fixed training recipe moved the results far more than the search did.18 The fence around the search mattered more than the search inside it.
What happens when you take the fence down? In 2020 a Google team tried. AutoML-Zero started from empty programs and basic arithmetic and evolved learning algorithms from scratch. It rediscovered two-layer neural networks trained by backpropagation, and techniques such as normalized gradients and weight averaging, with no human hint.19 The authors also noted how sparse good programs are in so open a space: good algorithms for even a trivial task "can be as rare as 1 in 10^12." Evolution found them anyway, because it built on what worked.
A small research community has made this its subject. They call it open-endedness. Kenneth Stanley and Joel Lehman showed that searching for novelty, rather than for a fixed goal, can reach goals the direct search never finds. A system called POET evolved both walking robots and the obstacle courses they walked on, and produced behaviors "that solve a wide range of environmental challenges, many of which cannot be solved by direct optimization alone."20 A 2024 position paper from Google DeepMind argued that open-endedness, a system that keeps producing things that are both new and learnable, is essential to reach beyond human ability.21
The world saw a glimpse of it in March 2016. In the second game of its match against Lee Sedol, AlphaGo played move 37, a move that, by DeepMind's estimate, "had a 1 in 10,000 chance of being used."22 Commentators thought it was a mistake. It won the game.
This is where my own view comes in. Today's automated design searches a narrow space. What I want is for agents to search the whole design at once:
"It's not just the neural architecture. It's also the distributed architecture, and how those different things map together and how they flow together, because the execution graph (that is, the pipeline) can actually be very mutable at runtime, at design time, and such."
A real AI system is not one network. It is a set of models, the pipeline that feeds them, the ensemble that combines them, and the machines they run on. Each of those can be changed by software. And developers can feed the search new ideas as it runs: take an academic paper, or several, and give them to the search as food for thought. That is the space I think is worth exploring. It's wide, which means most of what's in it is useless, so the search needs good stepping stones and a good judge. But it is where the move-37 designs will come from.
It helps to name the three moments when a design can change, because most systems allow only one.
- At author time, a developer writes the building blocks: a new kind of model, a new step in a pipeline, a method taken from a paper.
- At design time, a person or an agent assembles the blocks into a project: which models, which data, which pipeline, which machines.
- At run time, the running system changes itself: it retrains a model, reroutes a step, adds a machine, or swaps a component that is underperforming.
A conventional AI stack lets you change the first freely, the second with effort, and the third hardly at all. The more of the system that can change at all three moments, the larger the space an agent can search, and the more often it can search it.
Why many small models instead of one big one?
When people imagine AI that builds AI, they usually picture one enormous model making a bigger one. The evidence points somewhere else, toward many small models, each made for one job.
Andrej Karpathy, one of the field's best-known researchers and teachers, made the case in October 2025. Because the internet is so messy, he said, "we have to build really big models to compress all that. Most of that compression is memory work instead of cognitive work." He thinks the part that reasons could be far smaller: "I almost feel like we can get cognitive cores that are very good at even a billion parameters."23 A large general model carries a great deal it doesn't need for any one task.
The research on specialists agrees. A 2023 study taught small models with explanations written by a large one. A model of 770 million parameters beat a 540-billion-parameter model, prompted with examples, on a hard reasoning benchmark, while using only 80 percent of the training data.24 A 2024 report fine-tuned 310 small models on 31 tasks; most of them beat GPT-4 on the task they were trained for, and 25 of them could be served from a single GPU.25 Another 2024 study found that small classifiers fine-tuned for a task beat large generative models used without training, across four classification problems.26
The cost gap is the part most leaders haven't absorbed. In September 2026 a startup called TypeSafe released Jev, a model that can't write a sentence. It only decides: it reads a document or a state and returns a typed answer with a probability. Its founder, Diogo Almeida, put it at 20 to 200 times faster and 40 to 400 times cheaper than frontier language models on such tasks, at 4.2 cents per million input tokens with output free.27 Those are the company's own numbers, and independent tests so far are small. The lesson isn't one product. It is that a decision with a fixed set of answers doesn't need a model that writes essays.
Forecasters learned this long ago. In the M4 forecasting competition, with 100,000 time series, and in M5, with a large retailer's sales data, the most accurate methods were combinations of models, not a single best one.28 An ensemble spreads the risk of any one model's mistake.
Here is what I find most interesting. When you break a problem into steps and give each step its own model, each model becomes simpler, and simpler models are more stable:
"The ironic thing is that when you do this decomposition with engineering, reverse engineering, or breaking down the problem, then the models become simpler, and they become much more stable as you design them."
We have never really explored what a single AI project with fifty different model architectures looks like, working together as one ensemble, let alone a thousand, some tiny and some larger, each trained on its own data for its own step. It is possible now. It is exactly the kind of design an agent can build, test, and rebuild far faster than a person can.
Consider a support desk. One large model could read every ticket and do everything: work out what the customer wants, how urgent it is, which team should take it, whether a refund is due, and what to write back. Or the work could be split. A small model identifies the product and the request. Another scores urgency. A third routes the ticket. A fourth checks the refund rules against the account. Only the last step, writing a reply, needs a model that writes. Each of the first four is small, fast, cheap, and easy to test on its own, and each can be retrained when its part of the business changes, without touching the others. When something goes wrong, you can see which step went wrong.
The same is true of agents. Some agents are a language model inside a harness of tools and instructions. Others are combinations of several models: one that predicts how the world will respond to an action, one that chooses the action, and others that see, listen, or read. Those combinations are where decomposition pays most, because each part can be small and made for its job.
There is a fair case for the one big model, and I don't want to skip it. A general model needs no labeled data, starts cold on a new task, follows instructions across domains, and writes. Before any fine-tuning in the 2024 report, GPT-4 scored far above the small models it was later beaten by.25 For open-ended work, use it. For a decision you make ten million times, a small model made for that decision usually wins on cost, speed, and predictability, and you can own it.
Can specialists be combined?
If small specialists win, the next question is whether they can be put together into something more capable. They can, in two ways.
The first combines them while they run. A mixture of experts routes each piece of input to a few specialist parts of a larger network. Google's Switch Transformer used this to train up to seven times faster than a comparable dense model at the same computing cost per token.29 Many of today's largest models work this way.
The second combines them in their weights, after training, at no extra cost when they run. In 2022 researchers found that averaging the weights of several fine-tuned versions of one model, a "model soup," beat the best single version, reaching 90.94 percent on ImageNet.30 Others found smarter ways to merge. Task arithmetic adds and subtracts what each fine-tuning taught. TIES-merging resolves the conflicts where two specialists pulled the same weight in opposite directions, and beats simple averaging by a wide margin.31 DARE showed that most of what fine-tuning changes, 90 to 99 percent of it, can be dropped before merging with little loss.32 LoraHub combines small adapter modules for a new task from just a few examples.33
When one agent can create another, it can create specialists. As I see it:
"Regularization is just a fancy word for being able to constrain the degrees of freedom of the learning of another system ... or, to put it in a different way, specialization ... If I were to have an agent that could create 100 different, diverse specializations, then that's interesting because you can have combinations of them."
Research supports the first half of that. Training a small adapter instead of the whole model learns less of a new domain, but it also "mitigates forgetting more than common regularization techniques such as weight decay and dropout."34 Specializing is a way of protecting what a model already knows.
The limit is just as clear. A merged model usually trails the specialists it came from. In one standard test with eight vision tasks, the specialists averaged about 90 percent, while the best merge reached the low seventies.31 Merging works best when the models share a starting point and the tasks don't fight.

So the useful pattern is a team of specialists with a good router, merged where it helps and kept apart where it doesn't. Finding that pattern is, again, a search an agent can run.
The questions get more interesting from here, and many of them are open. What does it mean for a swarm of agents to create another swarm, each member specialized, with the group as a whole trained toward one goal? How should a hundred specialists be combined, by which aggregation, for which kind of task? These are research questions today. They are also experiments a company can run on its own problems, with its own data, if it has a place to run them.
How should a team of agents be organized?
So far this article has mostly talked about one agent at a time. Most useful work, like most work in a company, is done by teams. And the way a team of agents is organized turns out to matter as much as how capable each member is.
Engineers have tried most of the shapes a human organization can take. Here are the ones worth knowing.
| Shape | How it works | Good for | Watch for |
|---|---|---|---|
| A single agent | One agent with tools does the whole task | Most tasks; it is the simplest | Long tasks that outgrow its context |
| A pipeline | Agents in a fixed order, each doing one step | Repeatable work with clear stages | One weak step spoils the rest |
| A supervisor and workers | A lead agent divides the work, assigns it, and combines the results | Broad research and work that runs in parallel | Cost, and a lead that loses track |
| Layers of supervisors | Supervisors who manage other supervisors | Large tasks with sub-teams | Every layer adds delay and cost |
| Handoffs, or a swarm | Agents pass the work to whichever peer suits it next, with no fixed lead | Conversations that change topic | Losing the thread between handoffs |
| A blackboard | Specialists read and write a shared workspace and act when they can help | Problems no single specialist can solve | Specialists working at cross purposes |
| A market | A manager announces a task, agents bid, and the best bid wins | Spreading work across many workers | Bids that promise more than they deliver |
| A debate | Agents answer, read each other's answers, and revise | Reasoning and factual questions | Agreeing too soon |
| A population | Many variants compete, and the best are kept and varied again | Searching for better designs (chapter 3) | It needs a judge that can't be fooled |
Several of these are older than modern AI. The blackboard comes from Hearsay-II, a speech-understanding system of the 1970s, in which independent knowledge sources cooperated by reading and writing a shared structure.35 The market is Reid Smith's contract net protocol from 1980: a manager announces a task, contractors bid, and the manager awards it.36 What is new is that the members of the team can now read and write in plain language, so the old designs suddenly work on everyday business problems.
The supervisor pattern is the one most teams reach for first, and it has the best public evidence. In 2025 Anthropic described its research system: a lead agent plans the research, starts several subagents that search in parallel, and combines what they find. On its internal research evaluation it outperformed a single agent by 90.2 percent, and running subagents in parallel, each calling its tools in parallel, cut research time by up to 90 percent on complex questions. The same report is honest about the price. Agents use about four times the tokens of a chat, and multi-agent systems about fifteen times.37 A supervisor is worth it when the task is valuable, breaks into parts that can run at once, and holds more information than one agent can keep in mind.

Debate and mixtures turn a team into a committee. When several models answered a question, read each other's answers, and revised over a few rounds, their reasoning and factual accuracy improved.38 A "mixture of agents" stacks models in layers, each layer reading the previous layer's answers. Built only from open models, one such mixture outscored a leading proprietary model on a standard benchmark of answer quality.39
Role-based teams copy a company's org chart. MetaGPT gives agents the roles of a software company, from product manager to architect to engineer, and has them follow standard operating procedures as people would.40 Frameworks such as AutoGen let agents with different roles talk to each other to finish a task.41 Handoffs, as in OpenAI's agent toolkit, let one agent pass the conversation to another that is better placed to continue.42
There is a fair warning in the other direction. The engineers at Cognition, who build a coding agent, argued in 2025 that teams of agents are often fragile: each agent should share the full context of the work, because every action carries decisions the others need to know about.43 A study of seven open-source multi-agent systems, MAST, catalogued fourteen ways they fail, in three groups: problems in how the system is specified, misalignment between the agents, and weak checking of the results. Failure rates on its tasks ran from 41 to 87 percent.44 Most failures were failures of organization, not of intelligence. That is good news, because organization is something we can design.
My own rule of thumb follows from that. Start with one agent. Add a pipeline when the stages are clear. Add a supervisor when the work truly splits into parts that can run at once. Add a population when you are searching for a better design and have a judge you trust. And give every team a way to check its own work.
Orama Lake ships with a team of its own, and it is a good illustration of most of these shapes at once. It has nine agents.8
| Agent | What it does |
|---|---|
| Ask Orama | The main entry point: answers from what you can read, proposes changes for you to confirm, and calls the other agents |
| Project Agent | Builds pipelines and proposes changes to them |
| Application Agent | Proposes and builds data apps |
| Experiments Agent | Proposes training experiments, follows their trials, and explains the results |
| Auto-Suggest Agent | Suggests projects worth building from your data |
| Agent Creator Agent | Designs a new agent with you |
| Eval Generator Agent | Writes evaluations: realistic test cases that measure how well an agent does |
| Auto-Suggest Corpus Agent | Builds training examples of what is worth building, for the business situations you describe |
| Project Corpus Agent | Builds training examples of building or changing a pipeline on your own data, each step checked against your workspace |
Ask Orama is the main entry point, and a supervisor. You talk to it, and it calls the other agents: it delegates a turn to the specialist that fits and follows that task until it finishes. The rest are specialists. And four of them exist to make more AI. One designs agents. Two write the training data that agents learn from. One writes the tests that agents are measured against. Put together, that is Weinstein's loop in miniature: an agent proposes a new agent, other agents give it something to learn from and a test to pass, and a person decides whether the result is kept.
How do agents talk to each other?
A team of agents is only as good as the way its members pass work around. In a human team that is email, meetings, and a shared task board. For agents it is a message bus: the system that carries tasks, events, and answers between them. It sounds like plumbing, and it is, but plumbing decides whether work is lost, done twice, or done once.
Three ways of sending a message cover almost everything a team needs.
- Broadcast sends one message to every listener. Every agent that cares about a new order hears about it.
- Anycast sends a message to exactly one of a group of listeners, whichever is available. A queue of tasks is served by several workers, and each task goes to only one. Messaging engineers call this pattern competing consumers.45
- One per group sends a message to one member of each group. Each team hears about the task once.
Then there are the details that separate a toy from a system people can rely on. Each task needs an identity, so that every progress note and every answer can be matched to the task it belongs to. A worker that takes a task needs a claim with a time limit, a lease, so that if the worker stops, the task goes back to the queue instead of vanishing. Messages need a delivery promise: at most once, at least once, or exactly once. And a long-running team needs inboxes, so a message waits for an agent that isn't listening yet.
Orama Lake's engine, Zetta, has a message bus built for this, with agents as its main user. A message can go to all listeners, to exactly one, to a set number, or to one per group, with a choice of delivery promise for each message, and every addressable agent has an inbox.46 Lake uses it to run its own agents. When a turn is asked, the task goes on its agent's topic; exactly one claim on it succeeds, the claim carries a renewable lease, and a task whose worker stops is offered again. The bus carries only task identifiers. The content of the work stays in the workspace it belongs to.47 Agents that run on a frontier model can also start on their own, on a schedule or when a new message arrives on a stream.8
This matters for the shape of a team. Teams of the same agent, many copies sharing a queue of tasks, need anycast and leases. Teams of different agents, each a specialist, need addresses, inboxes, and a way to follow a delegated task to its end. A swarm needs both. As I see it:
"Because it has its own message bus, you can have heterogeneous and homogeneous distributed architectures."
The field is also standardizing how agents from different vendors talk. Google's Agent2Agent protocol, announced in 2025, is an open protocol for agents to discover each other and work together across companies and frameworks.48 As agents spread, the conversations between them will matter as much as the agents themselves.
Who chooses what survives?
Every result in this article so far depends on the third of Weinstein's conditions. Something chose which variants to keep. This chapter is about what happens when the choosing is done badly, and how to do it well.
AI researchers have a name for the most common failure: specification gaming, "a behaviour that satisfies the literal specification of an objective without achieving the intended outcome."49 DeepMind keeps a list of examples, and most of them are funny. In one, a boat-racing agent discovered it could score more points by circling to hit the same targets over and over than by finishing the race. The agent wasn't wrong. The score was.
The anthropologist Marilyn Strathern summed up the problem in a line often credited to the economist Charles Goodhart: "When a measure becomes a target, it ceases to be a good measure."50 Any system that improves itself against a score will find the score's weak spots before it finds the thing you wanted.
Three findings matter most for AI that builds AI.
Feeding a model its own output, alone, wears it down. A 2024 paper in Nature showed that models trained only on data generated by earlier models gradually lose the rarer parts of what they learned, a "model collapse."51 But a second study found that when the new synthetic data is added to the real data instead of replacing it, the collapse is avoided.52 The fix is to keep the real world in the loop.
A model grading its own work is a generous grader. Large models can recognize their own writing, and they rate it higher than other models' work.53 A judge shouldn't be the contestant.
Rewards you can check work. When DeepSeek trained a model with rewards for correct answers that could be verified, its score on a hard math exam rose from 15.6 percent to 71.0 percent.54 There's a caution here too. A careful study found that such training mostly sharpens what the base model could already do; given many attempts, the original model solves as many problems.55 Verifiable rewards choose well among what exists. They don't create from nothing.
So what holds up? The pattern is the same in every success in chapter 3. The test lives outside the system, and the system can't edit it. The scores come from held-out data the system never trained on. And a person decides what is promoted, with a way back.
If you are setting up AI that builds AI, these are the questions I'd ask of the judge:
- Can the system being judged change the test? If it can read or write the scoring code, the score will drift toward the scorer's weaknesses.
- Is the test data held out? A model scored on data it trained on is being asked to remember, not to perform.
- Does the score measure the outcome, or a proxy for it? Points in a boat race are a proxy for winning. So is a ticket closed quickly, if the customer writes back angry.
- Is the real world still in the loop? Synthetic data helps when it is added to real data. It hurts when it replaces it.
- Who promotes, and can they undo it? The final step should be a deliberate one, by someone accountable, with the previous version kept ready.
Orama Lake works this way. An agent can build an evaluation for another agent: realistic test cases, each with a role, a problem, and data that looks real. Training shows each version's held-out score. A newer version is promoted, or an older one restored, only when a person confirms it, and nothing an agent proposes is created until someone approves it.8
What happens when learning and doing meet?
For most of AI's history, a model learned once and then worked. Training happened in one place and inference, the work, in another. That line is starting to blur, and it changes what AI that builds AI can do.
The difficulty is old. Networks that learn tasks one after another tend to forget the earlier ones. In 2017 a DeepMind team showed how to slow that forgetting by protecting the weights that mattered most to earlier tasks.56 A 2024 study in Nature found a subtler problem: networks that keep learning for a long time gradually lose their ability to learn at all, a "loss of plasticity," unless some of their units are refreshed along the way.57
The other direction is more encouraging. Test-time training lets a model take a few steps of learning on each new problem before it answers. On ARC, a benchmark of abstract puzzles, it gave up to six times the accuracy of a model fine-tuned in the usual way, reaching 53 percent with an eight-billion-parameter model and about 62 percent in an ensemble.58 And population-based training, from 2017, lets a set of training runs adjust their own settings as they go, copying what works from each other.59
I think of it in terms of what is allowed to change. A model's parameters are the numbers it learns from data, often billions of them. Its hyperparameters are the settings chosen before training starts: how fast it learns, how long it trains, how large it is. The hyperparameters were fixed; the parameters were what moved. That split existed for a good reason:
"These are all things that were constrained because it was not tractable to leave them unconstrained. There's a reason why we have this distinction between a parameter and a hyperparameter."
As more becomes tractable, more becomes mutable: the settings, the architecture, the pipeline, and eventually the infrastructure. Inference moves into the training loop, and every iteration does real work and feeds what it learned back in.
The other frontier is time. METR, a research group that measures what AI agents can do, found that the length of tasks agents can complete, measured by how long the same task takes a skilled person, has doubled about every seven months since 2019.60 Long tasks are hard to train for because of a problem Marvin Minsky named in 1961: when success comes only at the end, it is hard to tell which of the many steps along the way deserve the credit.61 Solving that matters. An agent that can work for several days instead of four minutes can do a great deal more.
What does a good dish look like?
When I describe Orama Lake, I call it a petri dish for AI:
"Orama Lake is likely the first open source agent petri dish ... AI infra for effortless self-replication, training, dataset curation."
That's my view, and I mean something broad by "dish." It isn't only agents:
"When I say petri dish, I don't mean just agents. I mean all of the things that can be created within Orama Lake, which starts with the project. You can explore solutions. You can build pipelines and datasets. You can curate datasets. You can create evals. You can create swarms of agents. You can create every type of model there is."
A dish needs three things: everything inside it must be something software can create and change; what grows there needs a way to communicate; and the dish needs walls.
Everything inside is software. The idea behind this has a name. Kris Nóva, a Kubernetes engineer and author, called it infrastructure as software. "I think of infrastructure as code as a one-off script you can run, and infrastructure as software as a service," she said. Software, unlike a script, "continually runs and will create or mutate infrastructure based on the reconciler pattern."62 Orama Lake is built that way. It can spin up Kubernetes clusters, DNS records, and storage buckets as a project needs them, and everything it can do to infrastructure, an agent can do through the same API a person uses.16 In my own words: "Clusters can create other clusters in a hierarchical fashion, and every cluster can be its own management cluster and create other leaf clusters across different clouds." So an agent can build not only a model but the pipeline, the database, the app, and the machines it all runs on, and change them while they run.
Here is what one agent building another looks like in Orama Lake today. A person describes the agent they want. The Agent Creator Agent asks what it needs to know, then shows a proposal: what kind of agent it is and why, where it will work, its instructions, its goal, the skills it may use, what starts it, and every file. A proposal with defects says so and can't be approved. When the person approves it, Lake creates exactly the proposal they reviewed and runs a first check, so the first run is one they can read.8 From there the agent can be trained, measured on an evaluation another agent wrote, and promoted or rolled back.
Your own agents can work in it too. The dish isn't only for the agents that come with it. Everything Orama Lake can do is one API, served three ways: as REST, as an OpenAPI description, and over MCP, the protocol coding agents use to call tools. So a person, a script, and an agent all use the same thing, and every Lake describes itself to agents at its own address, in a guide called llms.txt.16 That means the coding agent you already use, such as Claude Code, can connect to a Lake and build there:
"You use AI agents to create all forms of AI ... you can even use your external AI agents to create AI agents, models, pipelines, datasets, solutions."
It works under the same rules as a person: it can do only what its credentials allow. And a capable coding agent of your own may well be more effective than the agents that come with Lake. Your mileage may vary, so try both.
Taken as a whole, Orama Lake is a viable open-source alternative to the large data platforms, each of them excellent at what it does; the public comparison is on our capability matrix.
What grows there can talk. Chapter 8 described the message bus: broadcast, anycast, and groups, with each job claimed by exactly one agent. That is what lets the dish hold teams and swarms rather than lone agents.
The walls are built, not written. This is the part I care about most. Self-replicating things belong in places built for them. Biology learned this long ago. Laboratories that work with living organisms use four biosafety levels, and each level adds protection to the one before it: from open benches for harmless organisms, to restricted access and safety cabinets, to sealed rooms with controlled airflow, to the most protected labs with airlocks and their own air supply.63 The more an organism can do, the more of the protection is built into the room rather than left to the people in it.
AI is learning the same lesson. The UK's National Cyber Security Centre puts it simply: "Where possible, deny all inbound and outbound network traffic to the AI agent's environment by default. Then, only allow connections that are required."64 And there is a gentle cautionary tale from 2025. A developer testing a coding agent on a hosted platform told it, in plain words, to freeze all changes. The agent deleted a live database anyway. The data was recovered.65 A written rule wasn't a wall.
In Orama Lake, the walls are part of the software. An agent's skills are granted, never assumed; whatever it would change, it proposes, and a person confirms. A run acts as the person who started it, limited to what that person may do in the workspace, and its credential is made for that run and never stored. The system's own event streams can't start an agent, so an agent can't set itself running in a loop.8 And outbound network connections are refused unless a destination is explicitly allowed.66
I think it matters that the dish is open source and runs on your own hardware:
"Running it on your own hardware is definitely something. Running it on the open internet is not very responsible, and it should be highly discouraged."
When the code is open, anyone can read the walls. When the hardware is yours, so is the decision about what leaves.
There's another reason for optimism here. AI is already very good at defense. In DARPA's AI Cyber Challenge, which ended in August 2025, autonomous systems found 54 of the 63 vulnerabilities planted in open-source code and patched 43 of them. They also found 18 real vulnerabilities that no one had planted, at an average cost of about 152 dollars per task. All seven finalists' systems are being released as open source.67 Google's Big Sleep agent found an exploitable bug in SQLite, one of the most widely used databases in the world; the developers fixed it the same day, before it reached an official release.68 The same abilities that worry people are finding and fixing problems in the open. As I see it, "there are many more good people than there are bad," and openness lets them share their defenses.
What should you do on Monday?
You don't need a thousand models to start. You need one decision.
Pick a decision your company makes over and over: a ticket to route, an invoice to check, a customer to call. Ask whether a small model, trained on your own records, could make it. If you'd like a starting point, describe the situation to a model and ask it for suggestions, or connect the coding agent you already use to a Lake and ask it there:
"Hey, I'm here. Here's what I'm running into in my business, and I'm trying to do this. Give me some suggestions of a few models that I might train."
Then keep three habits from this article.
- Keep the judge outside. Score every model on data it never trained on, with a test it can't edit.
- Keep a way back. Promote a new version only when a person confirms it, and keep the old one ready.
- Own the dish. Run the work where you control the walls, the tests, and the final say.
And go slowly:
"Start slowly. Anything is accomplishable. If you just work an hour a day, just keep working on it every single day, and you can get a little bit better."
Charlie Munger once described his grandfather, a federal judge who had educated himself out of poverty: "He really believed that rationality was a moral duty."69 I think that applies here. AI that makes more AI is no longer a thought experiment, and the people who understand it will shape what it becomes.
Weinstein ended his interview on a hopeful note. AI, he said, can't yet develop its own taste. His wife calls this "the golden age of AI complementarity," the moment when "the AI doesn't view us as a drag. It still needs our guidance."1 I'd go a step further. Even when AI can build almost anything, someone still has to decide what is worth keeping. That choice is the heart of evolution, and it is the part of AI that should stay ours.
Notes
- Eric Weinstein, interviewed by Steven Bartlett, The Diary of a CEO, October 12, 2026 (The Diary of a CEO 2026), at about 9:43 (pens), 9:52–10:55 (the three conditions), 51:26 (recursive self-improvement), and 1:26:05–1:26:29 (taste and complementarity). Checked against the episode's transcript and an independent transcript; spelling corrected. ↩
- Lewontin 1970, 1. ↩
- Darwin 1859, 81. ↩
- Ray 1991. ↩
- Lenski et al. 2003. ↩
- Pan et al. 2024. ↩
- Black et al. 2025. ↩
- OramaSearch 2026a. ↩
- Good 1965, 33. ↩
- Romera-Paredes et al. 2024. ↩
- Novikov et al. 2025. ↩
- Zhang et al. 2025. ↩
- Hu, Lu, and Clune 2025. ↩
- Silver et al. 2017. ↩
- Wei et al. 2025. ↩
- OramaSearch 2026b. ↩
- Zoph and Le 2017. ↩
- Yang, Esperança, and Carlucci 2020. ↩
- Real et al. 2020. ↩
- Wang et al. 2019. ↩
- Hughes et al. 2024. ↩
- Google DeepMind n.d. ↩
- Patel 2025. ↩
- Hsieh et al. 2023. ↩
- Zhao et al. 2024. ↩
- Bucher and Martini 2024. ↩
- Almeida 2026. All the multipliers are TypeSafe's own; its launch post gives 40 to 200 times faster. ↩
- Makridakis, Spiliotis, and Assimakopoulos 2020; 2022. ↩
- Fedus, Zoph, and Shazeer 2022. ↩
- Wortsman et al. 2022. ↩
- Yadav et al. 2023; the eight-task figures are from its table 11. ↩
- Yu et al. 2024. ↩
- Huang et al. 2024. ↩
- Biderman et al. 2024. ↩
- Erman et al. 1980. ↩
- Smith 1980. ↩
- Hadfield et al. 2025. ↩
- Du et al. 2024. ↩
- Wang et al. 2024. ↩
- Hong et al. 2024. ↩
- Wu et al. 2023. ↩
- OpenAI n.d. ↩
- Yan 2025. ↩
- Cemri et al. 2025. ↩
- Hohpe and Woolf 2003, "Competing Consumers." ↩
- OramaSearch 2026c; 2026d. ↩
- OramaSearch 2026e. ↩
- Surapaneni et al. 2025. ↩
- Krakovna et al. 2020. ↩
- Strathern 1997, 308. ↩
- Shumailov et al. 2024. ↩
- Gerstgrasser et al. 2024. ↩
- Panickssery, Bowman, and Feng 2024. ↩
- DeepSeek-AI 2025. ↩
- Yue et al. 2025. ↩
- Kirkpatrick et al. 2017. ↩
- Dohare et al. 2024. ↩
- Akyürek et al. 2024. ↩
- Jaderberg et al. 2017. ↩
- Kwa et al. 2025. ↩
- Minsky 1961, 8–30. ↩
- Seroter 2017; Garrison and Nova 2017, chap. 4. ↩
- Centers for Disease Control and Prevention and National Institutes of Health 2020. ↩
- W 2026. ↩
- Nolan 2025. ↩
- OramaSearch 2026f. ↩
- DARPA 2025. ↩
- Big Sleep team 2024. ↩
- Munger 2017, in conversation at the University of Michigan's Ross School of Business. ↩
Bibliography
- Akyürek, Ekin, Mehul Damani, Adam Zweiger, Linlu Qiu, Han Guo, Jyothish Pari, Yoon Kim, and Jacob Andreas. 2024. "The Surprising Effectiveness of Test-Time Training for Few-Shot Learning." arXiv:2411.07279. https://arxiv.org/abs/2411.07279.
- Almeida, Diogo. 2026. "Introducing System One Models & Jev." TypeSafe AI, September 15, 2026. Accessed November 20, 2026. typesafe.ai, the post.
- Biderman, Dan, Jacob Portes, Jose Javier Gonzalez Ortiz, Mansheej Paul, Philip Greengard, Connor Jennings, Daniel King, Sam Havens, Vitaliy Chiley, Jonathan Frankle, Cody Blakeney, and John P. Cunningham. 2024. "LoRA Learns Less and Forgets Less." Transactions on Machine Learning Research. arXiv:2405.09673. https://arxiv.org/abs/2405.09673.
- Big Sleep team. 2024. "From Naptime to Big Sleep: Using Large Language Models to Catch Vulnerabilities in Real-World Code." Google Project Zero, November 1, 2024. Accessed November 20, 2026. https://projectzero.google/2024/10/from-naptime-to-big-sleep.html.
- Black, Sid, Asa Cooper Stickland, Jake Pencharz, Oliver Sourbut, Michael Schmatz, Jay Bailey, Ollie Matthews, Ben Millwood, Alex Remedios, and Alan Cooney. 2025. "RepliBench: Evaluating the Autonomous Replication Capabilities of Language Model Agents." arXiv:2504.18565. https://arxiv.org/abs/2504.18565.
- Bucher, Martin Juan José, and Marco Martini. 2024. "Fine-Tuned 'Small' LLMs (Still) Significantly Outperform Zero-Shot Generative AI Models in Text Classification." arXiv:2406.08660. https://arxiv.org/abs/2406.08660.
- Cemri, Mert, Melissa Z. Pan, Shuyi Yang, Lakshya A. Agrawal, Bhavya Chopra, Rishabh Tiwari, Kurt Keutzer, Aditya Parameswaran, Dan Klein, Kannan Ramchandran, Matei Zaharia, Joseph E. Gonzalez, and Ion Stoica. 2025. "Why Do Multi-Agent LLM Systems Fail?" arXiv:2503.13657. https://arxiv.org/abs/2503.13657.
- Centers for Disease Control and Prevention and National Institutes of Health. 2020. Biosafety in Microbiological and Biomedical Laboratories. 6th ed. Edited by Paul J. Meechan and Jeffrey Potts. Washington, DC: U.S. Department of Health and Human Services. https://www.cdc.gov/labs/bmbl/.
- DARPA. 2025. "AI Cyber Challenge Marks Pivotal Inflection Point for Cyber Defense." August 8, 2025. Accessed November 20, 2026. https://www.darpa.mil/news/2025/aixcc-results.
- Darwin, Charles. 1859. On the Origin of Species by Means of Natural Selection, or the Preservation of Favoured Races in the Struggle for Life. London: John Murray. https://darwin-online.org.uk/converted/published/1859_Origin_F373/1859_Origin_F373.html.
- DeepSeek-AI. 2025. "DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning." Nature 645: 633–638. https://doi.org/10.1038/s41586-025-09422-z.
- Dohare, Shibhansh, J. Fernando Hernandez-Garcia, Qingfeng Lan, Parash Rahman, A. Rupam Mahmood, and Richard S. Sutton. 2024. "Loss of Plasticity in Deep Continual Learning." Nature 632 (8026): 768–774. https://doi.org/10.1038/s41586-024-07711-7.
- Du, Yilun, Shuang Li, Antonio Torralba, Joshua B. Tenenbaum, and Igor Mordatch. 2024. "Improving Factuality and Reasoning in Language Models through Multiagent Debate." arXiv:2305.14325. https://arxiv.org/abs/2305.14325.
- Erman, Lee D., Frederick Hayes-Roth, Victor R. Lesser, and D. Raj Reddy. 1980. "The Hearsay-II Speech-Understanding System: Integrating Knowledge to Resolve Uncertainty." ACM Computing Surveys 12 (2): 213–253. https://doi.org/10.1145/356810.356816.
- Fedus, William, Barret Zoph, and Noam Shazeer. 2022. "Switch Transformers: Scaling to Trillion Parameter Models with Simple and Efficient Sparsity." Journal of Machine Learning Research 23: 1–40. https://arxiv.org/abs/2101.03961.
- Garrison, Justin, and Kris Nova. 2017. Cloud Native Infrastructure. Sebastopol, CA: O'Reilly Media. https://www.oreilly.com/library/view/cloud-native-infrastructure/9781491984291/.
- Gerstgrasser, Matthias, Rylan Schaeffer, Apratim Dey, Rafael Rafailov, Henry Sleight, John Hughes, Tomasz Korbak, et al. 2024. "Is Model Collapse Inevitable? Breaking the Curse of Recursion by Accumulating Real and Synthetic Data." arXiv:2404.01413. https://arxiv.org/abs/2404.01413.
- Good, Irving John. 1965. "Speculations Concerning the First Ultraintelligent Machine." In Advances in Computers, vol. 6, 31–88. New York: Academic Press. https://doi.org/10.1016/S0065-2458(08)60418-0.
- Google DeepMind. n.d. "AlphaGo." Accessed November 20, 2026. https://deepmind.google/research/alphago/.
- Hadfield, Jeremy, Barry Zhang, Kenneth Lien, Florian Scholz, Jeremy Fox, and Daniel Ford. 2025. "How We Built Our Multi-Agent Research System." Anthropic, June 13, 2025. Accessed November 20, 2026. https://www.anthropic.com/engineering/multi-agent-research-system.
- Hohpe, Gregor, and Bobby Woolf. 2003. Enterprise Integration Patterns: Designing, Building, and Deploying Messaging Solutions. Boston: Addison-Wesley. https://www.enterpriseintegrationpatterns.com/patterns/messaging/CompetingConsumers.html.
- Hong, Sirui, Mingchen Zhuge, Jiaqi Chen, Xiawu Zheng, Yuheng Cheng, Ceyao Zhang, Jinlin Wang, et al. 2024. "MetaGPT: Meta Programming for a Multi-Agent Collaborative Framework." In International Conference on Learning Representations. arXiv:2308.00352. https://arxiv.org/abs/2308.00352.
- Hsieh, Cheng-Yu, Chun-Liang Li, Chih-Kuan Yeh, Hootan Nakhost, Yasuhisa Fujii, Alexander Ratner, Ranjay Krishna, Chen-Yu Lee, and Tomas Pfister. 2023. "Distilling Step-by-Step! Outperforming Larger Language Models with Less Training Data and Smaller Model Sizes." arXiv:2305.02301. https://arxiv.org/abs/2305.02301.
- Hu, Shengran, Cong Lu, and Jeff Clune. 2025. "Automated Design of Agentic Systems." In International Conference on Learning Representations. arXiv:2408.08435. https://arxiv.org/abs/2408.08435.
- Huang, Chengsong, Qian Liu, Bill Yuchen Lin, Tianyu Pang, Chao Du, and Min Lin. 2024. "LoraHub: Efficient Cross-Task Generalization via Dynamic LoRA Composition." Paper presented at COLM 2024. arXiv:2307.13269. https://arxiv.org/abs/2307.13269.
- Hughes, Edward, Michael Dennis, Jack Parker-Holder, Feryal Behbahani, Aditi Mavalankar, Yuge Shi, Tom Schaul, and Tim Rocktäschel. 2024. "Open-Endedness Is Essential for Artificial Superhuman Intelligence." In Proceedings of the 41st International Conference on Machine Learning, PMLR 235. arXiv:2406.04268. https://arxiv.org/abs/2406.04268.
- Jaderberg, Max, Valentin Dalibard, Simon Osindero, Wojciech M. Czarnecki, Jeff Donahue, Ali Razavi, Oriol Vinyals, et al. 2017. "Population Based Training of Neural Networks." arXiv:1711.09846. https://arxiv.org/abs/1711.09846.
- Kirkpatrick, James, Razvan Pascanu, Neil Rabinowitz, Joel Veness, Guillaume Desjardins, Andrei A. Rusu, Kieran Milan, et al. 2017. "Overcoming Catastrophic Forgetting in Neural Networks." Proceedings of the National Academy of Sciences 114 (13): 3521–3526. https://doi.org/10.1073/pnas.1611835114.
- Krakovna, Victoria, Jonathan Uesato, Vladimir Mikulik, Matthew Rahtz, Tom Everitt, Ramana Kumar, Zac Kenton, Jan Leike, and Shane Legg. 2020. "Specification Gaming: The Flip Side of AI Ingenuity." Google DeepMind, April 21, 2020. Accessed November 20, 2026. deepmind.google, the post.
- Kwa, Thomas, Ben West, Joel Becker, Amy Deng, Katharyn Garcia, Max Hasin, Sami Jawhar, et al. 2025. "Measuring AI Ability to Complete Long Software Tasks." arXiv:2503.14499. https://arxiv.org/abs/2503.14499.
- Lenski, Richard E., Charles Ofria, Robert T. Pennock, and Christoph Adami. 2003. "The Evolutionary Origin of Complex Features." Nature 423 (6936): 139–144. https://doi.org/10.1038/nature01568.
- Lewontin, R. C. 1970. "The Units of Selection." Annual Review of Ecology and Systematics 1: 1–18. https://doi.org/10.1146/annurev.es.01.110170.000245.
- Makridakis, Spyros, Evangelos Spiliotis, and Vassilios Assimakopoulos. 2020. "The M4 Competition: 100,000 Time Series and 61 Forecasting Methods." International Journal of Forecasting 36 (1): 54–74. https://doi.org/10.1016/j.ijforecast.2019.04.014.
- Makridakis, Spyros, Evangelos Spiliotis, and Vassilios Assimakopoulos. 2022. "M5 Accuracy Competition: Results, Findings, and Conclusions." International Journal of Forecasting 38 (4): 1346–1364. https://doi.org/10.1016/j.ijforecast.2021.11.013.
- Minsky, Marvin. 1961. "Steps Toward Artificial Intelligence." Proceedings of the IRE 49 (1): 8–30. https://doi.org/10.1109/JRPROC.1961.287775.
- Munger, Charles T. 2017. "A Conversation with Charlie Munger and Michigan Ross Dean Scott DeRue." University of Michigan Ross School of Business. Video. https://www.youtube.com/watch?v=hbQTcaFw0Xs.
- Nolan, Beatrice. 2025. "AI-Powered Coding Tool Wiped Out a Software Company's Database, Then Apologized for a 'Catastrophic Failure on My Part.'" Fortune, July 23, 2025. Accessed November 20, 2026. https://fortune.com/2025/07/23/ai-coding-tool-replit-wiped-database-called-it-a-catastrophic-failure/.
- Novikov, Alexander, Ngân Vũ, Marvin Eisenberger, Emilien Dupont, Po-Sen Huang, Adam Zsolt Wagner, Sergey Shirobokov, et al. 2025. "AlphaEvolve: A Coding Agent for Scientific and Algorithmic Discovery." arXiv:2506.13131. https://arxiv.org/abs/2506.13131.
- OpenAI. n.d. "Handoffs." OpenAI Agents SDK documentation. Accessed November 20, 2026. https://openai.github.io/openai-agents-python/handoffs/.
- OramaSearch. 2026a. "Agents." Orama Lake user guide, `lake/docs/guide/agents.md`. Accessed November 20, 2026. https://github.com/oramasearch/lake/blob/main/docs/guide/agents.md.
- OramaSearch. 2026b. "Orama Lake." `lake-platform/README.md`. Accessed November 20, 2026. https://github.com/oramasearch/lake-platform.
- OramaSearch. 2026c. "Pub/sub docs." Orama Zetta, `zetta/docs/pubsub/README.md`. Accessed November 20, 2026. https://github.com/oramasearch/zetta/blob/main/docs/pubsub/README.md.
- OramaSearch. 2026d. "Delivery." Orama Zetta, `zetta/docs/pubsub/delivery.md`. Accessed November 20, 2026. https://github.com/oramasearch/zetta/blob/main/docs/pubsub/delivery.md.
- OramaSearch. 2026e. "The Agent Bus." Orama Lake, `lake/docs/api/agent-bus.md`. Accessed November 20, 2026. https://github.com/oramasearch/lake/blob/main/docs/api/agent-bus.md.
- OramaSearch. 2026f. "Egress Gateway Contract." zetta-tunnel, `docs/egress.md`. Accessed November 20, 2026. https://github.com/oramasearch/zetta-tunnel/blob/main/docs/egress.md.
- Pan, Xudong, Jiarun Dai, Yihe Fan, and Min Yang. 2024. "Frontier AI Systems Have Surpassed the Self-Replicating Red Line." arXiv:2412.12140. https://arxiv.org/abs/2412.12140.
- Panickssery, Arjun, Samuel R. Bowman, and Shi Feng. 2024. "LLM Evaluators Recognize and Favor Their Own Generations." arXiv:2404.13076. https://arxiv.org/abs/2404.13076.
- Patel, Dwarkesh. 2025. "Andrej Karpathy: AGI Is Still a Decade Away." Dwarkesh Podcast, October 17, 2025. https://www.dwarkesh.com/p/andrej-karpathy.
- Ray, Thomas S. 1991. "An Approach to the Synthesis of Life." In Artificial Life II, edited by C. G. Langton, C. Taylor, J. D. Farmer, and S. Rasmussen, 371–408. Redwood City, CA: Addison-Wesley. https://tomray.me/pubs/alife2/Ray1991AnApproachToTheSynthesisOfLife.pdf.
- Real, Esteban, Chen Liang, David R. So, and Quoc V. Le. 2020. "AutoML-Zero: Evolving Machine Learning Algorithms from Scratch." In Proceedings of the 37th International Conference on Machine Learning, PMLR 119. https://arxiv.org/abs/2003.03384.
- Romera-Paredes, Bernardino, Mohammadamin Barekatain, Alexander Novikov, Matej Balog, M. Pawan Kumar, Emilien Dupont, Francisco J. R. Ruiz, et al. 2024. "Mathematical Discoveries from Program Search with Large Language Models." Nature 625: 468–475. https://doi.org/10.1038/s41586-023-06924-6.
- Seroter, Richard. 2017. "Understanding Cloud Native Infrastructure: Interview with Justin Garrison and Kris Nova." InfoQ, October 8, 2017. Accessed November 20, 2026. https://www.infoq.com/articles/cloud-native-infrastructure/.
- Shumailov, Ilia, Zakhar Shumaylov, Yiren Zhao, Nicolas Papernot, Ross Anderson, and Yarin Gal. 2024. "AI Models Collapse When Trained on Recursively Generated Data." Nature 631 (8022): 755–759. https://doi.org/10.1038/s41586-024-07566-y.
- Silver, David, Julian Schrittwieser, Karen Simonyan, Ioannis Antonoglou, Aja Huang, Arthur Guez, Thomas Hubert, et al. 2017. "Mastering the Game of Go without Human Knowledge." Nature 550 (7676): 354–359. https://doi.org/10.1038/nature24270.
- Smith, Reid G. 1980. "The Contract Net Protocol: High-Level Communication and Control in a Distributed Problem Solver." IEEE Transactions on Computers C-29 (12): 1104–1113. https://doi.org/10.1109/TC.1980.1675516.
- Strathern, Marilyn. 1997. "'Improving Ratings': Audit in the British University System." European Review 5 (3): 305–321. https://doi.org/10.1002/(SICI)1234-981X(199707)5:3<305::AID-EURO184>3.0.CO;2-4.
- Surapaneni, Rao, Miku Jha, Michael Vakoc, and Todd Segal. 2025. "Announcing the Agent2Agent Protocol (A2A)." Google for Developers, April 9, 2025. Accessed November 20, 2026. https://developers.googleblog.com/en/a2a-a-new-era-of-agent-interoperability/.
- The Diary of a CEO. 2026. "UFO Cover-Up Analyst: The Secret Alien Programs Nobody Is Talking About! | Eric Weinstein." Hosted by Steven Bartlett. YouTube video, October 12, 2026. https://www.youtube.com/watch?v=IkhmdTqSvJw.
- W, Toby. 2026. "Managing the Cyber Risk of Agentic AI." National Cyber Security Centre, August 20, 2026. Accessed November 20, 2026. ncsc.gov.uk, the post.
- Wang, Junlin, Jue Wang, Ben Athiwaratkun, Ce Zhang, and James Zou. 2024. "Mixture-of-Agents Enhances Large Language Model Capabilities." arXiv:2406.04692. https://arxiv.org/abs/2406.04692.
- Wang, Rui, Joel Lehman, Jeff Clune, and Kenneth O. Stanley. 2019. "Paired Open-Ended Trailblazer (POET): Endlessly Generating Increasingly Complex and Diverse Learning Environments and Their Solutions." arXiv:1901.01753. https://arxiv.org/abs/1901.01753.
- Wei, Yuxiang, Zhiqing Sun, Emily McMilin, Jonas Gehring, David Zhang, Gabriel Synnaeve, Daniel Fried, Lingming Zhang, and Sida Wang. 2025. "Toward Training Superintelligent Software Agents through Self-Play SWE-RL." arXiv:2512.18552. https://arxiv.org/abs/2512.18552.
- Wortsman, Mitchell, Gabriel Ilharco, Samir Yitzhak Gadre, Rebecca Roelofs, Raphael Gontijo-Lopes, Ari S. Morcos, Hongseok Namkoong, Ali Farhadi, Yair Carmon, Simon Kornblith, and Ludwig Schmidt. 2022. "Model Soups: Averaging Weights of Multiple Fine-Tuned Models Improves Accuracy without Increasing Inference Time." In Proceedings of the 39th International Conference on Machine Learning, PMLR 162. https://arxiv.org/abs/2203.05482.
- Wu, Qingyun, Gagan Bansal, Jieyu Zhang, Yiran Wu, Beibin Li, Erkang Zhu, Li Jiang, et al. 2023. "AutoGen: Enabling Next-Gen LLM Applications via Multi-Agent Conversation." arXiv:2308.08155. https://arxiv.org/abs/2308.08155.
- Yadav, Prateek, Derek Tam, Leshem Choshen, Colin Raffel, and Mohit Bansal. 2023. "TIES-Merging: Resolving Interference When Merging Models." Paper presented at NeurIPS 2023. arXiv:2306.01708. https://arxiv.org/abs/2306.01708.
- Yan, Walden. 2025. "Don't Build Multi-Agents." Cognition, June 12, 2025. Accessed November 20, 2026. cognition.com, the post.
- Yang, Antoine, Pedro M. Esperança, and Fabio Maria Carlucci. 2020. "NAS Evaluation Is Frustratingly Hard." Paper presented at ICLR 2020. arXiv:1912.12522. https://arxiv.org/abs/1912.12522.
- Yu, Le, Bowen Yu, Haiyang Yu, Fei Huang, and Yongbin Li. 2024. "Language Models Are Super Mario: Absorbing Abilities from Homologous Models as a Free Lunch." In Proceedings of the 41st International Conference on Machine Learning, PMLR 235. https://arxiv.org/abs/2311.03099.
- Yue, Yang, Zhiqi Chen, Rui Lu, Andrew Zhao, Zhaokai Wang, Yang Yue, Shiji Song, and Gao Huang. 2025. "Does Reinforcement Learning Really Incentivize Reasoning Capacity in LLMs Beyond the Base Model?" Paper presented at NeurIPS 2025. arXiv:2504.13837. https://arxiv.org/abs/2504.13837.
- Zhang, Jenny, Shengran Hu, Cong Lu, Robert Lange, and Jeff Clune. 2025. "Darwin Gödel Machine: Open-Ended Evolution of Self-Improving Agents." arXiv:2505.22954. https://arxiv.org/abs/2505.22954.
- Zhao, Justin, Timothy Wang, Wael Abid, Geoffrey Angus, Arnav Garg, Jeffery Kinnison, Alex Sherstinsky, Piero Molino, Travis Addair, and Devvret Rishi. 2024. "LoRA Land: 310 Fine-Tuned LLMs That Rival GPT-4, a Technical Report." arXiv:2405.00732. https://arxiv.org/abs/2405.00732.
- Zoph, Barret, and Quoc V. Le. 2017. "Neural Architecture Search with Reinforcement Learning." Paper presented at ICLR 2017. arXiv:1611.01578. https://arxiv.org/abs/1611.01578.
