The Complete Wiki to the 2 Billion-Year Minecraft AI Run

Minecraft is usually associated with speedruns, automation and player creativity. RedLogic's “Running Minecraft Until It Beats Itself” experiment explored something much stranger: whether a Minecraft world could theoretically progress far enough for its own mobs to defeat the Ender Dragon without a player controlling them.

The experiment produced a simulated timeline lasting approximately 1.975 billion in-game years, eventually reaching the final hit that killed the Ender Dragon.

There is one important correction to the way this experiment is sometimes described online: it was not a neural-network AI run. RedLogic's project used a custom probabilistic simulation and Monte Carlo-style sampling to model rare events and compress enormous waiting periods. The available description and reporting do not identify a neural network as part of the method.

That distinction matters because the experiment is better understood as a Minecraft probability and simulation experiment, rather than an AI agent learning to play Minecraft.

Quick Facts

The creator's published video states that the simulation searched for extremely rare chains of Minecraft events rather than literally running a normal Minecraft world for billions of years.

What Was the 2 Billion-Year Minecraft Experiment?

The experiment started with a simple question:

Could Minecraft eventually beat itself?

The answer produced by RedLogic's model was effectively yes, under a very specific set of conditions.

The key was finding a Minecraft seed where the environment could support a chain reaction involving several different mob behaviors.

The selected seed was:

-535646876083114041

The scenario depended on a particularly favorable world setup, including a completed End Portal positioned so that mobs could eventually reach it. The model then examined how long extremely rare interactions could take to occur.

Rather than waiting for every ordinary Minecraft tick, the simulation concentrated on meaningful events and statistically sampled the waiting time between them.

That is why the experiment could represent billions of years without actually running Minecraft normally for billions of years.

Was This Actually a Minecraft AI?

No, Not in the Neural-Network Sense

The biggest misconception surrounding the experiment is the word AI.

A conventional AI Minecraft project might use:

• Neural networks
• Reinforcement learning
• Computer vision
• An AI agent
• Machine-learning policies
• LLM-based decision making

RedLogic's experiment was different.

The published description specifically explains a custom simulation that tracks rare chains of Minecraft events and uses statistical methods to compress the enormous waiting periods involved. Reporting on the project identifies the technique as a Monte Carlo simulation.

So there is no documented evidence that a neural network was trained to defeat the Ender Dragon.

The Better Description

A more accurate description would be:

A probabilistic Minecraft simulation that searched for a theoretically possible self-completion sequence.

This makes the experiment interesting for a completely different reason. Instead of asking whether an AI can learn Minecraft, it asks how far Minecraft's own random mechanics could theoretically go when given an extraordinary amount of simulated time.

How the Monte Carlo Simulation Worked

The core idea was to avoid calculating every Minecraft event individually.

Minecraft normally operates through extremely frequent game updates. Waiting for an event such as an Enderman moving a specific block into exactly the right position could take an enormous amount of time.

Doing that billions of years into the future directly would be computationally impractical.

Instead, the simulation focuses on meaningful events.

For example:

1. An Enderman eventually interacts with a pumpkin.
2. The pumpkin can be positioned on snow.
3. A Snow Golem can be created.
4. The Snow Golem can interact with nearby mobs.
5. Creepers can be provoked.
6. Explosions can modify the environment.
7. The altered environment can expose routes toward the End Portal.
8. Mobs can eventually reach the End.
9. Endermen can manipulate blocks around the Ender Dragon's arena.
10. Snow Golems and Creepers can damage the End Crystals and eventually the Dragon.

The simulation estimates the waiting time associated with these rare events rather than processing every irrelevant tick between them.

The Minecraft Mob Chain Reaction

The experiment's most fascinating feature is that no single mob is responsible for defeating the Dragon.

Instead, different Minecraft mechanics contribute to a long chain reaction.

Endermen

Endermen are important because they can pick up and place certain blocks.

In this scenario, their block-moving behavior becomes enormously important over extremely long simulated periods.

One critical early event occurred around year 33,477, when an Enderman picked up a pumpkin.

