Laya beat my Rust game. So did random picks.

I built a simple Rust game (not my first one) and wanted to see whether Laya could actually play it. I’d seen Jev playing Minecraft, and small-model demos in games like Snake. Time to test the hype in a game of my own.

The game gave me a fairly small problem to start with. Enter a room, kill the enemies, find the next room. Keep doing that until the whole floor is clear. No inventory management or elaborate quest to explain away a failure.

Goal: clear all combat rooms. Stay alive.
… Health: 3. Phase: combat.
Clearance now/goal, tiles: enemy 11.46/4; wall 0.1/2. Clearance goal unmet: yes.
Chaser 0: health 2, distance 11.46, aligned false.
Chaser 1: health 2, distance 22.03, aligned false.
Chaser 2: health 2, distance 15.56, aligned false.
…

Create space when clearance is inadequate; otherwise focus a nearby weakened chaser.

There was one neural model in this experiment. I ran the pinned English Laya checkpoint locally through MLX on Apple Silicon. Jev was part of the inspiration, not another player I tested. There was no game-specific training or fine-tuning. All the changes below are changes to prompts, action selection or the code around the same weights.

Auto-aim wasn’t enough

To know whether Laya was any good, I wrote two bots to beat. One followed deterministic Rust rules. The other picked legal actions from a fixed seeded random stream. Neither used a neural model.

All three got the same Rust aiming, the same doorway steering and the same short-action menu. Each command ran for at most ten ticks at 60 Hz, about a sixth of a simulated second. Then came another choice.

We ran them through the same ten maps, with the same physics and a 120-second simulated-time budget. Waiting for Laya did not use that time. The Rust bot cleared every floor without damage. Laya and random cleared none.

The Rust bot got there with fixed rules. It chose the least-visited destination and scored combat moves for space from chasers and walls, plus firing alignment. That was static geometry, not the physics-prediction controller built later.

In a different recorded fight near the south wall, Rust moved northeast while firing north. Ten ticks later, it had almost lined up with the chaser. Then it stayed and fired. Staying was useful in that position. It was lethal in Laya’s east-wall fight.

Random found a different way to fail. In one run, it kept changing destinations until its time ran out. It had not killed an enemy or cleared a room.

Laya cleared three isolated combat tests without damage. Rust did too. Random cleared them with damage. Laya could also cross a doorway or survive a short test. But on the full floor, it still died or ran out of time.

Maybe the prompt is bad

Laya was still dancing around the starting room. I suspected the prompt.

That was a reasonable place to look. Laya got the same dump every time: positions, enemies, exits and its last few actions. Much of it didn’t matter. In a fight, it still read about sealed doors it couldn’t use. While exploring, it saw how often it had visited each neighbouring room, but not whether a cleared room led anywhere new.

So I stopped sending a fixed dump. Before every call, the game code looked at what was happening and built the prompt from that. A small behavior tree does the looking, built with Bonsai, a Rust library. It checks whether the player is moving between rooms, fighting, or exploring, then picks what goes into the prompt. A fight gets enemies, walls and shots. Exploring gets the open doors and a map of the rooms the player has already seen, so Laya can tell a dead end from a door that still leads somewhere new.

That map holds only what the player has seen. It is not the hidden floor layout, and nothing was trained.

Clear every combat room. Explore open doorways. Stay alive.
Axes: east +x, south +y. Chasers hurt on contact.
tick=0 room=0 bounds=-16,16
player position=0,0 velocity=0,0 health=3
exit North position=0,-16 sealed=false visits=0

Choose the action that advances clearing ALL remaining combat rooms. Explore unmapped doorways or reach unexplored branches. Repeating cleared dead ends or waiting cannot win.

North option text:
Head North to explore an unmapped doorway; short step, then choose again; no fire

North option text:
Head North to explore an unmapped doorway; retain target until arrival or interruption; no fire

Together, the new prompt and the remembered map took wins from zero to one. Keeping the door won that same map again, and no other. Keeping a door only helps if it’s the right door, and neither change touched the fights.

Rewording the question didn’t help either. Asking straight out which door led somewhere new made Laya more sure about the useful doors, but it didn’t pick them any more often. That test, and two more, are in “The other prompt experiments” below.

