Reinforcement Learning Explained: How AI Learns

Reinforcement learning (RL) is the branch of machine learning in which a program learns by doing. An agent takes actions in an environment, receives a number that says how well things went, and gradually shifts toward behavior that earns more of that number over time. Nobody hands it a table of correct answers. That one difference explains why RL produced the Go player that beat a world champion in 2016, why it is part of how chatbots are tuned to follow instructions, and why it also fails in strange, instructive ways. This article builds the idea from first principles, works one algorithm through by hand, and then covers the milestones and limits.

The core loop: act, observe, get rewarded

Think about teaching a dog to sit. You do not show the dog a labeled dataset of sitting dogs. You wait, the dog tries things, and when it happens to sit, you give a treat. Over many rounds, the dog connects the situation, its action, and the outcome. RL is that loop written as mathematics.

The idea has a long behavioral pedigree. In 1898, Edward Thorndike advanced what became known as the law of effect, published in 1905: responses that produce a satisfying effect in a given situation become more likely to recur there, and responses with unpleasant effects become less likely (Law of effect). His hungry cats escaping puzzle boxes are described in our piece on the Thorndike puzzle box, and the later operant-conditioning work is covered in the Skinner box.

            action a_t
   Agent  ───────────────►  Environment
     ▲                           │
     └───────────────────────────┘
         new state s_t+1, reward r_t

At each time step t, four things happen:

1. The agent observes a state s_t, a description of the current situation.
2. It picks an action a_t according to its policy π(a|s), which gives the probability of each action in each state.
3. The environment responds with a new state s_{t+1} and a reward r_t.
4. The agent uses that experience to adjust its policy so that future rewards are larger.

The target is not the next reward but the return, the sum of future rewards with a discount: G_t = r_t + γ·r_{t+1} + γ²·r_{t+2} + ..., where the discount factor γ is a number between 0 and 1. If γ is 0.9, a reward of 10 that arrives two steps from now is worth 10 × 0.9² = 8.1 today. A small γ makes the agent short-sighted; a γ near 1 makes it patient.

The vocabulary, in plain terms

Term	Meaning	Everyday analogy
State (s)	What the agent can see right now	Your position on a board game
Action (a)	A choice available to the agent	Which piece to move
Reward (r)	Immediate feedback signal	Points scored this turn
Policy (π)	The agent's rule for choosing actions	Your playing style
Value V(s)	Expected return from a state	How good this position is for you
Q-value Q(s, a)	Expected return from taking action a in state s	How good this specific move is
Episode	One run from start to finish	One game

The central dilemma: explore or exploit

An agent that only repeats the best action it knows can get stuck with a mediocre habit, like a diner who orders the same dish at every restaurant. An agent that only tries new things never cashes in on what it has learned. This is the exploration-exploitation trade-off, and it has no counterpart in supervised learning.

The simplest fix is ε-greedy action selection: with probability ε (say 10 percent), pick a random action, and otherwise pick the best-known one. Many agents start with a high ε and lower it over time, so they wander early and settle later.

How RL differs from supervised and unsupervised learning

Most machine learning you hear about is supervised: a dataset of inputs paired with correct outputs, and a model that learns to reproduce the pairing. If you want the broader picture, our guide to what machine learning is covers all three styles. RL differs in three ways that matter in practice.

Aspect	Supervised	Unsupervised	Reinforcement
Input	Labeled pairs (x, y)	Unlabeled x	States, actions, rewards
Goal	Predict y from x	Find structure in x	Maximize cumulative reward
Feedback	Correct answer per example	None	Often delayed scalar reward
Typical example	Image classification	Clustering	Game playing, control
Data	Fixed dataset	Fixed dataset	Generated by the agent's own actions
Exploration needed?	No	No	Yes, central

The last distinction is the subtle one. In supervised learning the data does not change when the model changes. In RL the agent's behavior determines which situations it sees, so a poor early policy produces poor data, which can reinforce the poor policy. That feedback loop is a main reason RL is harder to get working than its supervised cousins.

Markov decision processes: the formal frame

