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 play Minecraft, and small models play games like Snake, so I wanted to test that hype on a game of my own.

I kept the game small on purpose. You enter a room, kill the enemies and find the next room, until the whole floor is clear. There’s no inventory and no long quest, so when a bot fails, there’s nothing else to blame.

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.

This experiment had one neural model in it. I ran the exact English Laya version linked above on my own Mac, through MLX on Apple Silicon. Jev was part of the inspiration, but I never tested it. I did no training or fine-tuning for the game. Every change below is a change to the prompt, to how the answer turns into an action, or to the code around the same weights.

Auto-aim wasn’t enough

To know if Laya was any good, I needed something to compare it with, so I wrote two bots with no model at all. The rules bot follows a few plain Rust rules and always does the same thing in the same situation. The random bot picks from the allowed actions at random, using a fixed sequence of random numbers so every run can be repeated.

All three bots got the same help from Rust: the same aiming, the same steering through doorways and the same menu of short actions. Each action ran for at most a sixth of a second of game time (ten physics steps, at 60 a second), and then the bot chose again.

I ran all three on the same ten maps, with the same physics and a limit of 120 seconds of game time. Time spent waiting for Laya didn’t count against that limit. The rules bot cleared every floor and never took a hit. Laya and the random bot cleared none.

Its rules were simple. When exploring, it went to the room it had visited least. In fights, it scored each move on how much space it left from chasers and walls, and on lining up a shot. That was just the shape of the room at that moment. It didn’t predict the physics like the controller I built later.

In a different recorded fight near the south wall, the rules bot moved northeast while firing north. A sixth of a second later, it had almost lined up with the chaser. Then it stayed still and fired. In that spot, staying was useful. In Laya’s east-wall fight, staying killed it.

The random bot failed in a different way. In one run, it kept changing where it was going until time ran out. It never killed an enemy or cleared a room.

In three small fight tests, separate from the full game, Laya cleared the room without taking damage, and so did the rules bot. The random bot cleared them too, but took damage. Laya could also walk through a doorway, or survive a short test. But on a full floor, it still died or ran out of time.

Maybe it’s my prompt

Honestly, most of the time Laya was just dancing around in the starting room. At that point, I was pretty sure the problem was my prompt.

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

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

The map holds only what the player has seen, not the hidden layout of the floor, 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 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.

Asking the question a different way didn’t help either. When I asked straight out which door led somewhere new, Laya gave the useful doors higher scores, but it didn’t pick them any more often. That test and two others are in “The other prompt experiments” below.

Fix one failure, find another

The fights were the bigger problem. My first guess was the words. Maybe “move north” was hard to use when the gun was firing west, so I tried names relative to the gun, 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 made it worse.

So maybe Laya couldn’t turn coordinates into facts. Rust could. The next prompts added lines like “blocked moves east; sliding moves ne, se”, plus whether a chaser stood in the firing line. They described the room right now. They never said 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 choices that took damage. Here’s one. The player had its back against the east wall, and a chaser was about one tile away, closing in from the west. With the original prompt, Laya picked north, ran straight up along the wall and took no damage. With the wall facts added, it picked northeast and got hit a thirtieth of a second 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 northeast is really just a slow north, and the chaser catches up. The prompt even said northeast would slide, but it never said what sliding means here. To get from “slides along the wall” to “slow north, and the chaser catches me”, you have to think it through, and Laya reads the prompt once and scores the answers. Every word I added was true, and it still made this fight worse. Describing the room is not the same as knowing what each move does over the next few moments.

On full floors, the wall facts stopped the deaths, but now the bot ran out of time on nine floors. It was walking in circles. At one point, it walked back into a cleared room it had already visited 153 times, while two other doors were still unexplored. Adding a short list of its recent door trips to the prompt didn’t stop it. The bot walked to each door just fine. Moving wasn’t the problem. Choosing where to go was.

Laya kept walking back into the same cleared room because that door was always its top answer. But Laya doesn’t give just one answer. It scores every door. So I had an idea: what if the bot picked a door at random, 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. In fights, the bot still took Laya’s top answer.

The nine floors that ran out of time became nine deaths. The number of wins didn’t change.

So the weighted pick 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 away from fights it couldn’t win. In one of those deaths, the player had one health left and a chaser was just over a tile to the south. The prompt said to avoid contact, and Laya chose to move east anyway. A twentieth of a second later, the run was over. Room revisits fell from 2,762 to 128, but dead bots don’t revisit rooms. Technically I fixed it. It just isn’t progress.

The bot now failed in a new way, but it still failed. Better inputs, clearer wording and a weighted random pick had not taught Laya to survive a fight while it picked its own short moves.

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.

How do the Snake and Minecraft bots do it?

Going in, I’d have argued Laya was the more advanced model, ahead of Jev. So this made no sense to me. I’d seen Jev play Minecraft, so why couldn’t Laya clear these much simpler rooms every time?

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

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 result belongs to the planner and Laya together. 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 it 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. The README says direct control can stall, and the bot can briefly wobble back and forth.

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. He suggested removing the deadly moves in code. That report used the multilingual version too.

