Bets worth making

Cold open

Science output has halved, and the graph shows you where it dropped without showing you why. So you build more circuit assemblers. Nothing changes; the new ones just wait. Twenty minutes later you find it: the copper smelters share a belt with iron, the iron gets there first, and the cable assemblers are starving three steps upstream of where you were looking.

A tool that names the cause

The dataset's record for production chains lists this as one of the mechanic's failure modes: when starvation happens far upstream, players blame the wrong building. It also lists why the hunt never ends: the slowest stage sets the pace, so the bottleneck moves every time you fix one.

A tool that answered the question directly wouldn't need new AI. Add a little capacity to each machine and belt in turn, and measure how much the output rises. The one that raises it most is the constraint. Then a short generated sentence names it: circuits are limited by copper cable, which is starved because the smelters share a belt with iron.

That's one of the bets in the dataset, the bottleneck explainer. Production chains are among the most common mechanics in the catalog, and no technique in the dataset points at them.

What a bet contains

The dataset holds 42 bets like this one, and every one fills in the same fields. It names the mechanics it reworks and the techniques it depends on. It names games that already do part of it: for this one, Factorio, Satisfactory, Anno 1800, and Oxygen Not Included.

Two more fields make it a bet. An experiment a small team could run, with a number that counts as success: inject a bottleneck into a factory prototype, and see whether players fix it at least fifty percent faster with the view on. And a prediction with a date: a factory or city game ships a feature that finds the binding constraint by testing the simulation, by the middle of 2028.

Each bet is scored for impact, feasibility, and novelty, and the three combine into a priority that punishes a low score on any one of them. The scores are one model's reading of written anchors, so treat the ranking as an ordering of arguments. What the table does show is how near the bets are: 18 are buildable now, 19 in one to two years, and 5 in three to five.

The why button

The top of the table is the why-query. Overlays and tooltips tell you why a number is low right now. Nothing in a typical game tells you why the hospital closed three months ago. That's a chain of events, and the bet is to record those events with their causes and let a language model narrate the chain, with every sentence linked to an event in the log.

The output is constrained so the model can only say things it can point to, and an answer it can't ground says so. Many engines already keep an event log for replays and debugging. The bet is that showing it to players, through a "why?" button, lets designers ship deeper systems without losing people.

The experiment gives two groups the same failing save, one with the button and one without, and has people check whether the cited events actually support each sentence. Success means a correct diagnosis forty percent faster, with at least ninety-five percent of the sentences supported.

A fluent answer that isn't grounded teaches players a wrong model of the game, which is worse than no answer. Most shipped event logs don't record causes, and adding them is real engineering. And a perfect explainer might make the best move too easy to find.

Previewing the future

Second on the list is a branch preview. Before you pass a law, the game copies the live save dozens of times, runs each copy a year ahead with different random seeds, and shows you the spread. Because a deterministic simulation can fork from any moment, the preview runs the game's own rules. The target: sixty-four futures in under five seconds on an ordinary PC.

A colonist with a memory

Another bet near the top goes back to the cook from episode 1. Most of what a colonist does is routine: eat, sleep, haul. Cheap rules handle that. The memorable moments are rare, a death, an insult, a breakdown. So keep the rules running every tick, and call a language model only when something crosses a threshold of importance.

The model's answer has to fit a schema: a thought with a mood value and a duration, maybe a change to a relationship, maybe one spoken line. It lands in the same list that explained her breakdown. The test caps the model at one call per colonist per in-game hour and measures believability in blind playtests, tokens per player-hour, and contradictions, like a colonist mourning someone who's still alive. Success needs a point of believability on a seven-point scale, under two thousand tokens per player-hour, and fewer than one contradiction an hour.

Mods from a sentence

Mods keep simulation games alive for decades, and writing one takes programming skill. Language modding turns a rule change into a sentence. A model writes the change against the game's own modding interface, agents test it on a headless map for crashes and for the effect you asked for, and the description, the code, and the test results travel together when you share it. The experiment takes a hundred real requests from a modding community. It counts as a success if at least sixty percent compile, pass the test, and do what the person asked.

The pattern

The bets at the top of the table share one design. None of the leading bets asks a learned model to become the simulation. The state stays symbolic and deterministic, and models work around it. They read it and explain it. They propose changes that a validator accepts or rejects. They decorate it, writing the line a character says without deciding whether she lives. And every call goes into the log.

What has shipped mostly stays at the edge of game state. And the economic core of these games, production, logistics, money, has almost nothing pointed at it. Bets that keep the core symbolic can ship on techniques that already work.

Long shots

At the far end are the long shots, each scored low for feasibility and high for novelty. A city builder that keeps its state as a tile grid and lets a generative model draw it in any style. A terrarium of hundreds of language-model agents that you seed, nudge rarely, and watch write their own history. And a search over rule programs that proposes new mechanics, checked against the catalog in this series for what already exists. That last prediction runs the longest, to December 31, 2030.

Who builds what

The bets sort by who can make them. A small studio has the ones that are feasible now: an explanation layer over a game it already has, events generated against a schema, colonists with a local model, balance testing before launch. An engine or tools company has the infrastructure, starting with an event log that records every model call. A research group has the open problems, like proving that a generated picture of a city matches the city's actual state.

Close

Every one of the 42 bets in the dataset carries a date, and the first ones come due on December 31, 2027. Before that, the next episode is about how these ideas fail: the desync, the contradiction, and the bill.