Wolves and ravens in Core War: eight instructions among the front-runners

Eight instructions. That is the entire Lone Wolf warrior we developed with AI for Core War. Yet in our larger validation it finished just behind the 100-instruction Wolf Raven and ahead of our previous favourite, Kompas. Sometimes a good idea really does fit into a few lines.

In my Dungeon project I worked with agents in both Codex and Claude Code. The assignment was concrete: design warriors, test them against a fixed roster, and submit the code and results. Iteration produced our wolves and ravens, three different approaches to finding and disabling an opponent.

Experiment dated 10 October 2026; final validation added on 11 October. The wolf-and-raven cover is an AI-generated illustration. Actual arena screenshots and measured results appear below. The arena interface is Czech; the charts below are in English.

What worked

• Wolf Raven and Lone Wolf led the five programs compared against the same 25 opponents, with 50,000 games per program.
• Lone Wolf has just eight instructions. Program length is a poor substitute for measuring performance.
• Raven Scout beat Wolf Raven in 71 of 100 head-to-head games in a separate submission test. The best average does not guarantee victory against every opponent.

A game where you overwrite your opponent

Imagine a shared playing field of 8,000 memory cells, each holding an instruction. Two programs take turns executing their code and can overwrite any part of that field, including each other's instructions. Executing DAT kills the current process. Lose all your processes and you lose the game.

A warrior can also create additional processes or copy itself elsewhere. Hitting one location may therefore solve very little. First you have to find the opponent, then stop its escape routes.

No language model makes decisions during a duel. AI helped design and revise the programs beforehand. Inside the arena, only the resulting Redcode runs, a small assembly-like language.

Kompas beat Dwarf in this particular duel. Blue and orange identify the last program to write each cell. A screenshot illustrates the game; the rankings require many matches.

Rock, paper, scissors, with complications

These are tendencies, not guaranteed matchups. Exact instructions, starting positions and the roster matter. Scanners did particularly well in our original roster, which is also the environment we tuned against.

Ranking one: the original field

The first complete round-robin of 26 warriors comprised 32,500 games, or 2,500 per warrior. Here are the top ten:

Scores are not win percentages. A win earns 3 points, a draw 1 and a loss 0. We normalize to 100 games, giving a maximum of 300. One hundred draws earn 100 points; one hundred wins earn 300.

Meet the wolves and ravens

Wolf Raven, 100 instructions: an initial quick scan, relocation of its fighting code, a search for enemy traces, then a clearing attack. SPL instructions multiply the opponent's processes and bog it down; DAT instructions subsequently kill them. A backup Imp provides another survival mechanism. The bird and wolf describe parts of one program, not two conversational AI agents.

Wolf Raven tunes parameters of King Cobra by inversed. We build on an existing design rather than claiming to have invented that architecture.

Lone Wolf, eight instructions: its lineage runs from David van Dam's Scanny Boy through Kompas, developed with Codex, to further instruction-level changes in Claude Code. Its small footprint and attack direction help against Imp and Dwarf in this test. It is less effective against some hybrid strategies.

Raven Scout, 89 instructions: derived from Stefan Kammann and Forge-AI's CLRSRC, itself descended from inversed's Eternal Exile. It launches a limited attack and returns to searching. It has different favourable matchups, but all three newcomers belong to the broader scanner family.

This was not a controlled Codex-versus-Claude-Code benchmark. The workflow, available material and preceding work differed. Warrior scores cannot establish which underlying AI model is generally better.

Ranking two: the same opponents for everyone

With code frozen, a larger validation used 1,000 starting positions and both move orders. For the main comparison I aggregated the stored games against the same 25 opponents for all five programs, giving 50,000 games each.

Both wolves finished ahead of Kompas and the original King Cobra. That is a satisfying result. But Wolf Raven leads Lone Wolf by only 0.314 points per 100 games, too little to present as conclusive superiority. Raven Scout finishes just behind Kompas here.

