I built a real-time war game where an LLM commands one nation against 42 others. Nations make pacts and break them, and there is a nuclear doomsday clock: every nuke moves it closer to midnight, and whoever's strike reaches midnight is wiped out. So the move that ends the world always loses for the one who makes it.

I wanted to see what different rewards teach. All of this is small, 10 sealed wars per arm, so read it as a first look.

Imitation first (Qwen 7B, left side of the chart, the experiment from my earlier post here): trained only on DeepSeek wars where nobody struck midnight, it still struck midnight in 4 of 10 (the untrained model: 0). Most of the "good" wars still had nuke orders in them. Cutting the nuke turns out of the data got it to 0 of 10.

Then reward (gpt-oss-20b, 3 rounds). Each round it played a batch of wars, I kept its 6 best by the reward and fine-tuned on those turns with LoRA. So it is filtered self-imitation, not PPO.

Untrained: struck midnight 4 of 10, won 0, broke 3 pacts

Rewarded to win: struck midnight 6 of 10, won 0, broke 7 pacts

Rewarded to win with no nukes: struck midnight 0 of 10, won 0, broke 6 pacts

So rewarding the win made it more dangerous and no better at winning, and banning nukes removed midnight but it just moved the aggression into breaking pacts.

My question for people who know this better than me: how would you reward restraint without rewarding passivity, or pushing the bad behaviour somewhere else? Pacts broken looks like the obvious next term, but I suspect it just moves again.

The environment is on Prime Intellect's Environments Hub if anyone wants to try their own reward (prime env install clouthier-labs/second-strike). Rewards come from the game's own record, no LLM judge, and a seed always gives the same war.

I'm building Bitbots, a browser game where players assemble robots from parts and train them to move using reinforcement learning.

This video shows the game's “brain view”: the policy's inputs, selected hidden-layer activations, and motor outputs, synchronized with the robot's movement. These are recorded values from the actual policy, not a decorative animation.

The idea is to let players see more than just whether their robot walks or falls over. They can watch how the network's activity changes alongside its movement. It isn't an explanation of what individual neurons “mean,” but I wanted to give players a way to look inside the controller.

The current simulation uses MuJoCo, with GPU training through MJX's Warp backend. Players choose the robot's body and joint configuration; the policy learns how to control it. During races, the robot acts autonomously.

For people working on locomotion across different morphologies: how would you support creative, unconventional robot designs under a limited training budget? I’d like players to experiment with weird bodies and joint configurations, rather than feel pushed toward a few designs known to work. How would you approach this without making the reward so prescriptive that every robot ends up moving the same way?

I'm the developer. Bitbots is currently in closed alpha, and free invites are available by comment or DM if you'd like to experiment with your own robot designs.

Project page: https://bitbots.endresgames.com

During my MSc in Digital Agriculture at UNICAMP, I studied reinforcement learning for fraud prevention in crop insurance. The key modeling choice was to include the remaining budget in the state: approving one claim changes what can be funded later.

I built an inspectable Gym-style environment with approve/reject actions, claim context, budget use, approval history, and a statistical signal. The public repository documents subsequent DQN and random-policy experiments.

Walkthrough and short browser demo: https://nandevers.github.io/research/masters/

Code: https://github.com/nandevers/gym-insurance

The browser demo is synthetic; no trained agent or fraud prediction is running there. Benford distance is a statistical proxy, not a fraud label. Confirmed labels and independent evaluation would be needed to claim fraud-detection performance.

For a finite budget, would you model it as an explicit state/constraint or use a reward penalty? What baseline or ablation would you want before comparing policies?

AI helped edit this post; the research and code are mine.

How can agents adapt when the interactions between them keep changing? Here, σ controls the severity of these changes. PACT tracks how agents affect one another through shared roads, power networks or robotic systems, then adjusts their actions to compensate. These demos show PACT helping existing reinforcement-learning agents handle changing interactions in collective urban fleet routing, power-grid control, cooperative lifting and robot locomotion.