Contents
A gait learned in a training ground outside the gameYears spent getting one gait rightWhat a game can't do, and what it canLimitsHalf of putting it in a product is building toolsReferencesIf you play Arc Raiders, you often see a legged robot called the Leaper lunge in as if it were angry, botch the landing, tumble over, then pick itself up and come after you again. It looks clumsy more than cool, yet somehow that clumsiness makes it seem more alive. An enemy that just plays back set animations doesn't fall over like that.

A giant legged ARC in Arc Raiders. Image: Embark Studios, official media kit.
Maybe that's why, after launch, a story went around the community that the ARC robots get smarter as they fight players. I got curious about how these robots walk, so I went looking for what the developer, Embark Studios, has said about it themselves. My main sources are Learning to Move, the talk machine learning research lead Martin Singh-Blom gave at GDC in March 2026 (GamesRadar+'s write-up from someone who attended), an 80.lv interview from the same month, and a 4Gamer report that covered his June talk at NDC26, Nexon's developer conference, in detail. I filled in a few details from other coverage. I haven't watched the talks themselves, so every fact in this post rests on statements quoted in those articles.
What surprised me most was how long walking alone took. According to Singh-Blom, five to ten people worked for years to reach today's level, and the system came close to being cut several times along the way. Here are the reasons up front. The moment the team chose to move enemies with physics, it inherited the balance problems of robotics, and a decent gait only came from hand-balancing 10 to 15 rewards. Teaching one network both to walk and to stop made the robot hesitate as if scared, and every change to the gait's look cost weeks to months. Even after the robots walked well, their eyes couldn't see inside a tunnel.
The ARC robots did learn to walk through reinforcement learning, but that learning happens in the team's offline simulations and ships with updates; the robots don't learn by watching players during a match. And machine learning's job is much narrower than you might think. It doesn't decide where to go, only how to place the feet.
A gait learned in a training ground outside the game
In the 80.lv interview, Singh-Blom said it's true the robots can feel like they're picking up new tactics, but it doesn't work the way people think. We're not doing online learning or anything like that. Nothing is learned while the game is running.
The actual order goes like this. When the team spots an interesting behavior in videos posted on places like YouTube, they build a separate, controlled training scenario that makes the behavior show up more often. They don't train on one fixed layout; they randomize things like where objects are placed, which makes the behavior more robust. Training only on real gameplay records, he said, could mean the behavior falls apart as soon as a level changes a little.
The path to a smarter robot runs through the team's training ground, not the game server.
So as I see it, if you felt the robots had become cleverer, it's because the team learned something and retrained them, not because the robot in your game did. And that's the more interesting part. The clips players upload become material for the next training scenario.
Why did walking need to be learned in the first place? In most games, an enemy's walk is a motion clip made by an animator, played back. A clip moves only as scripted, so you always know exactly where the enemy will be, and it doesn't react when it bumps into something.
Embark chose a different direction early on. According to the NDC26 talk, the team wanted replayability and emergence, with something new happening every match, big walking robots that anyone would find cool, and physicality with real weight. A physics simulation gives a slightly different result every time, so you get a different scene each match without repeating a script. The 80.lv interview has a good example. If you blast an enemy into a wall, the impact with the wall can do more damage than the shotgun did and make it explode.
The catch was the price. As Singh-Blom put it, once you make your enemies physical robots, you run into exactly the same problems as robotics, even inside a simulation. The body has to move its legs while keeping its balance so it doesn't fall over. For the flying drones, traditional control techniques were enough, as with real drones, but for the legged robots the team couldn't find another way. So they went to the research literature on controlling real robots.