Escaping one failure finds another

The fights were the bigger problem. My first guess was the words. Maybe “move north” was hard to use when the gun fires west, so I tried names like “sidestep right relative to aim”. The moves behind the names stayed the same. New descriptions fixed some bad choices and broke some good ones. New names were worse.

So maybe Laya couldn’t turn coordinates into facts. Rust could. The next prompts said things like “east is blocked” and “northeast slides along the wall,” plus whether a chaser stood in the firing line. They described the room right now. They didn’t say which move was safe.

Walls: north 11.83, south 20.17, east 0.35, west 31.65.
Chaser 2: 0.27 south, 0.95 west; motion 1.49 north, 5.3 east. Health 2.

Wall contact now: blocked moves east; sliding moves ne, se. Blocked moves can still fire.

Current West firing lane: nearest chaser 2 is inside it. Current geometry, not a hit prediction.

Wall contact now: blocked moves east; sliding moves ne, se. Blocked moves can still fire.
Current West firing lane: nearest chaser 2 is inside it. Current geometry, not a hit prediction.

The best version still made two new damaging choices. Here is one. At the east wall, the original prompt led Laya to pick north, and it took no damage. With the wall facts added, it picked northeast and got hit two ticks later.

Walls: north 11.83, south 20.17, east 0.35, west 31.65.
Chaser 2: 0.27 south, 0.95 west; motion 1.49 north, 5.3 east. Health 2.

Wall contact now: blocked moves east; sliding moves ne, se. Blocked moves can still fire.

A diagonal move splits its speed between two directions. The wall blocks the east half, so the player slides north slowly, and the chaser catches it. The prompt even said northeast would slide. Describing the room is not the same as knowing what each move does over the next few ticks.

On full floors, the wall facts stopped the deaths, but the bot ran out of time on nine floors instead. It was going in circles. Once it walked back into a cleared room it had already visited 153 times, while two other doors still led somewhere new. A short history of recent door trips didn’t stop it. The bot walked there just fine. Moving wasn’t the problem. Choosing where to go was.

Laya kept walking back into the same dead end because that door was always its top answer. But Laya doesn’t give just one answer. It scores every door. So what if the bot rolled dice weighted by those scores? A door with a lower score would still get picked now and then, and that might break the loop. I changed only that, and only while exploring. Fights still took Laya’s top answer.

The nine timeouts became nine deaths. The number of wins did not change.

The dice worked, in a way. The bot stopped circling cleared rooms and walked into new fights. That was the problem: walking in circles had been keeping it out of fights it couldn’t win. In one of those deaths, the player had one health and a chaser sat just over a tile to the south. Laya chose to move east, even though the prompt said to avoid contact. A twentieth of a second later, the run was over. Room revisits fell from 2,762 to 128, but dead bots stop revisiting rooms, so that isn’t progress.

The bot now failed in a new way, but it still failed. Better inputs, clearer wording and weighted dice had not taught short-action Laya to survive a fight.

Question:
Choose the action that advances clearing ALL remaining combat rooms. Explore unmapped doorways or reach unexplored branches. Repeating cleared dead ends or waiting cannot win.

West option text:
revisit a cleared room with no known unexplored branch

Room description:
No known unexplored branch without returning here.

Which doorway offers an unknown connection or a known route to an unexplored branch?

Before:
revisit a cleared room with no known unexplored branch

After:
revisit a cleared room; further exploration returns here

Before:
No known unexplored branch without returning here.

After:
Further exploration requires returning here.

Firing West:
north: Move north; fire West

north: Sidestep right relative to aim; fire.

sidestep_right: Move north; fire West

sidestep_right: Sidestep right relative to aim; fire.

Walls: right 11.83, left 20.17, behind 0.35, ahead 31.65.
Chaser 2: 0.27 left, 0.95 ahead; motion 1.49 right, 5.3 behind. Health 2.

Prompt excerpt:
Recent room crossings: room 0 -> room 2; room 2 -> room 0; room 0 -> room 2; room 2 -> room 0.
Entered current room 0 through North doorway from room 2.

Laya picked: North, the way back, even though South was unexplored.

What were the Snake and Minecraft bots doing?