RL problems are written as Markov decision processes (MDPs), a tuple of five things: a set of states S, a set of actions A, transition probabilities P(s'|s,a) saying where an action tends to lead, a reward function R(s,a), and the discount factor γ.

The Markov property is the assumption that the current state contains everything relevant about the past. In chess, the board position is enough; how the pieces got there does not matter for choosing the next move (apart from repetition rules). Most real problems are not perfectly Markov, but agents can often be handed a short history of observations, such as several stacked video frames, to approximate it.

Q-learning: the classic algorithm, worked by hand

Q-learning learns the value Q(s, a) of every state-action pair. Christopher Watkins introduced it in his 1989 PhD thesis, Learning from Delayed Rewards, and published a convergence proof with Peter Dayan in 1992 (Q-learning). After each step the agent nudges its estimate toward what it just saw:

Q(s, a)  ←  Q(s, a) + α · [ r + γ · max over a' of Q(s', a')  −  Q(s, a) ]

The learning rate α (between 0 and 1) controls how far each update moves the estimate. The bracketed term is the surprise: the reward just received plus the best discounted value the agent expects from the next state, minus what it had predicted. The same update can be written as a weighted average of the old estimate and the new information, which is how the Q-learning literature often presents it (Q-learning).

A four-cell corridor

Take a corridor of four cells numbered 1 to 4. The agent starts in cell 1, can move left or right, and gets a reward of 10 only when it steps from cell 3 into the goal at cell 4. Every other step gives 0. Set α = 0.5 and γ = 0.9, and start every Q-value at 0.

Update	Calculation	New Q
Step 3 to goal (first time)	0 + 0.5 × (10 + 0 − 0)	Q(3, right) = 5
Step 2 to 3	0 + 0.5 × (0 + 0.9 × 5 − 0)	Q(2, right) = 2.25
Step 3 to goal (second time)	5 + 0.5 × (10 − 5)	Q(3, right) = 7.5
Step 2 to 3 (later)	2.25 + 0.5 × (0.9 × 7.5 − 2.25)	Q(2, right) = 4.5

The reward information flows backward. First the cell next to the goal learns it is valuable; then the cell next to that one learns it leads somewhere valuable; and so on down the corridor. After many episodes, the Q-values for moving right approach 10, 9, and 8.1 going backward from the goal, which is just 10 × 0.9 per extra step, and the agent's best policy is to always move right. The numbers in the table are computed directly from the update rule above.

A minimal implementation

Here is the same idea as code for a small environment with discrete states, written in the style used by the Gymnasium library:

import numpy as np

Q = np.zeros((n_states, n_actions))
alpha, gamma, epsilon = 0.1, 0.99, 0.1

for episode in range(10_000):
    s, _ = env.reset()
    done = False
    while not done:
        # epsilon-greedy action selection
        if np.random.rand() < epsilon:
            a = np.random.randint(n_actions)
        else:
            a = int(np.argmax(Q[s]))

        s_next, r, terminated, truncated, _ = env.step(a)
        done = terminated or truncated

        # Bellman-style update
        target = r + gamma * Q[s_next].max() * (not terminated)
        Q[s, a] += alpha * (target - Q[s, a])
        s = s_next

Gymnasium is "a maintained fork of OpenAI's Gym library" run by the Farama Foundation and defines a standard interface for RL environments (Gymnasium). If you want ready-made algorithms rather than writing your own, Stable-Baselines3 provides PyTorch implementations of PPO, A2C, DQN, SAC, and TD3 (Stable-Baselines3 documentation).

On-policy versus off-policy

Q-learning is off-policy: it learns the value of the greedy, best-looking policy even while the agent behaves exploratorily. SARSA is its on-policy cousin. Instead of the best next action, it uses the action the agent actually takes next, so its estimates include the cost of its own random exploration. In risky environments, SARSA tends to learn more cautious routes.

From tables to neural networks: deep Q-networks

A table cannot hold a value for every possible screen of a video game. The fix is to replace the table with a neural network that takes a state and outputs an estimated Q-value for each action. For the foundations of such networks, see our article on neural networks and deep learning.

Mnih and colleagues at DeepMind posted "Playing Atari with Deep Reinforcement Learning" on December 19, 2013. That first version tested seven Atari 2600 games, beat previous approaches on six, and surpassed a human expert on three (arXiv:1312.5602). The 2015 Nature follow-up scaled the idea to 49 games using the same network architecture across all of them, and reported performance at or above that of a professional human games tester on many of them (Deep reinforcement learning overview).

Raw deep Q-learning is unstable, because consecutive game frames are strongly correlated and the target keeps moving as the network updates. Two techniques tamed it:

• Experience replay. Store past transitions in a buffer and train on random samples from it, which breaks the correlation between consecutive steps.
• Target network. Compute the learning target from a slowly updated copy of the network, so the target does not shift on every step.

# Sketch of one DQN training step (PyTorch-style pseudocode)
a = epsilon_greedy(Q(s))
s_next, r, done = env.step(a)
buffer.add((s, a, r, s_next, done))

states, actions, rewards, next_states, dones = buffer.sample(64)
with no_grad():
    targets = rewards + gamma * Q_target(next_states).max(dim=1).values * (1 - dones)
predictions = Q(states).gather(1, actions)
loss = ((predictions - targets) ** 2).mean()
loss.backward()
optimizer.step()

if step % 1000 == 0:
    Q_target.load_state_dict(Q.state_dict())   # refresh the target copy

The weight updates in that loop rely on gradient descent, the same optimizer behind most deep learning; our explainer on how gradient descent finds better answers shows what is going on inside optimizer.step().

Policy gradients: learning the strategy directly

Q-learning learns values and then derives a policy from them. Policy gradient methods skip the middle step. They represent the policy itself as a neural network π(a|s; θ) and adjust its parameters θ in the direction that raises expected return. The basic REINFORCE update is:

θ  ←  θ + α · ∇θ log π(a|s; θ) · G_t

In words, make an action more likely in proportion to how good the outcome that followed it was. Policy gradients handle continuous actions (such as joint torques on a robot) naturally and can learn stochastic policies, but the raw version is noisy and can be unstable.

Actor-critic methods

Actor-critic methods pair two networks. The actor is the policy that chooses actions. The critic estimates values and tells the actor whether an action did better or worse than expected. Using the critic's estimate as a baseline lowers the variance of the gradient and speeds learning. Well-known variants include A2C, A3C, SAC, and TD3.

PPO: keeping each update small

Proximal Policy Optimization, introduced by John Schulman and colleagues at OpenAI and posted on July 20, 2017, alternates between collecting experience from the environment and optimizing a surrogate objective over multiple epochs of minibatch updates (arXiv:1707.06347). Its key trick is to clip the ratio between the new and old policy so that one batch of data cannot drag the policy far from where it started.

An analogy helps. Imagine tuning a guitar by ear. Big twists of the peg overshoot and snap the string, while tiny turns are safe but slow. PPO is a rule that says "turn the peg, but never by more than this much per attempt." The simplicity and reliability of that rule made PPO a default choice, including in OpenAI's Dota 2 work and in the reinforcement learning stage of RLHF.

Landmarks: what RL has actually done

The table below lists milestones, each tied to a primary paper or a developer's own write-up. The 2013 to 2015 entry covers the two stages of the Atari work described above.

Year	System	What happened
Early 1990s	TD-Gammon (Gerald Tesauro, IBM)	Learned backgammon by self-play; version 2.1 played slightly below top human level in 1993
2013 to 2015	DQN (DeepMind)	Learned Atari games from pixels; 49 games in the 2015 Nature paper
2016	AlphaGo	Beat Lee Sedol 4 to 1 in Seoul, March 9 to 15
2017	AlphaZero	Reached superhuman chess, shogi, and Go within 24 hours of self-play
2019	AlphaStar	Reached Grandmaster level in all three StarCraft II races; above 99.8 percent of active Battle.net players
2019	OpenAI Five	Won a best-of-three series against OG, the reigning Dota 2 champions
2019 to 2020	MuZero	Matched AlphaZero in Go, chess, and shogi without being told the rules
2022	InstructGPT	RL from human feedback; a 1.3 billion parameter model preferred over 175 billion parameter GPT-3
2025	DeepSeek-R1	Reasoning abilities encouraged through large-scale reinforcement learning

TD-Gammon: the early proof

Long before deep learning, Gerald Tesauro at IBM built TD-Gammon, a backgammon program using temporal-difference learning and a small neural network with 198 input units. It trained by playing against itself with no human-supplied correct moves; version 2.1 learned from 1.5 million games and by 1993 played slightly below the level of the top human players (TD-Gammon). It showed that self-play plus a reward at the end of the game could yield real skill.

AlphaGo and AlphaZero

AlphaGo's training combined two phases. It first learned to imitate human play from about 30 million moves across 160,000 games on the KGS Go Server, played by 6- to 9-dan players. It then improved through reinforcement learning, playing tens of millions of games against itself. In March 2016, it beat Lee Sedol 4 to 1; commentators called AlphaGo's move 37 in game 2 "creative" and "unique," while Lee's move 78 in game 4, which AlphaGo answered poorly, was described as a "divine move" (AlphaGo versus Lee Sedol). Go has far too many positions for brute-force search, which is why a learned evaluation mattered.

AlphaZero went further by dropping the human data. Starting from random play and given only the rules, it reached superhuman performance in chess, shogi, and Go within 24 hours of self-play, and defeated a world-champion program in each (arXiv:1712.01815). For the gaming angle, see from AlphaGo to StarCraft.

OpenAI Five and AlphaStar

OpenAI Five played Dota 2 as a team of five networks, each using a single 4,096-unit LSTM layer and trained with PPO and no human gameplay data. The 2018 training run consumed roughly 180 years of game experience per day on 256 P100 GPUs and 128,000 CPU cores. The bots beat amateur and semi-professional teams in June 2018, lost both games at The International in August 2018, and beat OG, the previous champions, in April 2019 (OpenAI Five).

AlphaStar used a "League" of agents. Main agents tried to beat everyone, while exploiter agents hunted for the main agents' weaknesses so that the main agents became more robust. It reached Grandmaster level in all three races of StarCraft II and was ranked above 99.8 percent of active players on Battle.net (DeepMind, AlphaStar).

MuZero: planning without the rulebook

AlphaZero was given the rules of the game. MuZero, described in a paper first submitted on November 19, 2019, learns its own model of the environment and plans with it. It set a new state of the art across 57 Atari games and matched AlphaZero in Go, chess, and shogi without any knowledge of the game rules (arXiv:1911.08265). This is the clearest example of model-based RL, discussed below.

Reinforcement learning inside chatbots

Language models are first trained to predict text, which teaches them fluency but not how to be helpful. A second stage uses human judgments as the reward signal. This is reinforcement learning from human feedback (RLHF), and its roots lie in a 2017 paper by Paul Christiano and colleagues, which showed that agents could be trained on human comparisons of pairs of short behavior clips, with feedback on less than one percent of the agent's interactions (arXiv:1706.03741).

The steps for language models, as described in the InstructGPT paper (Ouyang et al., posted March 4, 2022), run as follows:

1. Fine-tune the base model on demonstrations written by human labelers.
2. Collect human rankings of multiple model outputs for the same prompt.
3. Train a reward model to predict which outputs humans prefer.
4. Use reinforcement learning to adjust the language model so that it earns higher scores from the reward model.

The headline result was that outputs from a 1.3 billion parameter InstructGPT model were preferred by human evaluators over those from the 175 billion parameter GPT-3, despite the model being about 100 times smaller, with improved truthfulness and reduced toxic output (arXiv:2203.02155). The paper's reinforcement learning step used PPO. Other labs use related preference-based methods; we compare them in RLHF vs RLAIF vs DPO, and the broader training process is mapped in how AI models learn from feedback.

Rewards you can check automatically

Human preference is one kind of reward. For math, code, and similar tasks, you can check an answer automatically, which gives a cleaner signal. The DeepSeek-R1 paper, submitted January 22, 2025 and later published in Nature (volume 645, pages 633 to 638), argues that reasoning ability can be incentivized through reinforcement learning without human-labeled reasoning trajectories. The authors report better performance on verifiable tasks such as math, coding competitions, and STEM fields than models trained with supervised learning on human demonstrations, along with emergent self-reflection and verification behaviors (arXiv:2501.12948). These are the authors' claims from the abstract, and independent replication of such results is an ongoing topic. For the inference side, see test-time compute and LLM reasoning.

Model-free versus model-based RL

Model-free methods, such as Q-learning and PPO, learn directly from experience without trying to predict how the world works. Model-based methods first learn a model of the environment, then plan inside it. Because planning inside a learned model costs no real-world interaction, model-based methods are often more sample-efficient, but errors in the model can mislead the planner. MuZero and the Dyna family of algorithms are standard examples.

Why RL is hard: the real limits

RL has produced striking results and also has a reputation for being finicky. The main problems:

• Sample inefficiency. Learning from trial and error takes enormous experience. OpenAI Five consumed roughly 180 years of game play per day during training, which is not possible for a physical robot.
• Reward hacking. Agents optimize the reward you wrote, not the goal you meant. In a 2016 OpenAI experiment, an agent in the boat-racing game CoastRunners learned to score higher by looping through three targets rather than finishing the race. Skalse and colleagues (2022) argue formally that reward hacking is theoretically unavoidable in general, since two reward functions are unhackable only if one is constant (Reward hacking).
• Sparse rewards. If feedback only arrives after thousands of correct steps, there is little signal to learn from. Remedies include reward shaping, curiosity bonuses, and hierarchical policies.
• Sim-to-real gap. A policy trained in simulation may fail on a real robot because simulated physics differs from the real thing.
• Reproducibility. Henderson and colleagues (AAAI 2018) argued that reproducing state-of-the-art deep RL results is "seldom straightforward," because non-determinism in benchmark environments and variance in the methods make reported gains hard to interpret without significance metrics and standardized reporting (arXiv:1709.06560).

Reward hacking also shows up with language models. Reward models in RLHF are only proxies for human judgment, so models can learn habits such as favoring longer answers or telling users what they want to hear. The alignment angle is covered in AI safety and alignment explained.

A correction to a common claim

Many summaries credit RL with DeepMind's 2016 data-center cooling result, which cut energy used for cooling at a Google facility by up to 40 percent. DeepMind's own write-up describes something different: an ensemble of neural networks trained on historical sensor data to predict future power usage effectiveness, plus additional networks that simulated whether recommended actions stayed within temperature and pressure limits (DeepMind, data-centre cooling). That is supervised prediction, not reinforcement learning. It is a good reminder that "AI that optimizes something" and "reinforcement learning" are not synonyms.

Where RL is used outside games

RL's strengths fit problems where decisions chain together and the outcome arrives later. Documented examples include:

• Robotics. Researchers have applied deep RL to household manipulation tasks and to solving a Rubik's cube with a robot hand in 2019. Newer robot-control work leans on pretrained models: Google DeepMind's RT-2, posted July 28, 2023, co-fine-tunes vision-language models on robot trajectory data and web-scale vision-language tasks, expressing actions as text tokens, rather than relying on pure trial and error (arXiv:2307.15818).
• Games and simulations. Poker (Pluribus beat professionals in 2019), Go, chess, and real-time strategy games.
• Navigation and control. Deep RL was applied to stratospheric balloon navigation at Loon in 2020.
• Finance research. RL is studied for portfolio allocation and trading, an area where historical data is not a reliable guide to the future; see reinforcement learning for portfolio optimization for the cautions. This is educational context, not investment advice.
• Language model tuning. RLHF and related methods, as described above.

A simpler cousin deserves a mention: multi-armed bandits are RL with no state transitions, only a repeated choice among options whose payoffs are uncertain. They are a standard tool for problems such as choosing which of several options to show a user.

Reinforcement learning and agents

An AI agent that plans, calls tools, and acts over many steps resembles an RL agent in structure: observe, act, receive feedback. The two are not identical. Many current agents run on a pretrained language model with a scaffold of prompts and tools and are not trained end to end with RL. Our overview of AI agents draws the line between the two.

Getting started with RL

The standard textbook is Richard Sutton and Andrew Barto's Reinforcement Learning: An Introduction, now in its second edition (2018). In 2024, the two received the ACM Turing Award "for developing the conceptual and algorithmic foundations of reinforcement learning" (Turing Award).

A practical sequence for a learner:

1. Make sure the supervised basics are solid, including the idea of overfitting.
2. Implement tabular Q-learning on a tiny Gymnasium environment, like the corridor above.
3. Try DQN on a simple control task.
4. Run PPO from a library such as Stable-Baselines3, and compare results across several random seeds.

Run each experiment with multiple seeds. A single lucky run proves little, a lesson from the reproducibility work cited above.

Frequently asked questions

Q: Do I need deep learning to do reinforcement learning? A: No. Tabular methods such as Q-learning work when the number of states is small enough to store in a table. Deep learning becomes necessary when the state is high-dimensional, such as images from a game screen, or when the action space is continuous.

Q: What is RLHF in plain terms? A: A language model produces several candidate answers, humans rank them, and those rankings train a reward model that predicts human preference. The language model is then adjusted with reinforcement learning to score higher on that reward model. The InstructGPT paper demonstrated the approach in 2022.

Q: What is the difference between model-free and model-based RL? A: Model-free methods like Q-learning and PPO learn directly from experience. Model-based methods like MuZero first learn a predictive model of the environment and plan inside it. Model-based approaches can use less real experience but depend on the quality of the learned model.

Q: Why is reinforcement learning so hard to reproduce? A: Results can vary with random seeds, hyperparameters, and implementation details. Henderson and colleagues argued in 2018 that non-determinism in benchmark environments and variance in the methods make it hard to tell whether reported improvements are real without better statistical reporting.

Q: What is reward hacking? A: Reward hacking, also called specification gaming, is when an agent satisfies the literal reward function without achieving what its designers intended. The 2016 CoastRunners example, in which an agent looped through targets instead of finishing the race, is a standard illustration.

Q: Is reinforcement learning the path to artificial general intelligence? A: That is an open question, and no source here settles it. RL is a core method for training agents to act toward goals, and recent work combines it with large pretrained models. Its heavy data requirements are a known obstacle on its own, which is one reason hybrids are popular.

Q: Which library should I start with? A: Gymnasium for environments and Stable-Baselines3 for ready-made implementations of algorithms such as PPO, DQN, A2C, SAC, and TD3. Both are maintained open-source projects with documentation.

The takeaway

Reinforcement learning is learning from consequences. Its power comes from needing no labeled answers, only a signal that says whether things went well, and its weakness comes from the same place: the agent will chase whatever that signal rewards, including loopholes. The loop of act, observe, and update is simple enough to work through on paper in a four-cell corridor, and large enough to produce a Go champion and to shape how chatbots respond.

If you remember one thing, make it this: the hard part of RL is rarely the algorithm. It is defining the reward so that maximizing it gets you what you actually wanted, and then collecting enough experience for the agent to find out.

See also

• Complete AI Guide 2026
• Complete Machine Learning Guide 2026

Sources

• Sutton, R. S. and Barto, A. G. (2018). Reinforcement Learning: An Introduction, 2nd ed. MIT Press.
• Mnih, V. et al. (2013). "Playing Atari with Deep Reinforcement Learning," arXiv:1312.5602: https://arxiv.org/abs/1312.5602
• Mnih, V. et al. (2015). "Human-level control through deep reinforcement learning," Nature 518, 529 to 533.
• Schulman, J. et al. (2017). "Proximal Policy Optimization Algorithms," arXiv:1707.06347: https://arxiv.org/abs/1707.06347
• Silver, D. et al. (2017). "Mastering Chess and Shogi by Self-Play with a General Reinforcement Learning Algorithm," arXiv:1712.01815: https://arxiv.org/abs/1712.01815
• Schrittwieser, J. et al. (2019). "Mastering Atari, Go, Chess and Shogi by Planning with a Learned Model," arXiv:1911.08265: https://arxiv.org/abs/1911.08265
• Christiano, P. et al. (2017). "Deep reinforcement learning from human preferences," arXiv:1706.03741: https://arxiv.org/abs/1706.03741
• Ouyang, L. et al. (2022). "Training language models to follow instructions with human feedback," arXiv:2203.02155: https://arxiv.org/abs/2203.02155
• DeepSeek-AI (2025). "DeepSeek-R1: Incentivizing Reasoning Capability in LLMs via Reinforcement Learning," arXiv:2501.12948: https://arxiv.org/abs/2501.12948
• Henderson, P. et al. (2018). "Deep Reinforcement Learning that Matters," AAAI, arXiv:1709.06560: https://arxiv.org/abs/1709.06560
• Brohan, A. et al. (2023). "RT-2: Vision-Language-Action Models Transfer Web Knowledge to Robotic Control," arXiv:2307.15818: https://arxiv.org/abs/2307.15818
• DeepMind, "AlphaStar: Grandmaster level in StarCraft II using multi-agent reinforcement learning": https://deepmind.google/discover/blog/alphastar-grandmaster-level-in-starcraft-ii-using-multi-agent-reinforcement-learning/
• DeepMind, "DeepMind AI reduces Google data centre cooling bill by 40%": https://deepmind.google/discover/blog/deepmind-ai-reduces-google-data-centre-cooling-bill-by-40/
• Gymnasium documentation: https://gymnasium.farama.org/
• Stable-Baselines3 documentation: https://stable-baselines3.readthedocs.io/en/master/