Two years later, around year 33,479, that pumpkin contributed to the creation of a Snow Golem.

Under ordinary Minecraft gameplay, these events are essentially background noise.

Over hundreds of millions of years, however, small random actions can accumulate into something much more significant.

Snow Golems

Snow Golems become one of the main sources of indirect chaos.

Their projectiles can provoke hostile mobs, including Creepers.

This creates a strange chain:

Snow Golem → mob aggression → Creeper movement → explosion → environmental change

The first important Snow Golem interaction happened around year 35,510, when a Snow Golem helped provoke a Creeper and an explosion opened part of the route toward the End Portal.

Another Snow Golem and additional Creeper explosions eventually opened enough of the route for surface mobs to reach the portal area.

Creepers

Creepers provide the destructive component of the experiment.

Their explosions can:

• Destroy blocks
• Open pathways
• Change terrain
• Damage entities
• Alter access routes

The important idea is that Creeper explosions do not need to be intentionally controlled.

The experiment relies on rare positioning and timing eventually producing useful destruction.

The End Portal Problem

One of the most important conditions was the existence of a favorable completed End Portal.

This is a major limitation of the experiment.

Mobs cannot simply decide to construct and activate an End Portal themselves.

The scenario therefore starts with an unusually favorable world configuration.

This means the experiment is not demonstrating that an untouched random Minecraft world will routinely beat the game.

Instead, it demonstrates that given a carefully selected seed and favorable conditions, a probabilistic chain can theoretically reach the game's ending.

The Journey Into the End

Once a path toward the portal was established, the experiment entered its most ridiculous phase.

The End became a battlefield of incredibly slow random activity.

According to the reported timeline, Endermen began entering the End around year 1.3 million.

They continued moving blocks around the Ender Dragon's arena over extraordinarily long periods.

Eventually, these movements created opportunities for Snow Golems to interact with the End Crystals.

The End Crystal Destruction Timeline

The End Crystals are critical because they continually restore the Ender Dragon's health.

Destroying them is therefore a prerequisite for dealing meaningful long-term damage to the Dragon.

The reported timeline includes:

Year 3 million

The first Snow Golem entered the End and accidentally destroyed an End Crystal.

Year 122,415,210

Eight of the ten relevant End Crystals had been destroyed.

Year 181 million

A Snow Golem destroyed the ninth End Crystal.

Year 199 million

After wandering around the End for approximately 18 million years, a Snow Golem finally destroyed the last remaining End Crystal.

At that point, the Dragon no longer had its normal crystal-based regeneration support.

But killing it was still an enormous task.

When Did the Ender Dragon First Take Damage?

The first recorded successful Creeper explosion against the Ender Dragon occurred around:

Year 227 million

The explosion dealt approximately 4 points of damage to the Dragon.

That sounds like progress.

But compared with the Dragon's total health, it was almost nothing.

The experiment therefore entered an even longer phase of incremental damage.

The 1.975 Billion-Year Ender Dragon Kill

The most important number in the experiment is:

Approximately 1.975 billion simulated years

That is when the final hit connected with the Ender Dragon, completing the scenario and allowing Minecraft's ending sequence to occur.

The Dragon did not suddenly lose all of its health.

Instead, its health was gradually reduced through an extraordinary combination of:

• Snow Golem attacks
• Creeper explosions
• Destroyed End Crystals
• Random mob movement
• Environmental changes
• Extremely long waiting periods

The final Dragon kill therefore represents the endpoint of a massive probabilistic chain reaction.

Why the Timeline Reached Billions of Years

The most important concept is rarity.

Each individual event may be possible.

But the experiment requires many events to happen in the right sequence.

Imagine a simplified chain:

A → B → C → D → E

If each event is unlikely, the probability of the entire sequence becomes dramatically smaller.

Minecraft contains enormous numbers of possible random interactions.

The experiment effectively asks:

How long would we expect to wait before the right combination occurs?

That is why the timeline escalates from thousands of years to millions, then hundreds of millions, and eventually almost two billion years.