I went back to the motivation for the experiment. I’d seen Jev play Minecraft. Why couldn’t Laya consistently complete these much simpler rooms?

So I read the code behind the public Snake and Minecraft bots I could find. I couldn’t find an official TypeSafe one, so these are all community projects. The results below are what their builders reported. I didn’t rerun them.

The Laya Snake port has the strongest result. It ran 8,160 moves with zero deaths, and the safety check overruled Laya only four times. But its planner had already labelled the best move in every list, so that’s a result for planner plus Laya. It also used the multilingual version of Laya, not the English one I used.

The ellistev Minecraft bot is the closest match to my experiment, because its builder tried both ways. When the model picked whole tasks, the bot built a 338-block flag in 590 seconds with 131 decisions. When the model steered every quarter-second step, the same flag took 801 seconds and 1,848 decisions, and the README says the bot can wobble back and forth and get stuck.

A bug report on Laya’s own GitHub shows the same limit from the other side. Each option already said what would happen. Laya still gave right a 53% score, even though the text for right said the snake would hit the wall and the game would end. The maintainer replied that Laya is “a single-pass classifier, not a planner”: it reads the options once and scores them, without thinking ahead. His fix was to remove the deadly moves in code. That report used the multilingual version too.

My short-action bot had none of that help. Nothing removed deadly moves before the question, nothing caught them after, and nothing marked the best option.

I hadn’t specialized Laya for this game, and none of this shows what happened inside the model. But it told me what to try next.

So the next change gave Laya bigger things to choose. Not new names for the same tiny moves, but whole tasks, with Rust doing the walking.

Give it a goal, let Rust drive

So I gave Laya bigger choices. Instead of a direction, it now picked a goal: fight this chaser, get some room, or go explore that unexplored door. Rust kept the goal and did the moving.

That’s a lot more help than aiming the gun and lining up with doors. It changed Laya’s job. The model stayed the same, and nothing was trained.

Fighting a chaser meant Rust kept that target, moved to where it could hit it, fired, and stayed out of reach. Laya no longer had to pick northeast, then stay, then northeast again just to line up one shot.

Getting room had no target. Rust moved away from enemies and walls and kept shooting at whatever was closest.

For both, Rust tried all nine moves every tick and played each one forward about a fifth of a second, using the game’s real movement and combat code. Staying alive came first. After that, a fight move scored on lining up shots on its target from a useful distance, and a room move scored on how much space it bought.

Exploring changed too. Laya now picked an unexplored door anywhere on the map the player had seen, even a few rooms away. Rust found the way there through rooms it already knew and walked the whole trip without asking again.

Rust still didn’t see the hidden map, and it never swapped Laya’s choice for its own. But “move northeast for a moment” had become “kill this chaser without getting hit.” Dodging, positioning and finding the way were now code’s job.

The skill version pushed that idea further. Before every call, code rebuilt the whole question from the game state: what Laya read, what it was asked, and which answers existed at all. An answer only appeared if Rust could carry it out right then. The create_space answer showed up only while the player was too close to a wall or an enemy. A dead chaser’s focus answer disappeared.

That meant the comparison had to change too. Pitting this bot against the old random bot would give Laya credit for all the new Rust code. So all three bots got exactly the same skills, and only the picking differed.

The fixed-rules bot got new rules for picking goals. It got room when it was too close to something. Otherwise it went for the nearest chaser it could kill in one hit, or just the nearest one. When exploring, it picked the unexplored door with the fewest rooms to cross. The skills did the moving.

Random picked evenly from whatever skills were on offer. It ran five times on each of the ten maps, with different dice each time. That’s fifty runs, but still only ten maps.

Laya cleared all ten floors. Fixed rules cleared all ten. Random cleared all fifty runs. None of the seventy runs took a single hit.

Random was choosing chasers and doors now, not moves. Earlier, random could turn back from a door almost immediately or step the wrong way next to an enemy. Now a random chaser came with Rust code that approached, shot and dodged. A random door came with a route that got there. And random only ever saw answers that made sense right then, because code had already removed the rest. Each skill had a time limit, but it ran long enough to get real work done before the next choice.

The bot worked. I still hadn’t shown why it needed Laya.

Laya won no more floors, and it was 8.4% slower than fixed rules, comparing each map with itself. It was no faster than random either.

