The enemy colony gets a new brain

The last post was about the ants learning to be afraid. This one is about the other colony — the one you play against — and about the complaint I have heard more than any other since the demo went up: the AI is too easy. It always dies.

For a game whose entire round is “outlast the other colony,” that is a dealbreaker, and I have struggled with it for months. This month it finally got a real answer — and the answer isn’t the headline feature, which is that the enemy colony can now be driven by Jev, a new kind of AI model from TypeSafe, on standing orders you write in plain English. The answer came out of building that, because a thing that plays the game a thousand times overnight notices what a thing that plays it twice on a Tuesday does not.

What Jev is (and isn’t)

Jev is not a chat model, and “we put an AI in the enemy colony” should not make you picture a chatbot writing paragraphs about ant strategy. TypeSafe calls Jev a System One model — fast, intuitive judgment rather than slow deliberation. You hand it a description of a situation and a set of typed questions: pick one of these options; score this from low to high. It hands back typed answers with a calibrated confidence on each, in roughly a tenth of a second. It never produces free text, cannot count or do arithmetic, and will not write you an essay — and in exchange it is fast and cheap enough to sit inside a real-time loop. Their launch demo has it playing Doom at ten decisions a second. Ours asks it about ants.

If you want the primary source, their introduction to System One models and Jev is a good read, and the docs show the actual request shape. It’s early-access as of this week.

The AI finally has teeth

The spike that wired Jev in had a control arm: a “player” who does nothing. No commands, ever. It should lose to the enemy AI every time. It won 61% of its games — because the enemy AI starved itself to death (#297). That is the “it always dies” complaint with a number on it.

Two days of paired seed sweeps later, the mechanism was clear, and it explained why no amount of balancing had ever helped: this was never a balance problem. The colony wasn’t eating too much; it was earning exactly nothing. The spider camps the colony’s single entrance, and the flee logic from V34 holds every homebound forager in place for as long as it stands there — around 1,200 ticks per camp. The queen starves with food piled up outside the door. Remove the spider and the AI queen survives thirty rounds out of thirty.

The tempting fix was a constant — the same knobs I had been turning for months. Measured properly this time, the best of them (starvation grace, egg threshold, larder size, spider appetite, a third food chamber) got survival to 40%. None touched the defect.

The real fix is V38: a homebound forager within eight tiles of one of its own open entrances pushes through the danger and goes home instead of freezing — but only if every open door is actually enterable, because releasing a carrier toward a door the spider is standing on is worse than the hold. No constants retuned. AI queen survival at twelve thousand ticks went from 23% to 87%, and the share of rounds where the AI ever reaches a war footing from 17% to 87% — and a standing thirty-seed gate now fails the build if those numbers regress, because correctness gates cannot see badness.

I have been wrong about this AI before, so I say it carefully: V38 is the first time since Phase 3 that it has felt like a worthy opponent rather than a clock I was waiting out. It survives the spider, it reaches a war footing, and it comes for you. The enemy has teeth now — and that is true of the plain rule-based AI, before Jev enters the picture at all.

The spider had a favorite colony

The second fix came out of a tournament I ran to pick Jev’s default orders: Jev against Jev, in both seats. Whichever colony sat in the enemy seat won about 61% of the time, regardless of what either was told to do.

So: two completely passive colonies, no controllers, 800 rounds. Seat one’s queen died first in 55% of them. With no spider, no queen died at all; the map audited as symmetric, and swapping the nests did not move the bias. It followed the colony’s id: every one of the spider’s target choices broke exact ties on an ascending id — which colony to rampage against, which ant to chase, which ant on a shared tile to bite — and the starting cohort holds the lower ids colony by colony. V39 replaces each ordering with a deterministic hash key — no random draws, saves still replay byte-for-byte — and the same 800 rounds now come out at 48%. If you ever felt the enemy got a slightly better deal from the spider than you did, you were right. You aren’t anymore.

How Jev drives a colony

It sits in either seat. Rather than replace the strategic layer of the enemy AI, the controller speaks the player’s command surface — the same dig marks, chamber placements, ratios and rally points you issue with the mouse — and can be handed either colony. Today that is the enemy seat; later it is a stand-in for a missing human when multiplayer arrives.

The state it sees has no digits in it. Jev can’t count, so instead of “food stored: 1,816 of 2,048” it reads “stores: high, rising”; instead of “seven workers,” “a handful.” Every number is bucketed into words before it leaves the game, and the code proposes a short list of concrete candidates — dig toward the food pile to the east, send the fighters to the enemy entrance — for Jev to pick among. Jev decides; the code does the arithmetic.

It decides every five seconds; the game runs every fifty milliseconds. One request every hundred ticks, fire-and-forget, applied on the next tick after the answer arrives — never mid-callback, so every write to the world happens inside the tick seam and the simulation stays deterministic and replayable.

The opening is planned at tick zero. The shaft and first three chambers are placed immediately and Jev takes over on the second tick while a single digger excavates the plan, so its first decision comes seconds in rather than the three or four minutes the rule-based opening used to take.

Standing orders are yours to write. Four presets came out of the tournament. Balanced was the runaway winner at 75% with no losing matchup: all food and growth early with fighters at home, then, once the colony is large and stores are high, mostly fighters and an assault until the queen is dead. Aggressive strikes whenever the enemy looks weaker; Economy puts survival first; Turtle only strikes with overwhelming force. Pure aggression from the opening bell finished dead last — it starved before it killed anything. Or ignore the presets and type your own, up to three hundred characters.

Nothing goes to Jev’s servers from your browser. The game talks to a small endpoint on subterrans.com, the only thing holding an API key. Each match mints a short-lived session token with a fixed budget of decisions, and every request carries the state in a closed vocabulary, so the endpoint can’t be repurposed as a general proxy. There’s a spend alarm on the other end.

If Jev is unreachable, you still get a game. Three consecutive failed requests and the round falls back to the rule-based AI, with the HUD saying so; the state machine has been ticking along underneath the whole time. Nothing in src/sim/ knows Jev exists.

Does it actually play?

The spike had a pass/fail bar written down before it ran, and it cleared it. Same seed, different orders, and the play diverged 7.3× more than two runs with identical orders — “turtle” never attacked, “aggressive” always did. Paired per seed, Jev beat a controller that presses random buttons by a clear margin (p ≈ 0.0002). And over 290 matches and ten thousand requests: zero API errors, median latency 123 ms, total cost under a dollar.

The playtest is coming soon

The Jev opponent is live on an unlisted build and I’m playing against it. Once the rough edges are off the picker, I’ll open it here on a separate page from the regular demo, so a broken experiment can never take the normal game down. You’ll pick your opponent on the new-game screen, choose a preset or write your own orders, and the HUD will tell you what you’re playing against.

My honest read so far: it plays differently every time in a way the state machine never did, and when it does something dumb, it’s dumb in a way you can argue with, because you wrote the orders. The rule-based AI is finally a fair fight on its own. With Jev driving it? Maybe the AI can give us a run for our money.

The current build already has V38 and V39 in it. As ever, play it and lose a round — but if the enemy finally beats you, that is not a bug report. That is the point.