The 2 Billion Years Were Not Normal Minecraft Runtime

This distinction is essential for understanding the experiment.

The experiment did not simply leave Minecraft running on a computer for two billion real-time years.

That would obviously be impossible.

Instead, the model statistically sampled the waiting time between important events. RedLogic described the approach as speeding up the universe itself by tracking rare chain reactions rather than calculating every tiny random action individually.

So:

2 billion years = simulated/modelled Minecraft time

It does not mean:

2 billion real-world years of Minecraft gameplay.

How Realistic Is the Result?

This is where some important nuance is needed.

The experiment is best understood as a theoretical simulation, not a prediction that an ordinary Minecraft world will naturally defeat the Ender Dragon if you leave it running.

Community discussion has raised questions about assumptions involving things such as mob spawning, loaded chunks, mob behavior and environmental interactions. The creator has also responded to some methodological questions, including how the Ender Dragon behaves when there is no player.

There is another limitation: the detailed simulation code is not fully publicly reproducible because the relevant code is behind RedLogic's Patreon, according to reporting.

Therefore, the 1.975-billion-year figure should be treated as the result of this particular model and scenario, rather than an independently verified prediction of what unmodified Minecraft would inevitably do.

Why the Experiment Is Still Interesting

Even with those limitations, the experiment highlights something unusual about Minecraft.

The game's mechanics are designed for players, but many systems operate through independent rules:

• Mobs move
• Endermen manipulate blocks
• Snow Golems attack enemies
• Creepers explode
• Explosions modify terrain
• End Crystals regenerate the Dragon
• The Dragon follows its own behavior
• Random events continue accumulating

When those systems are considered over an absurdly long timescale, the world starts behaving like a gigantic probabilistic machine.

That is the real appeal of the experiment.

What Happened to the World?

After the simulated journey, the Minecraft world looked radically different.

The long sequence of explosions and block movement produced a heavily altered environment, with huge quantities of blocks displaced and terrain damaged by Creepers.

The result demonstrates an interesting Minecraft concept:

Time itself becomes an environmental force.

A landscape that looks stable during a normal survival session can theoretically change dramatically when random mechanics are allowed to operate for hundreds of millions or billions of simulated years.

Minecraft AI vs Minecraft Simulation

This is why describing the project simply as a “Minecraft AI run” can be misleading.

The experiment is much closer to probabilistic computational modeling than to an AI agent learning how to play Minecraft.

Key Timeline

The milestone sequence is based on RedLogic's experiment as reported by PC Gamer and other coverage.

Is This the Longest Minecraft Experiment Ever?

The experiment is notable for its simulated timescale, but it should not automatically be described as the longest-running real Minecraft world.

The billions of years are generated through a statistical model.

That makes the project fundamentally different from someone leaving an actual Minecraft server running continuously for years.

The significance is therefore computational and theoretical rather than a record for real-world Minecraft runtime.

FAQ

Did AI defeat the Ender Dragon?

Not in the conventional machine-learning sense. The documented experiment used a custom probabilistic simulation and Monte Carlo-style sampling, not a documented neural-network agent.

How long did the simulation take?

The modeled scenario reached the final Dragon kill at approximately 1.975 billion simulated years.

Did Minecraft actually run continuously for 2 billion years?

No. The experiment statistically compressed extremely long waiting periods rather than running normal Minecraft for that amount of real-world time.

What Minecraft seed was used?

The reported seed was -535646876083114041.

Which mobs were most important?

The central chain involved Endermen, Snow Golems and Creepers.

When was the first End Crystal destroyed?

The reported timeline places the first destroyed End Crystal at around 3 million simulated years.

When did the Dragon first take damage?

Around year 227 million, when a Creeper explosion dealt approximately 4 damage.

When did the Ender Dragon die?

The final hit occurred at approximately 1.975 billion simulated years.

Can I reproduce the exact experiment?

Not straightforwardly. The detailed simulation code is not fully publicly available, with reporting noting that the relevant code is behind RedLogic's Patreon.