← Blog
Research preview

Ent v0.1: A general-purpose reinforcement learning agent

November 17, 2026

Over the past decade, reinforcement learning agents have learned to play Atari, Go, StarCraft and Dota at or above the level of the best human players. They moved on to locomotion and control, demonstrating impressive results in simulations and demos. These results proved that a machine can acquire a difficult skill purely through its own experience.

However, the agents behind those results were purpose-built and heavily tuned for the specific tasks they learned. Ultimately, they still depended on hyperparameters and carefully engineered inputs. The same approach continues to struggle when environments become larger, more complex and noisier. If even a single parameter is poorly tuned, an agent can go from superhuman performance to performing worse than random.

A more general agent is needed to robustly handle different tasks with a single design and set of parameters.

Today we are sharing an early research preview of Ent, our first step in that direction. Ent is a reinforcement learning agent that learns a model of its environment from its own interactions and uses that model to plan its actions. We evaluated a single configuration of Ent across 35 environments spanning control, navigation, memory and multi-agent games, with the usual convenience features removed in each case.

Alongside Ent, we tested classical RL algorithms, each with a single set of parameters and no per-task tuning. We classify performance as good if the agent shows clear progress toward the ultimate goal, and we track total failures, where an agent performs at the level of a random agent. We also measured each agent's performance variability across multiple runs of the same task.

Ent achieves the highest number of good performances and is the only agent with no total failures across the evaluated tasks. It is also the most robust, with the lowest variability in scores across runs.

Good performance

Failed task

Score spread

The setup for general-purpose comparison

This comparison aims to assess the performance of different RL agents across a broad range of tasks using a single set of hyperparameters per agent. This is not about achieving the best possible performance on any individual task – pretty much every environment on the list could be maxed out by a precisely tuned algorithm. It is about performing reliably well across all of them out of the box.

Since this setup is uncommon, we had to find a suitable set of parameters for each agent, except DreamerV3, which pioneered this approach and whose code was openly available. We made our best effort to find such a set for each algorithm, trying many different configurations. For example, our PPO variant does not have standard clipping and has magnetic mirror descent, as this performed better than any of the more conventional configurations we tried.

We also believe that, to better reflect an agent's ability to generalise to larger, more complex environments, it should be able to construct its own state representation rather than having it provided through observations. Thus, most environments had these features removed, leaving only the minimum information necessary to perform the task. For example, control environments no longer provide velocity values, only coordinates. We also do not stack frames in Atari games. To support this setup, each agent was given the same GRU-based backbone as Ent, apart from DreamerV3, which was already designed to handle this.

We defined failure as performance within 5 % of random performance or of a trivial baseline (effectively not acting at all). We refer to this baseline as the floor. To assess good performance, we set a threshold at 80 % of the range between the floor and the maximum possible score. For Atari (MinAtar) and most board games, we measured performance relative to the best achieved score (Atari also used a lower 50 % threshold), since agents were not expected to complete these games within 20 million steps. Tightening up the definition of good performance would mostly favour Ent, since it achieved the highest proportion of best scores as well.

What Ent is

Ent is a general-purpose reinforcement learning agent, designed to reliably solve tasks it has never seen before, out of the box.

Put into an environment, Ent builds an internal model of it from its own interactions and uses that model to plan its actions ahead. At every step it forms its own robust representation from the raw observations, whatever their shape and form, from structured data to pixels. Ent knows how to deal with uncertainty: it projects the different ways the environment could unfold rather than averaging over them.

Using its notion of the environment's rewards, Ent finds the best sequence of actions at every step and keeps learning from the feedback it gets from executing those actions.

More details

Model-based RL agents are not exactly a new area, with approaches like JEPA [1], Dreamer [2], MuZero [3] and TD-MPC [4, 5], and we believe it has a lot of potential and is, frankly, the most promising way forward for RL. Yet none of the existing approaches seem general enough to solve a very broad range of tasks, even “simple” ones.

