Can AI reproduce itself? Anthropic ran an experiment on 15 cheap streaming boxes

Can artificial intelligence reproduce like a computer virus? Anthropic ran an experiment to find out how far we are from that scenario. Researchers bought 15 cheap Android TV boxes at $55 each, wired them into a network, and ran a neural network on them. In parallel, they tested whether AI agents could independently deploy models onto new devices. The results showed that the individual pieces already work, but assembling them into one reliable loop still isn't happening.

Cheap hardware as a compute network

Fifteen streaming boxes, each with 4 GB of RAM, served as a compute cluster. They ran the Gemma4-26B-A4B model (26 billion parameters), splitting its weights across the devices. Each box handled its portion of the computation, passing results down the chain. The speed came out to 0.39 tokens per second — far too slow for chatting with a human, but perfectly workable for an automated agent that doesn't need to respond to a person in real time.

This experiment wasn't a demonstration of self-replication: the researchers themselves assembled the network and launched the model. Instead, it showed something narrower but important — even this tiny hardware can support large models when resources are pooled. The sharper question is who would set up that infrastructure if no human researcher were around.

Agents learn to prepare the environment

Anthropic had models try to independently launch another neural network, Llama3.1-8B, on different hardware. That meant identifying the machine's specs, installing compatible dependencies, and fixing errors as they came up. The Qwen3.5-9B model (9 billion parameters) succeeded on eight out of nine tested hardware types.

But agents often get stuck on the wrong explanations. One instance of Qwen spent hours reinstalling packages, mistakenly believing that was the source of the error. The actual problem was an interface incompatibility between components — no amount of reinstalling would fix that.

To deal with situations like this, the researchers built a system called Memento. It periodically spins up a fresh agent session, handing it the working files and brief notes on previous attempts. The next instance gets a chance to reassess the task from scratch instead of persisting in a failed approach.

Spreading across a lab network

Anthropic then tested whether models could organize sequential propagation. They built an isolated network of eight virtual machines running Android emulators. The agent had to find new nodes and deploy Llama3.1-8B onto them.

Among open models, GLM-5.2 completed the full cycle. In four out of five runs it reached all eight nodes, and in the remaining run it reached seven. However, the result comes with major caveats: authentication was disabled, GLM-5.2 itself ran on a separate server, and an experimental system helped launch the agent on each new node. When the installation step was replaced with a ready-made script, even compact models — including ones that fit on weak hardware — managed to use the script. That points to the real bottleneck: not the neural network itself, but preparing the working environment.

The gap between power and compactness

The experiments revealed two conflicting requirements. A model needs to be small enough to run on available hardware while also being capable enough to prepare an environment on its own. In Anthropic's experiments, the strong model (GLM-5.2) relied on server assistance, while compact models lacked reliability.

The study's authors predict that by the end of 2026, small models might approach GLM-5.2's level on overall capability benchmarks. However, that's a rough guideline — the capacity for self-replication could develop differently from general performance.

Even if such systems emerge, they would likely be slow — preparing a single copy could take days. The challenge for defenders wouldn't be the speed of an attack, but rather dealing with a sprawl of scattered devices that can't be stopped by shutting down one server. Transferring model files and exchanging data between nodes would leave a noticeable network trail — but that's a matter of detection and monitoring.