ANYmal D, a real four-legged robot inspecting a substation. The walking of machines like this is what the robotics literature Embark turned to is about. Photo: Cvoellmy, CC BY-SA 4.0, Wikimedia Commons.
He said it also gave them confidence that, when the studio was just starting out, papers on moving physics-based characters through learning were already out. The example in the talk was DeepMimic (Peng et al., 2018), which uses reinforcement learning to make a character imitate motion made by people.
The skeleton of reinforcement learning is simple. A neural network called the policy outputs an action as numbers, and the robot carries out that action in the simulation. The world changes (it moves forward, lifts a leg, falls off an edge), and the robot observes the result and passes it back to the policy. The policy looks at the observation and picks the next action. The reward tells it what a good action is. At every step you measure a reward the researchers defined, and nudge the network toward whatever makes the reward bigger.
Here is how the early demo was set up, as described in the NDC26 talk. It was built by putting game assets into a Unity test environment. The observations were the angle of each joint and the distance and angle to the target player. The actions were target angles for the PD controller on each joint. The motors turn the joints to those angles.
The policy sets the angles, physics sets the outcome, and the reward sets the direction of the next round of learning.
GamesRadar+ described this setup as the robots chasing players to get rewards, but the reward here is the yardstick for adjusting the policy during training, not a score handed out during play. Once a robot ships, its neural network doesn't change anymore.
Singh-Blom drew a clear line around how much machine learning handles. The machine learning part is actually more limited than people think. Machine learning is used only for where the robot places its feet and how it moves, that is, locomotion. Higher-level decisions like where to go and what to do are made by traditional systems such as behavior trees.
A box is a good example of where the line falls. When there's a box in front of the robot, the behavior tree decides it wants to move forward, and the locomotion system decides whether to step over the box or go around it.
The behavior tree handles the what, the locomotion policy the how.
So where does the intelligence players sense come from? Singh-Blom's answer was that most of it comes from the decision to make everything physical. The enemies seem smart because they live in a world where they move with the same degrees of freedom as real objects, and they were designed from the start to correct themselves within it. Instead of having them memorize patterns, the team set down principles for why an enemy moves the way it does, and that makes them look intentional.
Years spent getting one gait right
At first there were three rewards: points for closing the distance to the target, points for standing upright, measured as the cosine of the angle between the body's up direction and the world's up direction, and points for facing the player. That alone got the robot moving toward the target, and the goal of emergence was met. But the walk was floaty and unstable, not what they wanted from it as animation.
Then came the days of turning dials. They tuned how stiff each joint was, the strength and damping of the motors, the ratios between rewards, an extra reward for using less energy and its weight. They also built a lot of software to manage the experiments. That got them to a fairly decent walk that could stand up on its own and walk through rain. By then there were 10 to 15 rewards, and they had to be balanced against each other perfectly.
Reward terms mentioned in the talks and coverage. The actual weights weren't made public, so I left them out, and the plus or minus sign on some terms is my guess based on the descriptions.
According to the GamesRadar+ article, using too much energy or bending limbs at bizarre angles costs points, and those penalties keep the robot from flailing around wildly. If you only hand out rewards, learning finds the cheapest way to collect them, so without penalties you easily end up with a robot that thrashes forward in strange poses.
Teaching walking alone was fine. The trouble started once there was more than one behavior, like walking and then stopping. The NDC26 talk called this behavior bleed. If you teach a single network to go forward with one reward and to stop with another, it can switch between the two. But the walk got noticeably worse. Never knowing when it might be told to stop, the robot hesitated, as if scared, and wouldn't walk at full speed.
The fix was to give up on the idea of one network for everything. They trained one brain that never stops and only ever walks, and a separate brain that knows how to walk and then stop. Now, when the behavior tree decides it's time to close in, it uses the never-stop brain, and when it's time to stop, it switches to the brain that learned stopping. The stopping brain is always run with its stop signal on, so it tries to stop right away and no bleed happens.
Teach one brain two things and it does both halfway. They split the brains and left choosing between them to the behavior tree.
As I see it, the bigger effect of this decision was that it split up who does what. The machine learning side builds the brains and designs the rewards, and the combat and narrative designers decide when to use each brain with the behavior trees they already know. If a designer wants a robot to walk more often, they only need to change the behavior tree, not build a new model. The talk described it as adding independent modules like LEGO bricks.
A robot with 10 to 15 hand-tuned rewards had a big weakness. Building a new robot meant redoing everything from scratch. When an animator asked for a bit more spring, a bit more bounce, or more weight, all the rewards had to be retuned, and changing a single aspect of how it looked took weeks to months. If someone suggested going from one leg to two, it was back to the start, with no guarantee of getting the same result.
According to the 80.lv interview, the system came close to being cut several times because it didn't meet the quality bar. It survived because the game designers believed in the value of emergent gameplay, and what raised the quality a lot was a method called AMP (Adversarial Motion Priors) (Peng et al., 2021).
The idea of AMP goes like this. An animator makes a walk cycle for the robot in the tools they normally use. Then you add a neural network, a discriminator, that takes a few frames and tells whether the motion was made by the animator or not. The discriminator is fed the animator's clips and the in-game robot's movement in turn. And you add one more reward to the existing ones: the more it looks like the animator made it, the more points it gets.
The task reward teaches where to go; the style reward teaches what it should look like getting there.
That's how the artists came back into the loop. If you want to change the gait, you make a new animation and retrain. Artists know how things should move, so this put a tool in their hands to work on that movement directly.
What a game can't do, and what it can
According to the NDC26 talk, the robots with AMP moved beautifully in Server Slam, the public test, and were well received. Then, he said, a problem showed up within seconds. When a player who had been knocked down by a robot crawled into a tunnel, the robot tried to dive in and bounced off, even though it could fit inside. The cause was the eyes, not the walk.
Real robots use cameras, but the ARC robots can't. Seeing through a camera would mean rendering the view on the server, and that costs too much. So the method they had been using was a height grid. You float a grid of points above the robot, cast a ray straight down from each point, and measure the height where it hits the ground. Because the result comes out as a grid, it suited a convolutional neural network (ConvNet), which is good at handling grids.
Try moving the robot toward the tunnel and the wall in the figure below.
A diorama: a small four-legged robot carries a pin comb (20 pins in five tines) on a mast and walks past a roofed passage built against a long wall. Each pin is one ray cast straight down and stops on the first surface below it. Pins over the passage stop on its roof and never reach the floor inside; pins that reach past the wall measure the terrace behind it, which the robot’s head could not see (shown bright, a cheat). Switch to rays from the body and the pins lift above the comb while a lens on the robot’s head fires three rays a step. Each hit stays fixed in the world and fades over one second; hits land on the passage floor, on the edge of the roof’s underside and on the wall’s near face, never behind the wall. A height map under the card shows the same 5 × 4 cells: the pin heights, or the ray hits moved into the robot’s frame. A slider moves the robot and buttons switch the mode.
As the text under the demo explains, each pin is one ray cast straight down. To keep things visible, the tunnel is simplified to a roof open on one side and the grid to 5×4 cells ahead of the robot. In the game the grid is centred on the robot.
It had two weak spots. In places covered overhead, like under a bridge or inside a tunnel, the rays cast from above catch on the roof and can't see the floor inside. And when the robot is pressed against a wall, part of the grid ends up on the far side, so the robot can see ground behind the wall that it shouldn't be able to see, which is cheating.
The fix was to cast the rays from the robot itself instead of from a grid above it. The clever part was making use of the fact that once a point is hit, it doesn't move in the world. You record where it hit and convert it into the robot's own coordinates every frame, so you only need to cast a few rays per frame and can reuse those points for about a second. The catch was that PointNet, the neural network that handles a point cloud gathered this way, performed worse than the grid ConvNet. It was hard to implement, but they made PointNet work in the end, and the tunnel problem went away. According to the 80.lv interview, after this improvement the robots could get around indoor spaces, which changed their behavior and opened up new possibilities.
The robots in a simulation also have an edge over real ones. In the 80.lv interview, Singh-Blom said a real robot can't have a magic force that lifts it up when it starts to fall, but in a game you can cheat like that.
According to another GamesRadar+ article from GDC, the team literally calls these tricks magic internally, and the main one is magic torque. Robots that rely on a learned walk, like the Leaper or the Bastion, may not be able to walk properly once a player has shot off several of their legs. At that point a turning force that physics couldn't produce is added to keep them moving. The team made sure it's used only to the point where it doesn't look obviously unnatural, and the reward penalizes using too much of it, so the robot falls back on it only when there's no other way. According to the article, Singh-Blom presented this as a kind of breakthrough for the team: the realization that since they were making a game, it didn't matter how something moved as long as it looked right.
Magic torque is a set of training wheels that costs points to use. So the robot tries to solve things with physics first.
I think this is the part that best shows the difference between games and robotics. In robotics, the result of the simulation has to carry over to a real machine, so you can't cheat. In a game, the simulation is the final product, so it only has to look convincing to the player.
Limits
First, the scope is narrow. Machine learning is used only for the locomotion of the legged robots, while the drones and the high-level decisions are handled by traditional methods. Singh-Blom said that as the models get better, decisions like squeezing through a narrow gap or jumping over something could move over to the machine learning side. I read that the other way around: for now, those decisions sit outside machine learning.
It's expensive. The GamesRadar+ article reports that it took years to get one robot walking properly, and only once the system was in place could they extend it to the other robots relatively quickly.
The upside of unpredictability is also its downside. You can't know in advance where an enemy moved by physics will be, so the strict pathfinding used in other games doesn't work, and every system had to be built to be more flexible. Things happen that even the team can't explain. In one internal video a Leaper had ended up inside a dome, and nobody knew how it got there. He noted that one-in-a-million things happen all the time when you have millions of players. He said moments like this are fun for the team, but my read is that it also means it's hard to tell a bug from emergence.
That the robots don't adapt on their own is a limit too. Because the learning is offline, fitting them to new terrain or new situations means the team has to change the scenarios or the sensing setup, retrain, and ship again. Then again, Singh-Blom explained that controlling the training environment makes behavior more stable, so it seems this is also a price they chose to pay.
Half of putting it in a product is building tools
More than the technology, what stayed with me longest from these sources were the words Singh-Blom closed his NDC26 talk with. Algorithms and models matter, he said, but organization matters just as much, and half the work of putting machine learning into a real product is building tools for artists and designers. The two brains and AMP were, in the end, both ways of letting designers and animators handle the robots. The next time I see a Leaper tumble and get back up, I think I'll remember that behind it are people who spent years turning dials.
References
Talks and interviews
- The Arc in Arc Raiders have multiple brains… (GamesRadar+, 12 Mar 2026): on-site write-up of the GDC 2026 talk Learning to Move
- Inside the Magic of Machine Learning That Powers Enemy AI in Arc Raiders (80.lv, 31 Mar 2026): interview with Martin Singh-Blom
- ARC Raiders のロボットはどう動いているのか (4Gamer, Japanese, 16 Jun 2026): report on the NDC26 talk
- Arc Raiders has a hidden magic system (GamesRadar+, 17 Mar 2026): the magic torque part of the same GDC talk
- Embark says Arc Raiders' robots don't learn on player data (FRVR, 16 Apr 2026)
Coverage of the AI voices
- Arc Raiders' use of AI highlights the tension and confusion… (PC Gamer, 31 Oct 2025)
- Arc Raiders has been cutting back its AI voices (PCGamesN, 14 Mar 2026)
Papers
- DeepMimic: Example-Guided Deep Reinforcement Learning of Physics-Based Character Skills (Peng et al., SIGGRAPH 2018)
- AMP: Adversarial Motion Priors for Stylized Physics-Based Character Control (Peng et al., SIGGRAPH 2021)
- PointNet: Deep Learning on Point Sets for 3D Classification and Segmentation (Qi et al., CVPR 2017)