My short-move bot had none of that help. Nothing removed deadly moves before the question, nothing caught them after, and nothing marked the best option. I was using the wrong tool for the job.

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

So I did what the demos do. Instead of new names for the same tiny moves, Laya would pick whole tasks, and Rust would do the walking.

Laya picks the goal, Rust does the rest

Instead of a direction, Laya now picked a goal: fight this chaser, make some space, or go explore that door. Rust held on to 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.

To fight a chaser, 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.

Making space had no target. Rust moved away from enemies and walls, and kept shooting at whatever was closest.

For both goals, Rust tried all nine moves, 60 times a second. It played each move 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 space move scored on how much space it bought.

Exploring changed too. Laya now picked an unexplored door anywhere on the part of 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 Laya 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 the code’s job.

The skill version went one step 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 showed up 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. When a chaser died, its focus answer disappeared.

That meant the comparison had to change too. If I put this bot against the old random bot, Laya would get the credit for all the new Rust code. So all three bots got exactly the same skills, and only the picking was different.

The rules bot got new rules for picking goals. If it was too close to something, it made space. 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 walk through. The skills did the moving.

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

Laya cleared all ten floors. The rules bot cleared all ten. The random bot cleared all fifty runs. Not one of the seventy runs took a single hit.

The random bot could win now because it was choosing chasers and doors, not moves. Before, it could turn back from a door almost right away, or step the wrong way next to an enemy. Now a random chaser came with Rust code that walked up, shot and dodged. A random door came with a route that got there. And the random bot 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.

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

Laya won no more floors, and it was 8.4% slower than the rules bot, comparing the two map by map. It was no faster than the random bot either.

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

The game now

The game has changed since September, so these clips show how the controls work. They don’t repeat the comparison. In the current game, the skill version won once, in 20.35 seconds of game time, with nineteen calls to Laya and no damage.

The September results also came from development maps, the same maps I’d already used to figure out what was going wrong. I had fresh maps held back, and I never used them. So the result I have is: reliable on those ten maps. It’s not a claim about every floor the game can generate.

Takeaways

What the working demos do

1. Do the geometry in code. The Snake demos work out dead ends, reachable squares and the route to food before they ask the model. TypeSafe’s Jev guidance says it plainly: “Keep the arithmetic in code.” My first bot sent raw coordinates and wall distances.
2. Remove or replace deadly choices. The Jev Snake removes deadly moves before it asks. The Laya Snake checks the answer afterwards and swaps it if it’s deadly. My short-move bot did neither, so the deadly stay at the east wall went straight through.
3. Offer actions that already work. In Minecraft, “travel to the waypoint” calls a pathfinder, code that finds the route. My skills became the same kind of action.
4. Let code keep checking. The Minecraft dragon’s breath reflex can cancel an action at any moment, without asking the model. My game paused while Laya thought, so speed was never the problem. A short fight move ran for up to a sixth of a second. Rust stopped it after damage or a room change, but it never predicted danger and picked a safer move. The skill code does that 60 times a second.
5. Send only the facts the question needs. In the Flappy Bird game from the Laya vs Jev arena, a description of 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 how often its safety check stepped in. ellistev labels direct-control runs and task runs separately. My rules bot and random bot 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 task-level Minecraft design: the model picks a goal, and code handles the movement.

What my prompt changes actually did

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

• Ask for goals, not moves. Skills with time limits cleared 10/10 floors with no damage, against 0/10 for short moves.
• 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:

• A prompt built for the situation, plus a remembered 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. The line “blocked moves east; sliding moves ne, se” took saved fight moments from 38/47 to 42/47 without damage, with two new choices that took damage. On full floors, deaths fell from 4 to 0, but wins stayed at 1/10.
• Moves described relative to the gun. Moments without damage went from 38/47 to 41/47, with three new choices that took damage.

Three changes did not help. A narrower exploring question raised Laya’s score on useful doors from 76.65% to 81.07%, but it picked correctly in the same 27 of 32 moments. Naming the moves relative to the gun dropped fights from 38/47 to 27/47 without damage. A list of recent door trips took floor wins from 1/10 to 0/10.

These habits kept the results honest:

• Test wording on saved moments, with a rule against new damage. It caught the cases above that got worse, which better totals would have hidden.
• Change one thing at a time. Names, descriptions and the order of the options each moved the results. Reversing the order of the exploring options fixed three moments and broke two.
• Don’t ask when there is only one answer. In the first set of runs, 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 version reads at most 512 tokens (word pieces) per question. A check before sending rejects a shortened option or a cut-off instruction, then checks the real input after it’s split into tokens. Skill prompts used 150 to 249 tokens.

The fight question that worked was short. It asked for one judgment, and every answer 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 moves and Rust helping it aim. I ended with the same model choosing goals and Rust working out how to reach them. The second bot won. Then the random bot picked its goals, and it kept winning.