Post training Inkling 2 Small
to run a railway

The job

Between Leeuwarden and Groningen, in the north of the Netherlands, runs 55 km of mostly single track. Trains going opposite ways can only pass each other at stations with two tracks. Eight trains an hour share it. When something goes wrong (a broken-down train, a collision at a level crossing, a signal failure) a dispatcher has a few minutes to re-plan the next three hours: hold this train at that station, turn that one back early, cancel another.

RailSimEnv (bpHigh, 2026) turns real days from 2025 into that job. It is an OpenEnv (Meta PyTorch, 2025) environment rebuilt from the public record of every train on the line (Rijden de Treinen, 2025), and it grades every plan against the best plan possible, proven by a solver. We took Thinking Machines’ newest small model, Inkling 2 Small, measured it, and fine-tuned it on the environment with reinforcement learning through the Tinker API (Thinking Machines Lab, 2026).

The environment

What the model sees and does

Each task is one real disruption window: the line as it stood at that minute, every train’s timetable and position, the closure or the lost passing track, and the train sets that work chains of runs. The model plans every train with three levers: hold it at a station until a minute, short-turn it at Hurdegaryp, Buitenpost or Zuidhorn (and start its set’s next run from there), or cancel it. Trains it leaves alone run as early as the physics allow, never ahead of the timetable.

It has three tools. get_situation() describes the line, the closures and every train. check_plan(plan) simulates a draft and lists every train’s times, every rule it breaks and the cost; it can be called ten times. submit_plan(plan) ends the episode with one grade.

How a plan is scored

The cost is counted in stop-minutes stop-minutes One minute of delay at one stop served. A stop not served at all costs 30, and lateness handed on to the next window counts too. , the delay passengers feel. A solver (CP-SAT from OR-Tools (Perron & Furnon, 2024)) has proven the cheapest possible plan for every task, so the reward is honest:

• a plan that breaks any rule scores below 0.2;
• a legal plan scores 0.2 to 1.0, and 1.0 means it matched the proven optimum.

The 45 evaluation tasks were chosen for hardness from days the training tasks never use¹. Larger models do fine but not great on them, and a simple rule-based dispatcher stays near 0.2:

The model and the training loop

Inkling 2 Small (Thinking Machines Lab, 2026) is a mixture-of-experts model from Thinking Machines Lab: 594 billion parameters, 17 billion active per token. Tinker trains a LoRA adapter on it (Hu et al., 2021), a small set of extra weights, while Thinking Machines runs the hardware. We used rank 8 throughout.

The loop is plain policy-gradient reinforcement learning with group-relative advantages, in the spirit of GRPO (Shao et al., 2024):

1. pick a handful of training tasks;
2. let the model play each one 4 times with the current weights;
3. compare the four scores: attempts that beat their siblings are pushed up, worse ones pushed down;
4. one optimizer step, then repeat with the new weights.

Every token the model wrote in an episode (its reasoning, its tool calls, its final plan) is one training sequence, and the reward is the environment’s own score.

Round 1: a 64K context and 8K words a turn

Tinker’s standard Inkling 2 Small has a 65,536-token context. A single check_plan report can be 10,000 tokens, so we gave the model 8,192 tokens of output per turn, at its default reasoning effort (“high”).

Before training: 0.119

That is below the rule-based dispatcher. Reading the transcripts showed why: the model thought too long. A third of its turns hit the 8,192-token limit in the middle of reasoning, before it called any tool, and 11 of 45 episodes ended without a plan at all.

The obvious fix, maximum effort instead of high, made it worse: 0.111, with 21 episodes ending without a plan. More thinking in the same small box only meant running out of room sooner.

After 23 steps of RL: 0.186

On the same 45 tasks the trained model is better by +0.067 per task (95% interval +0.024 to +0.115, comparing each task with itself), better on 30 tasks and worse on 12. What it learned is clearest in how it behaves:

It learned to budget: shorter reasoning, more drafts checked, always a plan at the end. The plans themselves improved much less. That is typical of what reinforcement learning finds first, the cheapest way to stop losing rewards.

Round 2: give it room to think

If the problem was room, the fix was room. Tinker also serves Inkling 2 Small with a 262,144-token context (256K, as Tinker lists it: 256 × 1,024). We ran it at maximum effort with 32,768 output tokens per turn.