Instead of building on top of any of those, we chose to start from scratch. The final architecture might not sound groundbreaking on the surface: model-based RL with on-policy planning in latent space. But nearly every design decision differs from the classic algorithms, and together they let one agent tackle control, memory and planning tasks as well as non-stationary multi-agent environments with randomness and hidden information:

  • Randomness is modelled explicitly rather than averaged over.
  • Other agents' decision points are just stochastic nodes: no opponent model, no special treatment.
  • The world model operates in latent space. There is no reconstruction objective, so only relevant information survives.
  • Planning is exact over the model's predictions: no Monte Carlo tree search, no sampled rollouts.
  • The policy imitates the planner, and the planner plans under the policy. One loop handles exploration and keeps improvement smooth.

Ent has solid infrastructure fundamentals: it does most of its work on the GPU for faster rollouts, can use multi-GPU setups, and has an offline mode with policy-only inference for fast-paced environments.

Ent is still in active development and is missing some pieces, such as continuous actions or proper backbones for high-resolution pixel inputs. We also believe that the design of the latent space is the crux of all model-based RL. Our approach excels in some areas and still lacks in others, and it stays our R&D's top priority.

Performing good across the board

Our approach is to start with small but very diverse environments and achieve good performance across the board: nothing should fail, and ideally everything should be at least good. It is not about speed or sample efficiency now; it is about an agent that could, in principle, solve everything out of the box. Then we move to harder and harder environments, more challenging tasks and eventually real-world scenarios, both inside and outside the digital world.

For this first comparison we took 35 established environments from different domains: control, navigation, planning, memory, and competitive and cooperative multi-agent environments. Nothing was cherry-picked; we implemented them one by one and watched how Ent does out of the box.

Technical details: environments

Every environment is stripped of the unnecessary, almost expert-like features that are usually there to make the task easier. The environments we modified this way are tagged PO in the results table, and the MinAtar games, which show a single frame instead of the usual stack, 1-frame.

Most environments are our own ports or wrappers. Each port was checked against its reference implementation (Gymnasium [6], MiniHack 1.0.2 [7, 8], bsuite [9], POPGym [10], MinAtar [11], OpenSpiel [12]). Random floors are either computed exactly or simulated from random legal episodes.