Why 25 rather than 26 opponents? The original reference roster includes Kompas. Leaving it in would make the baseline Kompas fight its own copy. I therefore excluded that opponent equally for all five programs. No remaining match result was changed; the original 26-opponent data is available below.

An average hides the interesting weaknesses

Each cell represents 2,000 games and shows points per 100 games, not win percentage. These six opponents illustrate different weaknesses; the main ranking uses all 25 shared opponents.

Wolf Raven never lost to Imp, but 1,607 of their 2,000 duels were draws. It survives well without earning as many points as Lone Wolf does in that matchup. Lone Wolf, meanwhile, struggles against Aeka. That is more useful feedback for the next revision than a single overall rank.

Ranking three: fighting the siblings too

In a separate submission test, each newcomer faced the 26 reference warriors plus the other two newcomers, for 2,800 games each:

Raven Scout beat Wolf Raven 71 to 26, with three draws, and Lone Wolf 74 to 26. Wolf Raven beat Lone Wolf 83 to 16, with one draw. Raven Scout can hunt our wolves, while its other matchups keep it from the best overall average.

This test includes only pairs involving at least one newcomer. It is not a complete round-robin of all 29 warriors, so it does not establish a new overall champion.

What failed, and why that matters

Adding more hunters to a larger pack sounded promising. In shared memory, however, they can overwrite their own hiding places or destroy one another. More components did not automatically improve the result.

Another trap was testing. A variant that looked excellent on a small set of starting positions could lose its edge elsewhere. Regular scanning steps can also interact misleadingly with regularly spaced test positions. The useful loop is idea, measurement, weakness analysis, revision and fresh validation. An AI-generated explanation is no replacement for matches.

The colours show the last writer to each cell, not permanent ownership. Thousands of live processes explain why a single hit may not settle a duel.

A connection to research

Digital Red Queen from Sakana AI and MIT also uses language models to evolve Core War warriors against a growing history of opponents. Our smaller experiment asks a related question: how does the environment shape a successful strategy?

Our scores are not directly comparable to that study. Rosters, evolution and evaluation differ. Testing a few files from a public repository would not reproduce the published experiment. See the Digital Red Queen paper for its methodology.

Where I want the pack to go next

First, a complete tournament with the expanded roster. Then strong opponents we never tuned against. I would also like to test a complementary portfolio: a specialist might cover the best generalist's weak matchups.

The bigger question is whether AI helps us not only produce more code, but identify which ideas actually work and why. Our wolves are a promising answer for one particular arena. Now we need to learn what survives outside it.

Results, code and test conditions

• Main comparison and all reference matchups (JSON)
• Shared 25-opponent ranking (CSV)
• Original 26-warrior round-robin (JSON)
• Submission test summary (JSON)
• Detailed submission results (JSON)
• Large validation log (TXT)
• Data and our three warriors in one download (ZIP)
• Redcode: Wolf Raven, Lone Wolf, Raven Scout.

Methodology and limitations

We use a custom JavaScript implementation of ICWS ’94nop, not the original pMARS binary. Core size: 8,000 cells. Limits: 8,000 processes per warrior, 80,000 rounds (up to 160,000 executed instructions in a two-warrior duel), 100 instructions per program. Score: (3 × wins + draws) / games × 100.

Original round-robin: seed 6101003, 50 positions and both move orders. Submission test: seed 20261011, also 50 positions and both orders. Large validation: optimized engine, seed 161803, 1,000 positions. The development log reports comparison of the optimized and reference engines on 1,900 games with identical outcomes and step counts; this is a check, not a formal equivalence proof.

Fresh starting positions limit overfitting to placement, but the opponents remain familiar. This is not a test of generalization to unseen strategies. We report no confidence intervals and do not claim statistically established superiority for small gaps. The download contains our three warriors and results, not a complete executable environment with every opponent.