Those are game-time numbers. The game pauses while Laya thinks, so they leave out the waiting. The fixed-rules and random bots never wait at all, because they don’t call a model.

The game now

The game has changed since September, so these clips illustrate the controls rather than reproduce the comparison. The current skill trace won once, in 20.35 simulated seconds with nineteen model calls and no damage.

The historical results also came from development maps that we’d already used to diagnose failures. Held-out worlds remained unused. Reliable on those ten worlds is the result we have, not a claim about every floor the generator can produce.

Takeaways

What the working demos do

1. Compute the geometry in code. The Snake demos compute dead ends, reachable cells and the route to food before they ask. TypeSafe’s Jev guidance says it plainly: “Keep the arithmetic in code.” My first bot sent coordinates and wall distances.
2. Remove or replace fatal choices. The Jev Snake removes fatal moves before the question. The Laya Snake shields the answer after it. My short-action bot had neither, so the fatal stay at the east wall went straight through.
3. Offer actions that already work. In Minecraft, “travel to the waypoint” calls a pathfinder. Our skills became the same kind of action.
4. Let code check every tick. The Minecraft breath reflex can cancel an action on any physics tick without asking the model. My game paused during inference, so latency was never the problem. A short-action combat move ran for up to ten ticks. Rust stopped it after damage or a room change, but never predicted danger and picked a safer move. The skill controller does that every tick.
5. Send only the facts the question needs. In the Laya-vs-Jev arena’s Flappy Bird game, a state that described both the gap and the bird made Laya answer with the bird’s position, 0/6. Describing only the gap gave 6/6.
6. Show how much the code does. The Laya Snake port counts shield interventions. ellistev labels direct and high-level runs separately. Our fixed and random baselines do the same job: they show what the code achieves without the model.

All of these demos gave the model more help than my first bot had. For the skills, I borrowed the high-level Minecraft design. The model picks a goal, and code handles the movement.

What our prompt changes actually did

The version that worked did two things together, so I can’t split the credit:

• Ask for goals, not movement. Bounded skills cleared 10/10 floors with no damage, against 0/10 for short actions.
• Rebuild the whole question from the game state before every call. Code chose what Laya read, what it was asked and which answers existed. Laya never saw an answer Rust couldn’t carry out right then. One of the Minecraft demos does the same: gathering and building offer different actions.

Three changes helped a little. Two of them also broke cases that used to work:

• Phase context and a discovered map. Together they raised floor wins from 0/10 to 1/10. I changed both at once, so I can’t split the credit.
• Blocked moves in words. “East is blocked” and “northeast slides along the wall” took recorded states from 38/47 to 42/47 damage-free, with two new damaging choices. On full floors, deaths fell from 4 to 0, but wins stayed at 1/10.
• Enemy-relative descriptions. Damage-free states went from 38/47 to 41/47, with three new damaging choices.

Three changes did not help. A narrower exploration question raised the probability on useful doorways from 76.65% to 81.07%, but picked correctly in the same 27 of 32 states. Relative action IDs dropped combat from 38/47 to 27/47 damage-free. Recent crossing history took floor wins from 1/10 to 0/10.

These habits kept the results honest:

• Test wording on frozen states with a no-new-damage rule. It exposed the regressions above, which better totals would have hidden.
• Change one thing at a time. IDs, descriptions and option order each moved results. Reversing the exploration option order fixed three states and broke two.
• Don’t ask when there is only one answer. In the first campaign, 3,590 of 6,817 calls offered only a forced wait. The skill version skips those calls.
• Fit the prompt without cutting it. The English checkpoint reads 512 tokens per question. A preflight check rejects a shortened option or a cut instruction, then checks the real tokenized input. Skill prompts used 150 to 249 tokens.

The combat question that worked was short. It asked for one judgment, and every option named something Rust could finish:

Create space when clearance is inadequate; otherwise focus a nearby weakened chaser.

focus_0: Retain 0; position/fire to defeat
create_space: Seek clearance; nearest fire

I started with a model choosing small movements and Rust helping it aim. I ended with the same model choosing goals and Rust working out how to accomplish them. The second bot won. Then random picked its goals, and it kept winning.