Before any training: 0.259

More than double the 64K baseline, and better than the model we had just trained. 25 of 45 plans were legal (9 before) and two matched the proven optimum. The lesson of round 1 held: the bottleneck was the budget, not the model.

After 12 steps of RL: 0.316

Episodes here are about 143,000 tokens long, so each step played 8 tasks × 4 instead of 16 × 4. After 12 steps the fine-tuned model scores 0.316: +0.056 per task, better on 22 tasks, worse on 13, the same on 10. This time it was not about budget (the model already submitted almost every time) but about plan quality. Legal plans now cost 23 % more than the optimum on the median, against 37 % before, and three reached the optimum.

Watching it on the line

Averages hide what a dispatcher actually does. Here are three tasks, before and after the second round of training, on the environment’s train graph (time across, the line from Leeuwarden down to Groningen) and in its 3D replay. Every plan below is the one the model submitted, replayed exactly as it was graded; all of them can be replayed on the RailSimEnv Space, first tab.

13 March 2025, 07:01: a broken-down train

A real breakdown closed Leeuwarden - Hurdegaryp from 07:01 to 08:00, with 26 trains to plan.

The difference is a decision a human dispatcher would recognise: when a section is closed for an hour, do not queue trains in front of it, turn them back where they can be turned and keep the rest of the timetable intact. The base plan’s queue does not hurt during the closure; it hurts two and a half hours later, when the delayed trains collide with the timetable coming the other way.

16 February 2025, 17:00: litter on the track

Litter on the track closed Buitenpost - Groningen from 17:10 to 18:42: half the line, in the evening rush.

31 May 2025, 09:00: where training made it worse

Not every task improved. A defective track closed Leeuwarden - Hurdegaryp from 09:30 to 09:56, a short closure.

What we noticed

Reinforcement learning learns the easy lesson first

On the 64K model nearly all of the gain was “stop running out of tokens, always submit a plan”: useful. On the long-context model, where that lesson was already learned, the gains came more slowly and were about the plans themselves: fewer cancellations, more short-turns, cheaper legal plans.

Small samples mislead in both directions

Training batches draw different tasks every step, so a batch swung from 0.18 to 0.38 by luck. The 16 held-out tasks and the 45 evaluation tasks sometimes disagreed. Comparing the same tasks before and after¹, rather than two averages, was the only reliable way to see an effect, and even that leaves the second round’s gain on the edge.

The model found a bug in the grader

During training the model tried a plan that starts a train at its own final station, leaving nothing to run. The simulator crashed instead of calling it a broken rule. Reinforcement learning is very good at finding the corners of an environment that nobody tested. The fix and a test for it went in the same night.

Some habits never changed

Every episode, before and after training, begins by calling get_situation, though the situation is already in the first message. Each call costs about 4,000 tokens of context, and neither round of training removed it.

What it took

All of the training ran on Tinker; the loop, the environment and the grader ran on one small cloud machine. In tokens and time:

Each evaluation of 45 tasks took 7 minutes at 64K and 30 minutes at 256K, with all 45 episodes in flight at once. At 256K most of the training cost is training itself: the sequences are three times longer and long-context training is priced higher per token.

What’s next

1. Train longer at 256K: round one needed about a dozen steps before anything moved; round two stopped at twelve.
2. Teach the length of a closure: the 31 May regression suggests the model has not learned when waiting beats turning back.

Try it

Everything is open:

• The environment and its tasks, on the RailSimEnv Space: an OpenEnv server you can connect an agent to, an eval explorer, a train graph, and a 3D replay whose first tab plays every Inkling 2 Small plan from this post.
• The code on GitHub: the environment, the Tinker harness and the training loop (railsim-v1/train/train_rl.py), and every evaluation run with each plan the model submitted.

Data and credits

Train services, delays and disruptions: Rijden de Treinen open data (CC BY 4.0) (Rijden de Treinen, 2025). Map: © OpenStreetMap contributors (ODbL) (OpenStreetMap contributors, 2026). Inkling 2 Small and Tinker: Thinking Machines Lab (Thinking Machines Lab, 2026b, 2026a).