Control (Gymnasium)CartPole, Acrobot, Mountain Car, Lunar Lander. Velocities read zero after the reset, so speed has to be inferred from history. Caps 500 / 500 / 200 / 1000 steps. Score: return.
Blackjack (Gymnasium toy text)infinite deck, dealer stands on 17; the observation is an event stream of raw cards, not hand sums. Score: return per hand.
MiniHack navigation (native ports)Memento (8 doors, dark corridor of 60), Maze Walk 15×15, Key Room 15×15, Multi Room (6 rooms with at most 10 cells), River and River narrow. 9×9 egocentric view, eight compass moves (Key Room adds pick up and apply), +1 on the stairs (Memento instead gives +1 for killing the indicated bug and −1 for entering a wrong room), −0.01 only for a move that takes no game time. Caps: Memento 5000, mazes 1000, Key Room 400, Multi Room 240, River 350. Score: return.
Memory probesMemoryLength with 20 silent steps (bsuite), RepeatPrevious with 2 decks and k = 32 (POPGym Medium), Mine Sweeper 4×4 with 2 mines (POPGym), Key-to-Door [13] (DeepMind's TVT pycolab game, three rooms of 15 / 90 / 15 actions, apple reward 1 or 10 drawn per episode). Score: return.
Planning and explorationTiger [14] (listen is 85 % accurate, 20 steps), RockSample (4, 4) [15] (sensor accuracy (1 + 2−d/20) / 2, 100 steps), DiscountingChain (bsuite; five arms paying at delays 1 to 100, the slowest pays 1.1). Score: return.
Atari (MinAtar)Breakout, Space Invaders, Asterix, Freeway, Seaquest. 10×10 boolean channels, six actions, sticky actions 0.1 [16], difficulty ramping on, 1000-frame cap (so Freeway tops out near 37 crossings). Score: return.
Two- and three-player gamesOpenSpiel rules. Leduc Poker (blinds of 1 and 2 where OpenSpiel antes 1 each), Liar's Dice (one d6 each, 6 wild), Goofspiel (4 cards), Kuhn Poker with 3 players, TicTacToe, Phantom TicTacToe (abrupt), Connect Four 7×6, Othello 6×6, Hex 5×5, Dark Hex 3×3 (abrupt), Battleship 3×3 (one 2-cell ship, 9 shots). Both seats see every event, the non-active seat gets an empty mask, an illegal move forfeits.
CooperativeSpeaker-Listener (PettingZoo MPE [17, 18] simple_speaker_listener_v4): shared 12-float observation, 8-way action with a role mask, 25 cycles, shared return. A reference goal-informed depth-5 planner reaches −7.8 ± 0.5 over 300 episodes.

How we score

  • Floors: where one action repeated beats a random policy, that floor replaces the random score in the good and fail bars: Tiger −20 (listening every step), RockSample 10 (walking east off the grid), Freeway 10.2 (holding up the whole episode), Lunar Lander −132 (doing nothing), River −0.21 (walking east), Speaker-Listener −32 (the listener standing still), Leduc Poker 0.75 (folding every hand). The other MiniHack navigation rows keep their random score: not bumping into walls is not trivial.
  • Exact exploitability over the whole game tree [19] for Leduc, Liar's Dice, Goofspiel, TicTacToe, Dark Hex, and Phantom TicTacToe. For 3-player Kuhn it is NashConv / 3. Exploitability is measured on the raw policy/actor head's output.
  • Optimal-move rate (Connect Four, Hex, Othello): the share of decisions where the policy's move keeps the game-theoretic outcome, judged by an exact solver on the policy's own self-play positions.
  • Search-based best response (Battleship): an adversary that tracks the posterior over the policy's placement; its payoff is a lower bound on exploitability.

Win rate against a fixed opponent is deliberately not used: it measures the opponent.

We compare Ent to five other standard RL algorithms. DreamerV3 [20] is the closest to Ent, both in approach (it also builds a model and plans) and in the claim to perform well across the board. MuZero [3] is the other model-based agent in the comparison: it also learns a model and plans with it, through tree search over a deterministic latent dynamics. PPO [21] is the go-to RL algorithm nowadays. SAC [22, 23] and DQN [24] are two other classical approaches. Each algorithm has one set of parameters for all tasks, which is usually a problem for anyone but Dreamer. We tried different parameter sets for the algorithms, and though they might start performing better in one environment, they would start failing on others they were good at before.

Technical details: agents

Every agent except DreamerV3 shares the recurrent trunk (GRU, 1 layer, 128 neurons, 64 hidden), collects on 100 parallel environment lanes (Ent on 1000, DreamerV3 on 16), and trains for 20M environment steps, five seeds each. Numbers below are the shipped configuration files, verbatim.

PPO (the variant shown: magnetic mirror descent)

Three PPO configurations ran on every environment: plain PPO with entropy bonus 0.1, a low-entropy PPO with bonus 0.01, and a magnetic mirror descent (MMD) variant [25] that replaces the entropy bonus with two KL terms in the policy-gradient loss, one to the policy that collected the batch and one to a slowly trailing copy of itself, at the paper's coefficients. Under these terms the ratio clip was cosmetic, since the KL to the behaviour policy already keeps the update inside a trust region, so the MMD variant runs without it. Everything else follows Stable-Baselines3's PPO defaults [30], except the four passes per collection, which are CleanRL's [31]. MMD was the strongest of the three overall, especially in the imperfect-information games, so it is the PPO in this post. In the previous, single-seed round plain PPO was good on 10 of 36 environments and low-entropy PPO on 12, against MMD's 17.

Losspolicy gradient with advantages normalised, no ratio clip (ppo_eps: null), entropy coefficient 0, KL to behaviour policy ×10 (kl_coef), KL to magnet ×1 (magnet_coef), magnet Polyak rate 0.05 once per collection
Valuevf_coef 0.5, GAE γ 1.0, λ 0.95, Welford value normalisation
OptimiserAdam, lr 3e-4 constant, gradient clip 0.5 on the heads and 1.0 on the trunk, 4 full shuffled passes per collection
Dataon-policy buffer, 4000 steps per collection, minibatch 1000 steps (whole episodes)
NetworkGRU trunk 128/64, policy head 64
Plain / low variantsidentical except: clip 0.2, entropy 0.1 (plain) or 0.01 (low), no KL terms

DreamerV3 (vanilla, 1M-parameter size)

The published agent run as is, with our environments plugged in through its own replay. The same settings on every environment, 5M replay capacity, 16 parallel environments.

World modelRSSM, deterministic 512, stochastic 32 × 4 classes, 8 blocks, hidden 64, unimix 0.01, free nats 1, 1 dynamics layer, 2 imagination layers, 1 observation layer
Encoder / decoderMLP, 3 layers × 64 units, SiLU, RMS norm, symlog inputs
Headsreward and value: 255 bins, symexp two-hot, value 3 layers × 64; continue head binary; policy 3 layers × 64, categorical, unimix 0.01
Imaginationhorizon 15, λ 0.95, actor entropy 3e-4, discount horizon 333, slow value rate 0.02, return normalisation by 5–95 percentiles
Loss scalesreconstruction 1, dynamics 1, representation 0.1, reward 1, continue 1, value 1, policy 1, replay value 0.3
Optimiserlr 4e-5, adaptive gradient clipping 0.3, warm-up 1000, β 0.9 / 0.999
Databatch 16 × 64 steps, train ratio 32, uniform replay, 20M environment steps

MuZero (our port)

Our own implementation of the published recipe [3] on the shared recurrent trunk: a learned representation, deterministic latent dynamics and prediction heads, pUCT search at every decision with the visit counts as the policy target, and a K-step unroll loss. Adaptations are a GRU memory over the observation stream, whole-episode replay, AdamW, γ 1 and step-based schedules. In the multi-player games the opponent is part of the learned dynamics.

ModelGRU trunk 128/64, embedding 64, dynamics MLP 2 × 256, one deterministic successor per (state, action), latents min-max scaled to [0, 1]; value and reward heads: 601 categorical bins over h-transformed returns, support ±300
SearchpUCT, 50 simulations per decision in rounds of 10, Dirichlet root noise α 0.25 at fraction 0.25, legality enforced at the root
Targetspolicy: the root's visit distribution, temperature 1 → 0.5 → 0.25 at 50 % and 75 % of training; value: 5-step returns bootstrapped by a lagged copy of the network refreshed every 100 updates, loss weight 0.25
UnrollK = 5 own decisions, gradient scaled by 0.5 into the imagined steps
OptimiserAdamW, lr 1e-3, weight decay 0.01, gradient clip 1.0
Datareplay 1.25M transitions, replay ratio 200, 40k steps per collection, batches of 10k steps (whole histories), 20M environment steps

SAC (discrete)

Hyperparameters follow Stable-Baselines3's SAC defaults [30]. The target entropy, 0.7 × log of the number of actions, is ours: we swept the ratio, and the usual higher settings broke too many environments.

Critictwin critics with the minimum, Polyak target 0.005, γ 1.0
Entropylearned α from 1.0, α lr 3e-4, target entropy 0.7 × log(number of legal actions)
Optimiserlr 3e-4, grouped gradient clipping 1.0; critic squared error divided by the return's variance, actor loss by its standard deviation, temperature loss unscaled
Datareplay 1M transitions, replay ratio 100, 40k steps per collection, batches of 10k steps (whole episodes)
NetworkGRU trunks 128/64

DQN

The variant is Rainbow's double, dueling, 3-step DQN without prioritised replay, noisy nets or the distributional head [32]. Hyperparameters follow Stable-Baselines3's DQN defaults [30] where they overlap; the exploration schedule, target refresh period and replay ratio were set empirically across the benchmark rather than per environment.

Q-learningdouble DQN, dueling head, 3-step returns, scalar Q, γ 0.99, hard target copy every 1000 updates
Explorationε-greedy, 1.0 → 0.1 linearly over the first 1.25 % of training, then 0.1; no noisy nets
Optimiserlr 3e-4, gradient clipping 1.0; Huber loss on Q and its target, no loss scaling
Datauniform replay 1M transitions, replay ratio 32, 4000 steps per collection on 100 lanes, batches of 320 steps
NetworkGRU trunk 128/64
Scorethe greedy policy (ε 0), 100 evaluation episodes every 10 collections

Ent

One configuration, every environment. We are not publishing the list yet. The budget is the same 20M environment steps, collected 10k at a time on 1000 lanes with a replay ratio of 200; the search budget per action is a few hundred model expansions.

Below is the resulting table of this comparison: every cell is the mean over five runs (different seeds). Failures – performing like a random agent or a trivial strategy (e.g. doing nothing) – are marked red; Failed seeds counts them across all the individual runs. Good performances – 80 % or more of the way from fail to the maximum – are green. The best performance in each row is in bold. We additionally measure the spread, which indicates how robust the agent is, i.e. how much its result changes between seed runs on the same environment, over the environments it did not fail.

Technical details: the protocol
  • Budget: 20M environment steps per run, every agent, every environment. A run's score is the mean of its metric over its last 1M environment steps, whole episodes only.
  • Partial observability everywhere. Every environment that exposes more than an agent strictly needs loses it in the observations: coordinates without velocities in the control tasks, raw card events in the card games, only each player's last move in Tic Tac Toe and never the board, and so on.
  • One memory block for those without one. Every algorithm that cannot handle partial observability on its own gets the same recurrent backbone Ent uses: a one-layer GRU trunk, 128 units, 64 hidden.
  • One hyperparameter set per algorithm, shared across all 35 environments. No per-environment tuning.
  • Self-play without a hint. Multi-agent games are trained in self-play with no knowledge that there is another player; the agent just sees an event stream and treats it as a single-agent environment.
  • Seeds: five per agent and environment. Every number is the mean over the seeds; the learning curves shade a 95 % confidence interval point-wise, 1.96 × the sample standard deviation across seeds / √n.
  • Good performance: the score clears 80 % of the way from a random policy (or from the trivial floor, where an environment has one; see the environments) to the known ceiling, or to the best of all agents where no ceiling is known or, in the board games, where it is not expected to be reached within the 20M budget. The MiniHack rooms set the bar by hand above a known local minimum.
  • Fail: the score is within 5 % of a random policy's, or of the floor's.
  • The selection. The full internal benchmark has 54 environments and 9 algorithm variants. This post uses the subset we consider representative (one size of each family, the sharper variants of the memory probes). Ent gains nothing from the cut: it scored no fails on the full set either.

good fail bold best in row

Learning curves

Takeaways

Ent's performance on this benchmark shows promising signs: it has not failed at any task, or even at any single run. It did good on 29 out of 35 environments, more than any other agent. It is the most robust agent in this comparison, with the lowest spread in performance between runs. And it was the best more often than the others, given one configuration for all the tasks.

The only quantitative downside of Ent, as of any other model-based agent, is speed. While the model-based agents (DreamerV3 and MuZero) are roughly 3× slower than the model-free ones, Ent doubles that. Most of the extra cost comes from the not yet optimised handling of uncertain outcomes.

Why the others fail

No baseline fails everywhere. Each has one or two structural blind spots, and across 35 environments every blind spot gets hit.

Imperfect information needs a mixed strategy. Where a move is made without seeing the opponent's cards, dice or past moves, or where both sides move at once as in Goofspiel, the equilibrium is a mixed strategy, so a deterministic policy is fully exploitable. DQN plays its greedy action and DreamerV3's actor runs with a near-zero entropy bonus, and both sit at an exploitability of 1.0, the worst possible, in Goofspiel, Phantom Tic Tac Toe, Dark Hex and Battleship. MuZero follows its visit counts at a low temperature and adds a handicap of its own: its learned dynamics are deterministic, so a card deal or a dice roll has nowhere to go [26]. Tic Tac Toe has a pure optimal strategy, yet DreamerV3, MuZero and PPO are close to fully exploitable there too: self-play against a copy of yourself visits one line of play, and exact exploitability probes every line. The replay-based agents also train on millions of transitions against stale copies of themselves, so their targets chase an opponent that no longer exists [27].

One entropy setting cannot fit every task. SAC keeps its policy at a fixed fraction of maximum entropy [28]. In Blackjack that forces a coin flip on a large share of decisions, and SAC ends with the worst return per hand of the six agents. In Tiger it forces mass onto the two doors, and the wrong one costs 100. Plain PPO with a fixed entropy bonus has the same problem, which is why we show the magnetic mirror descent variant [25]: a KL penalty to a slowly trailing copy of the policy regularises change rather than certainty and adapts to each environment.

A memory block is not the same as memory. Every baseline got the same GRU as Ent, but PPO, SAC and DQN train it only through the reward signal, which says nothing about what to remember until a remembered fact changes a return. RepeatPrevious asks for the card from 32 steps ago: Ent scores 0.94, while after the same 20M steps no baseline has reached 0.3, and the ones that do improve, improve slowly. Memento and Maze Walk show the same split. The agents that learn to predict their observations get through the dark corridor, the three model-free agents stay far from the stairs.

DreamerV3 learns the world through reconstruction. Its latent has to store everything needed to redraw the observation, whether or not it matters for reward [29]. On MinAtar that means every pixel of a 10×10 board, and with a model the size of Ent's it spends its parameters on the scenery and has less left for the game, which shows most on Asterix and Seaquest. On Tiger and RockSample it settles for the safe trivial policy and never learns that gathering information pays only if you act on it.

Ent has none of these blind spots: a stochastic policy, a latent trained for prediction rather than reconstruction, and search on top. It misses good performance on six environments, four long-horizon exploration tasks and two games, and never fails one.

Future work

Even though Ent performed well above its competition in this comparison, it did not perform good on 100 % of the environments, which is our goal. We could clearly improve on long-term exploration and on stability in high-dimensional tasks. Continuous actions should also be implemented, in order to expand this test bed and include more complicated control environments.

We have the mindset of building a production-ready agent already during the research phase, so improving speed, moving planning from inference to training, pacing ourselves to the environments' requirements, using multi-GPU setups and more are all in active development.

Our next steps would be to up the difficulty in those areas where performance is already high, to challenge Ent further and discover more areas where it can improve.

Want to be a part of that?

Consider joining us.

References

  1. LeCun, Y. (2022). A path towards autonomous machine intelligence. Position paper. OpenReview
  2. Hafner, D., Lillicrap, T., Ba, J., Norouzi, M. (2020). Dream to control: learning behaviors by latent imagination. ICLR 2020. arXiv:1912.01603
  3. Schrittwieser, J. et al. (2020). Mastering Atari, Go, chess and shogi by planning with a learned model. Nature 588, 604–609. doi:10.1038/s41586-020-03051-4
  4. Hansen, N., Wang, X., Su, H. (2022). Temporal difference learning for model predictive control. ICML 2022. arXiv:2203.04955
  5. Hansen, N., Su, H., Wang, X. (2024). TD-MPC2: scalable, robust world models for continuous control. ICLR 2024. arXiv:2310.16828
  6. Towers, M. et al. (2024). Gymnasium: a standard interface for reinforcement learning environments. arXiv:2407.17032
  7. Samvelyan, M. et al. (2021). MiniHack the planet: a sandbox for open-ended reinforcement learning research. NeurIPS 2021 Datasets and Benchmarks. arXiv:2109.13202
  8. Küttler, H. et al. (2020). The NetHack learning environment. NeurIPS 2020. arXiv:2006.13760
  9. Osband, I. et al. (2020). Behaviour suite for reinforcement learning. ICLR 2020. arXiv:1908.03568
  10. Morad, S., Kortvelesy, R., Bettini, M., Liwicki, S., Prorok, A. (2023). POPGym: benchmarking partially observable reinforcement learning. ICLR 2023. arXiv:2303.01859
  11. Young, K., Tian, T. (2019). MinAtar: an Atari-inspired testbed for thorough and reproducible reinforcement learning experiments. arXiv:1903.03176
  12. Lanctot, M. et al. (2019). OpenSpiel: a framework for reinforcement learning in games. arXiv:1908.09453
  13. Hung, C.-C. et al. (2019). Optimizing agent behavior over long time scales by transporting value. Nature Communications 10, 5223. doi:10.1038/s41467-019-13073-w
  14. Kaelbling, L. P., Littman, M. L., Cassandra, A. R. (1998). Planning and acting in partially observable stochastic domains. Artificial Intelligence 101, 99–134. doi:10.1016/S0004-3702(98)00023-X
  15. Smith, T., Simmons, R. (2004). Heuristic search value iteration for POMDPs. UAI 2004. arXiv:1207.4166
  16. Machado, M. C. et al. (2018). Revisiting the Arcade Learning Environment: evaluation protocols and open problems for general agents. JAIR 61, 523–562. arXiv:1709.06009
  17. Terry, J. K. et al. (2021). PettingZoo: Gym for multi-agent reinforcement learning. NeurIPS 2021. arXiv:2009.14471
  18. Lowe, R., Wu, Y., Tamar, A., Harb, J., Abbeel, P., Mordatch, I. (2017). Multi-agent actor-critic for mixed cooperative-competitive environments. NeurIPS 2017. arXiv:1706.02275
  19. Zinkevich, M., Johanson, M., Bowling, M., Piccione, C. (2007). Regret minimization in games with incomplete information. NeurIPS 2007. proceedings
  20. Hafner, D., Pasukonis, J., Ba, J., Lillicrap, T. (2025). Mastering diverse control tasks through world models. Nature 640, 647–653. doi:10.1038/s41586-025-08744-2
  21. Schulman, J., Wolski, F., Dhariwal, P., Radford, A., Klimov, O. (2017). Proximal policy optimization algorithms. arXiv:1707.06347
  22. Haarnoja, T., Zhou, A., Abbeel, P., Levine, S. (2018). Soft actor-critic: off-policy maximum entropy deep reinforcement learning with a stochastic actor. ICML 2018. arXiv:1801.01290
  23. Haarnoja, T. et al. (2018). Soft actor-critic algorithms and applications. arXiv:1812.05905
  24. Mnih, V. et al. (2015). Human-level control through deep reinforcement learning. Nature 518, 529–533. doi:10.1038/nature14236
  25. Sokota, S. et al. (2023). A unified approach to reinforcement learning, quantal response equilibria, and two-player zero-sum games. ICLR 2023. arXiv:2206.05825
  26. Antonoglou, I., Schrittwieser, J., Ozair, S., Hubert, T., Silver, D. (2022). Planning in stochastic environments with a learned model. ICLR 2022. OpenReview
  27. Foerster, J. et al. (2017). Stabilising experience replay for deep multi-agent reinforcement learning. ICML 2017. arXiv:1702.08887
  28. Zhou, H., Lin, Z., Li, J., Fu, Q., Yang, W., Ye, D. (2022). Revisiting discrete soft actor-critic. arXiv:2209.10081
  29. Okada, M., Taniguchi, T. (2021). Dreaming: model-based reinforcement learning by latent imagination without reconstruction. ICRA 2021. arXiv:2007.14535
  30. Raffin, A., Hill, A., Gleave, A., Kanervisto, A., Ernestus, M., Dormann, N. (2021). Stable-Baselines3: reliable reinforcement learning implementations. JMLR 22(268), 1–8. jmlr.org
  31. Huang, S. et al. (2022). CleanRL: high-quality single-file implementations of deep reinforcement learning algorithms. JMLR 23(274), 1–18. jmlr.org
  32. Hessel, M. et al. (2018). Rainbow: combining improvements in deep reinforcement learning. AAAI 2018. arXiv:1710.02298