diff --git a/evals/elsuite/incontext_rl/README.md b/evals/elsuite/incontext_rl/README.md
new file mode 100644
index 0000000000..69dbde303b
--- /dev/null
+++ b/evals/elsuite/incontext_rl/README.md
@@ -0,0 +1,74 @@
+# In-Context RL
+
+This eval tests models' ability to solve RL environments simply by interacting with them in-context, without dedicated training or fine-tuning.
+
+## Usage
+
+Run with:
+
+```bash
+oaieval <solver> incontext_rl
+```
+
+For examples of tested solvers, see [`./scripts/run_experiments.sh`](./scripts/run_experiments.sh).
+
+## Dataset
+
+The eval is currently set up to test models on the following canonical RL environments:
+1. [FrozenLake-v1](https://gymnasium.farama.org/environments/toy_text/frozen_lake/) (non-slippery version, default map), 4x4 gridworld where the agent has to reach the goal without falling into traps.
+2. [CliffWalking-v0](https://gymnasium.farama.org/environments/toy_text/cliff_walking/). 4x12 gridworld where the agent has to reach the other side of the map without falling off a cliff.
+3. [BanditTwoArmedHighLowFixed-v1](https://github.com/james-aung/gymasium-bandits). Stochastic two-armed bandit setup where Arm 1 pays out 80% of the time with reward 1, and Arm 2 pays out 20% of the time with reward 1.
+4. [BanditTenArmedRandomFixed-v1](https://github.com/james-aung/gymasium-bandits). Stochastic ten-armed bandit setup where each arm has some randomly-initialized probability of payout.
+
+Besides these four environments, our eval is also built to be compatible with any environments that have discrete action and observation spaces using the Gymnasium API. Future work may generalize our eval to work with environments with other types of action/observation spaces.
+
+## Evaluation Process
+
+Each run of the eval tests the model on all four environments in the dataset, and has the model take steps in each environment until 200 steps are taken or the model’s context limit is reached.
+
+At each step, the eval provides the following to the model:
+- The next observation and the reward from the last action. The model is also told when the environment has reset due to its action leading to a termination.
+- How many of the maximum number of steps it has already taken.
+- The total reward it has accumulated so far across all episodes.
+
+If an episode ends, the environment resets and a new episode begins.
+
+If the eval receive 4 responses in a row where we cannot parse an action selection, we end the evaluation for that environment. (This provides a natural end for runs where the model’s context window is exceeded.)
+
+
+## Prompts
+
+We refer readers to the [`./defaults.py`](./defaults.py) file for the `TASK_DESCRIPTION` and other prompts used in the eval.
+
+## Metrics
+<!-- prettier-ignore-start -->
+We provide the following metrics per evaluated environment:
+
+| **Metric** | **Notes** |
+|---|---|
+| `average_episode_reward` | The average reward achieved per episode |
+| `total_steps` | The number of steps taken across all episodes before the environment sample ended |
+| `invalid_response_rate` | % of responses that were in an invalid format for the eval |
+<!-- prettier-ignore-end -->
+
+## Token Usage Estimates
+
+<!-- prettier-ignore-start -->
+| Model | Token Usage Per Run |
+|---|---|
+| **gpt-3.5-turbo** | 4200000 ± 400000 |
+| **gpt-4-turbo-preview** | 21900000 ± 10100000 |
+| **mixtral-8x7b** | 2700000 ± 800000 |
+<!-- prettier-ignore-end -->
+
+## Future modifications
+
+- Extend the eval to work with other observation and action spaces beyond Discrete spaces
+
+## Version History
+
+- v0: Initial version released
+
+## Contribution Statement
+
+Eval design, implementation, and results evaluation were primarily conducted by James Aung. Chan Jun Shern was responsible for code reviews throughout the implementation process, along with fine-grained feedback on the project in general. Additional guidance was provided by Steven Adler, who scoped and managed the broader research project, including input on evaluation design, results analysis, and interpretation.
\ No newline at end of file
diff --git a/evals/elsuite/incontext_rl/anti-cot_solver.py b/evals/elsuite/incontext_rl/anti-cot_solver.py
new file mode 100644
index 0000000000..40b3997e3c
--- /dev/null
+++ b/evals/elsuite/incontext_rl/anti-cot_solver.py
@@ -0,0 +1,38 @@
+from typing import Any
+from evals.solvers.solver import NestedSolver, Solver, SolverResult, SolverSpec
+from evals.task_state import Message, TaskState
+
+ANTI_COT_TEMPLATE = "RESPOND ONLY WITH YOUR FINAL ANSWER IN THE FORMAT REQUESTED. DO NOT OUTPUT ANY ADDITIONAL REASONING OR TEXT."
+
+class AntiCoTSolver(NestedSolver):
+    """
+    Instructs the model to not do any further reasoning and just respond with the final answer.
+    """
+
+    def __init__(
+        self,
+        solver: SolverSpec,
+        registry: Any = None,
+    ):
+        super().__init__(solver=solver)
+
+    @property
+    def solver(self) -> Solver:
+        return self.get_solver("solver")
+
+    def _solve(
+        self,
+        task_state: TaskState,
+        **kwargs,
+    ) -> SolverResult:
+        task_state.messages += (
+            [
+                Message(role="system", content=ANTI_COT_TEMPLATE),
+            ]
+        )
+        solver_result = self.solver(task_state=task_state, **kwargs)
+        return solver_result
+
+    @property
+    def name(self) -> str:
+        return f"Anti-CoT_{self.solver.name}"
diff --git a/evals/elsuite/incontext_rl/baselines.py b/evals/elsuite/incontext_rl/baselines.py
new file mode 100644
index 0000000000..34f65d6caf
--- /dev/null
+++ b/evals/elsuite/incontext_rl/baselines.py
@@ -0,0 +1,118 @@
+import random
+
+import numpy as np
+
+from evals.elsuite.incontext_rl.eval import CurrentState
+from evals.record import record_sampling
+from evals.solvers.solver import Solver, SolverResult
+from evals.task_state import TaskState
+
+
+class RandomSolver(Solver):
+    def __init__(self, *args, **kwargs):
+        pass
+
+    def _solve(
+        self,
+        task_state: TaskState,
+        **kwargs,
+    ) -> SolverResult:
+
+        cs: CurrentState = task_state.current_state
+
+        try:
+            action = cs.action_space.sample()
+            response = f"[SELECT: {action}]"
+        except Exception as e:
+            response = f"Error: {e}"
+
+        record_sampling(
+            prompt=cs.observations[-1],
+            sampled=response,
+            model="incontext_rl_random",
+        )
+
+        return SolverResult(response)
+
+
+class QlearningSolver(Solver):
+    def __init__(
+        self,
+        learning_rate=0.7,
+        gamma=0.95,
+        epsilon=1.0,
+        min_epsilon=0.05,
+        max_epsilon=1.0,
+        decay_rate=0.0005,
+        *args,
+        **kwargs,
+    ):
+        super().__init__(*args, **kwargs)
+        self.learning_rate = learning_rate
+        self.gamma = gamma
+        self.epsilon = epsilon
+        self.min_epsilon = min_epsilon
+        self.max_epsilon = max_epsilon
+        self.decay_rate = decay_rate
+        self.q_table = None
+
+    def initialize_q_table(self, observation_space_size, action_space_size):
+        self.q_table = np.zeros((observation_space_size, action_space_size))
+
+    def select_action(self, state, action_space):
+        if random.uniform(0, 1) < self.epsilon:
+            return action_space.sample()  # Explore action space
+        else:
+            return np.argmax(self.q_table[state][:])  # Exploit learned values
+
+    def update_q_table(self, state, action, reward, next_state):
+        next_max = np.max(self.q_table[next_state])
+        self.q_table[state, action] = self.q_table[state, action] + self.learning_rate * (
+            reward + self.gamma * next_max - self.q_table[state, action]
+        )
+
+    def reduce_epsilon(self, episode_number):
+        self.epsilon = self.min_epsilon + (self.max_epsilon - self.min_epsilon) * np.exp(
+            -self.decay_rate * episode_number
+        )
+
+    def _solve(self, task_state: TaskState, **kwargs) -> SolverResult:
+
+        cs: CurrentState = task_state.current_state
+
+        # TODO these might not be true if environment is not discrete
+        assert (
+            cs.observation_space_n is not None
+        ), "Environment must have discrete observation space"
+        assert cs.action_space_n is not None, "Environment must have discrete action space"
+
+        if self.q_table is None:
+            print("Initializing Q-table")
+            self.initialize_q_table(
+                observation_space_size=cs.observation_space_n, action_space_size=cs.action_space_n
+            )
+
+        # This shouln't run on the first step
+        if len(cs.actions) >= 1 and len(cs.rewards) >= 1 and len(cs.observations) >= 2:
+            print(cs.actions)
+            self.update_q_table(
+                state=cs.observations[-2],
+                action=cs.actions[-1],
+                reward=cs.rewards[-1],
+                next_state=cs.observations[-1],
+            )
+            print(
+                f"The last action {cs.actions[-1]} resulted in reward {cs.rewards[-1]}. We went from state {cs.observations[-2]} to state {cs.observations[-1]}"
+            )
+            self.reduce_epsilon(episode_number=len(cs.episode_end_steps))
+
+        action = self.select_action(state=cs.observations[-1], action_space=cs.action_space)
+        response = f"[SELECT: {action}]"
+
+        record_sampling(
+            prompt=cs.observations[-1],
+            sampled=response,
+            model="incontext_rl_qlearning",
+        )
+
+        return SolverResult(response)
diff --git a/evals/elsuite/incontext_rl/defaults.py b/evals/elsuite/incontext_rl/defaults.py
new file mode 100644
index 0000000000..2f1cb06fc2
--- /dev/null
+++ b/evals/elsuite/incontext_rl/defaults.py
@@ -0,0 +1,30 @@
+from string import Template
+
+task_description_template = Template("""$explanations
+
+You have the following $action_space actions available to you: $actions.
+
+On each turn, you will receive an observation from the environment, which maybe be one of the following $observation_space possible observations:
+$observations
+Each action you take will give you a reward (which might be negative) and may move you to a new state.
+
+You should take actions such that you accumulate the highest possible reward across all your actions.
+
+This is how we will play the game:
+1. You will consider all the information you have received to decide upon the best action you can take now.
+2. You will select your action from the list above by specifying the number key of the action in the command [SELECT: x], where x is the number key of the action.
+3. Your selected action will be taken.
+4. As a result of your action, you will be given an observation from the environment and you may receive some reward.
+5. Repeat from step 1.
+""")
+
+step_counter = Template("Total actions taken so far: $step_count")
+reward_counter = Template("Total reward so far: $reward_count")
+reset_msg = Template("""After the game reset you are now in $observation. 
+Please pick an action, providing your reasoning. You must format your final action choice as [SELECT: x]""")
+step_result = Template("""You took Action $action. You are now in $next_observation. 
+The last step you did provided reward: $reward. 
+Please pick an action, providing your reasoning. You must format your final action choice as [SELECT: x]""")
+step_result_reset = Template("""You took Action $action. You arrived at $next_observation.
+The last step made the game reset.
+The last step you did provided reward: $reward.""")
\ No newline at end of file
diff --git a/evals/elsuite/incontext_rl/env_setup.py b/evals/elsuite/incontext_rl/env_setup.py
new file mode 100644
index 0000000000..31ffcba534
--- /dev/null
+++ b/evals/elsuite/incontext_rl/env_setup.py
@@ -0,0 +1,12 @@
+"""
+Optional setup scripts for specific environments.
+"""
+
+def setup_GymnasiumBandits():
+    import gymnasium_bandits
+    return
+
+ENV_SETUP_FUNCS = {
+    "BanditTwoArmedHighLowFixed-v0": setup_GymnasiumBandits,
+    "BanditTenArmedRandomFixed-v0": setup_GymnasiumBandits,
+}
\ No newline at end of file
diff --git a/evals/elsuite/incontext_rl/eval.py b/evals/elsuite/incontext_rl/eval.py
new file mode 100644
index 0000000000..a1fac2101e
--- /dev/null
+++ b/evals/elsuite/incontext_rl/eval.py
@@ -0,0 +1,299 @@
+import logging
+import random
+import re
+from dataclasses import dataclass, field
+from typing import Any, List, Optional
+
+import gymnasium as gym
+import numpy as np
+
+import evals
+from evals.api import CompletionFn
+from evals.elsuite.incontext_rl.defaults import (
+    reset_msg,
+    reward_counter,
+    step_counter,
+    step_result,
+    step_result_reset,
+    task_description_template,
+)
+from evals.elsuite.incontext_rl.env_setup import ENV_SETUP_FUNCS
+from evals.eval import SolverEval
+from evals.solvers.solver import Solver
+from evals.task_state import Message, TaskState
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class CurrentState:
+    action_space: gym.Space
+    observation_space: gym.Space
+    action_space_n: int
+    observation_space_n: int
+    invalid_responses: int = 0
+    total_responses: int = 0
+    actions: List = field(default_factory=list)
+    rewards: List[float] = field(default_factory=list)
+    observations: List = field(default_factory=list)
+    episode_end_steps: List[int] = field(default_factory=list)
+
+
+class InContextRl(SolverEval):
+    def __init__(
+        self,
+        completion_fns: list[CompletionFn],
+        max_steps: int = 200,  # maximum possible steps per sample, optional
+        max_invalid_responses: int = 4,  # maximum invalid responses from Solver before terminating sample
+        max_num_messages_allowed: int = 2048,  # maximum number of messages allowed by OpenAI API
+        use_explanations: bool = False,  # Whether to include a key for how to understand action and observation spaces
+        *args,
+        **kwargs,
+    ):
+        super().__init__(completion_fns, *args, **kwargs)
+        self.max_steps = max_steps
+        self.max_invalid_responses = max_invalid_responses
+        self.use_explanations = use_explanations
+        self.max_num_messages_allowed = max_num_messages_allowed
+
+    def eval_sample(self, solver: Solver, sample: Any, rng: random.Random):
+
+        # Validate sample
+        required_keys = ["env", "env_id", "explanations"]
+        assert all(
+            key in sample for key in required_keys
+        ), f"Sample missing required keys: {required_keys}"
+        assert isinstance(sample["env"], gym.Env)
+        assert isinstance(sample["env_id"], str)
+        assert isinstance(sample["explanations"], str)
+
+        env = sample["env"]
+        ts = TaskState(
+            task_description=self._generate_task_description(env, sample),
+            messages=[],
+            current_state=CurrentState(
+                action_space=env.action_space,
+                observation_space=env.observation_space,
+                action_space_n=env.action_space.n,  # TODO might not be available for all envs, check when adding a continuous env
+                observation_space_n=env.observation_space.n,  # TODO might not be available for all envs, check when adding a continuous env
+            ),
+        )
+
+        # Reset environment and update task state
+        observation, _ = env.reset(seed=42)
+        ts.current_state.observations.append(observation)
+
+        # Tell model starting observation and ask it to pick an action
+        self._add_reset_message_to_task_state(ts, observation, sample)
+
+        for _ in range(self.max_steps):
+            self._add_recap_message_to_task_state(
+                ts, ts.current_state.actions, ts.current_state.rewards
+            )
+
+            action = self._try_get_valid_action(solver, ts, env.action_space.n)
+
+            if action is None:
+                logger.info("Ending sample since couldn't parse an action.")
+                break
+            else:
+                next_observation, reward, terminated, truncated, _ = env.step(action)
+                ts.current_state.actions.append(action)
+                ts.current_state.rewards.append(float(reward))
+                ts.current_state.observations.append(next_observation)
+
+            if terminated or truncated:
+                # Tell model that episode ended and what reward was received
+                content = self._format_step_message(
+                    action, next_observation, reward, sample, terminated=True
+                )
+                ts.messages += [Message(role="user", content=content)]
+
+                # Log what step the episode ended on
+                ts.current_state.episode_end_steps.append(len(ts.current_state.actions))
+
+                # Reset environment
+                observation, _ = env.reset(seed=42)
+                ts.current_state.observations.append(observation)
+
+                # Tell model new observation after reset and ask it to pick an action
+                self._add_reset_message_to_task_state(ts, observation, sample)
+            else:
+                content = self._format_step_message(action, next_observation, reward, sample)
+                ts.messages += [Message(role="user", content=content)]
+
+        env.close()
+
+        episode_rewards = self._calculate_episode_rewards(
+            ts.current_state.episode_end_steps, ts.current_state.rewards
+        )
+        evals.record.record_metrics(
+            environment=f"{env.spec.id} {env.spec.kwargs}",
+            explanations=self.use_explanations,
+            total_return=sum(ts.current_state.rewards),
+            total_steps=len(ts.current_state.actions),
+            actions=ts.current_state.actions,
+            rewards=ts.current_state.rewards,
+            episode_rewards=episode_rewards,
+            average_episode_reward=float(np.mean(episode_rewards)),
+            average_reward_last_5_episodes=float(np.mean(episode_rewards[-5:])),
+            average_reward_last_10_episodes=float(np.mean(episode_rewards[-10:])),
+            average_reward_last_20_episodes=float(np.mean(episode_rewards[-20:])),
+            average_reward_last_50_episodes=float(np.mean(episode_rewards[-50:])),
+            invalid_response_rate=ts.current_state.invalid_responses
+            / ts.current_state.total_responses
+            if ts.current_state.total_responses > 0
+            else 0,
+            episode_end_steps=ts.current_state.episode_end_steps,
+        )
+
+    def run(self, recorder: evals.record.Recorder):
+        samples = self.get_samples()
+        for sample in samples:
+            # Create environments and pass them to each thread via the sample
+            # (gym envs don't like being created in the thread itself)
+            sample["env"] = self._make_env(sample)
+        self.eval_all_samples(recorder, samples)
+
+        metrics = recorder.get_metrics()
+
+        results = []
+
+        for metric in metrics:
+            env_result = {
+                "env": metric["environment"],
+                "metrics": {
+                    "explanations": metric["explanations"],
+                    "average_episode_reward": metric["average_episode_reward"],
+                    "average_reward_last_5_episodes": metric["average_reward_last_5_episodes"],
+                    "average_reward_last_10_episodes": metric["average_reward_last_10_episodes"],
+                    "average_reward_last_20_episodes": metric["average_reward_last_20_episodes"],
+                    "average_reward_last_50_episodes": metric["average_reward_last_50_episodes"],
+                    "episode_rewards": metric["episode_rewards"],
+                    "total_return": metric["total_return"],
+                    "total_steps": metric["total_steps"],
+                    "actions": metric["actions"],
+                    "rewards": metric["rewards"],
+                    "invalid_response_rate": metric["invalid_response_rate"],
+                    "episode_end_steps": metric["episode_end_steps"],
+                },
+            }
+            results.append(env_result)
+
+        final_result = {"environments": results}
+        return final_result
+
+    def _make_env(self, sample: dict) -> gym.Env:
+        env_id = sample["env_id"]
+        env_args = sample.get("env_args", {})
+        if env_id in ENV_SETUP_FUNCS:
+            # Optional setup scripts for specific environments
+            ENV_SETUP_FUNCS[env_id]()
+        return gym.make(env_id, **env_args)
+
+    def _generate_task_description(self, env: gym.Env, sample: dict) -> str:
+
+        actions = [str(action) for action in range(env.action_space.n)]
+        observations = [
+            f"Observation {observation}" for observation in range(env.observation_space.n)
+        ]
+        explanations = (
+            sample["explanations"] if self.use_explanations else "You are playing a game."
+        )
+
+        return task_description_template.substitute(
+            action_space=env.action_space.n,
+            actions=actions,
+            observation_space=env.observation_space.n,
+            observations=observations,
+            explanations=explanations,
+        )
+
+    def _try_get_valid_action(
+        self, solver: Solver, task_state: TaskState, action_space: int
+    ) -> Optional[int]:
+        number_of_attempts = 0
+        while number_of_attempts < self.max_invalid_responses:
+            if len(task_state.messages) > self.max_num_messages_allowed:
+                logger.info(
+                    f"Exceeded maximum number of messages allowed ({self.max_num_messages_allowed})."
+                )
+                return None
+            solver_response = solver(task_state).output
+            action = self._parse_action(solver_response)
+            task_state.messages += [Message(role="assistant", content=solver_response)]
+            task_state.current_state.total_responses += 1
+            # Check if action is valid
+            if action not in range(
+                action_space
+            ):  # TODO this might not work for non-discrete action spaces, check with more complex env
+                task_state.messages += [
+                    Message(
+                        role="user",
+                        content="Invalid action. Please provide ONE valid action by outputting your selection in the format [SELECT: x]. Only output this selection ONCE.",
+                    )
+                ]
+                task_state.current_state.invalid_responses += 1
+                number_of_attempts += 1
+            else:
+                return action
+        # If the loop exits due to reaching max invalid attempts, log and return None
+        logger.info(f"Exceeded maximum invalid action attempts ({self.max_invalid_responses}).")
+        return None
+
+    def _parse_action(self, raw_response: str) -> Optional[int]:
+        pattern = r"\[SELECT: (\d+)\]"
+        matches = re.findall(pattern, raw_response)
+
+        actions = [int(match) for match in matches]
+        if not actions:
+            logger.info(f"No action selections found in response: {raw_response}")
+            return None
+        if len(actions) > 1:
+            logger.info(f"Multiple action selections found in response: {raw_response}")
+            return None
+        return actions[0]
+
+    def _add_message_to_task_state(self, task_state: TaskState, role: str, content: str) -> None:
+        """
+        Adds a message to the task state, combining it with the previous message if they are from the same role.
+        """
+        if task_state.messages and task_state.messages[-1].role == role:
+            task_state.messages[-1].content += "\n\n" + content
+        else:
+            task_state.messages.append(Message(role=role, content=content))
+
+    def _add_reset_message_to_task_state(
+        self, task_state: TaskState, observation: int, sample: dict
+    ) -> None:
+        content = reset_msg.substitute(observation=f"Observation {observation}")
+        self._add_message_to_task_state(task_state, "user", content)
+
+    def _add_recap_message_to_task_state(
+        self, task_state: TaskState, actions: List, rewards: List[float]
+    ) -> None:
+        step_count = step_counter.substitute(step_count=len(actions))
+        reward_count = reward_counter.substitute(reward_count=sum(rewards))
+        content = "\n".join([step_count, reward_count])
+        self._add_message_to_task_state(task_state, "user", content)
+
+    def _format_step_message(
+        self, action: int, observation: int, reward: float, sample: dict, terminated: bool = False
+    ) -> str:
+        observation_desc = f"Observation {observation}"
+        if terminated:
+            template = step_result_reset
+        else:
+            template = step_result
+        return template.substitute(action=action, next_observation=observation_desc, reward=reward)
+
+    def _calculate_episode_rewards(self, episode_end_steps, rewards):
+        episode_rewards = []
+        if not episode_end_steps:  # Handle case where there was only 1 episode
+            return [sum(rewards)]
+        start_index = 0
+        for end_index in episode_end_steps:
+            episode_reward = sum(rewards[start_index:end_index])
+            episode_rewards.append(episode_reward)
+            start_index = end_index
+        return episode_rewards
diff --git a/evals/elsuite/incontext_rl/requirements.txt b/evals/elsuite/incontext_rl/requirements.txt
new file mode 100644
index 0000000000..2712d1140b
--- /dev/null
+++ b/evals/elsuite/incontext_rl/requirements.txt
@@ -0,0 +1,3 @@
+# Additional requirements for specific environments
+gymnasium
+git+https://github.com/james-aung/gymnasium-bandits
\ No newline at end of file
diff --git a/evals/elsuite/incontext_rl/scripts/plot_experiments.py b/evals/elsuite/incontext_rl/scripts/plot_experiments.py
new file mode 100644
index 0000000000..9e8e27f82b
--- /dev/null
+++ b/evals/elsuite/incontext_rl/scripts/plot_experiments.py
@@ -0,0 +1,363 @@
+import json
+import numpy as np
+import matplotlib.pyplot as plt
+from scipy.stats import sem
+import pandas as pd
+from pathlib import Path
+import matplotlib.colors as mcolors
+import argparse
+import seaborn as sns
+
+from evals.utils.log_utils import extract_spec, get_final_results_from_dir
+
+WINDOW_SIZES = {
+    "FrozenLake-v1 {'map_name': '4x4', 'is_slippery': False}": 20,
+    "BanditTwoArmedHighLowFixed-v0 {}": 40,
+    "BanditTenArmedRandomFixed-v0 {}": 40,
+    "CliffWalking-v0 {}": 20,
+    "FrozenLake-v1 {'map_name': '4x4', 'is_slippery': False, 'desc': ['SHFF', 'FFFF', 'FFGH', 'HFHF']}": 20,
+    "default": 20,
+}
+
+PRETTY_MODEL_NAMES = {
+    'generation/direct/gpt-4-turbo-preview': 'GPT-4 Turbo Preview',
+    'incontext_rl/random': 'Random Strategy',
+    'generation/direct/gpt-3.5-turbo': 'GPT-3.5 Turbo',
+    'incontext_rl/qlearning_scratch': 'Q-Learning from scratch',
+    'incontext_rl/qlearning_trained': 'Q-Learning trained',
+    'generation/direct/gemini-pro': 'Gemini Pro 1.0',
+    'generation/direct/mixtral-8x7b-instruct': 'Mixtral 8x7b',
+}
+
+PRETTY_ENV_TITLES = {
+    "FrozenLake-v1 {'map_name': '4x4', 'is_slippery': False}": 'Frozen Lake (4x4, Non-slippery)',
+    "BanditTwoArmedHighLowFixed-v0 {}": "Two-Armed Bandit",
+    "BanditTenArmedRandomFixed-v0 {}": "Ten-Armed Bandit",
+    "CliffWalking-v0 {}": "Cliff Walking",
+    "FrozenLake-v1 {'map_name': '4x4', 'is_slippery': False, 'desc': ['SFFF', 'FHFH', 'FFFH', 'GFFH']}": 'Frozen Lake Custom Map (4x4, Non-slippery)',
+}
+
+MODEL_STYLES = {
+    'generation/direct/gpt-4-turbo-preview': {'line_style': '-', 'color': 'purple', 'alpha': 0.7},
+    'incontext_rl/random': {'line_style': ':', 'color': 'grey', 'alpha': 0.7},
+    'generation/direct/gpt-3.5-turbo': {'line_style': '-', 'color': 'green', 'alpha': 0.7},
+    'incontext_rl/qlearning_scratch': {'line_style': '--', 'color': 'grey', 'alpha': 0.7},
+    'incontext_rl/qlearning_trained': {'line_style': '-', 'color': 'black', 'alpha': 0.7},
+    'generation/direct/gemini-pro': {'line_style': '-', 'color': 'blue', 'alpha': 0.7},
+    'generation/direct/mixtral-8x7b-instruct': {'line_style': '-', 'color': 'orange', 'alpha': 0.7},
+    'default': {'line_style': '-', 'color': 'black', 'alpha': 0.5},
+}
+
+def calculate_episode_rewards(row: pd.Series) -> list:
+    """
+    Calculate the rewards for each episode based on the episode end steps and rewards.
+    """
+    episode_end_steps = row['episode_end_steps']
+    rewards = row['rewards']
+    episode_rewards = []
+    if not episode_end_steps:  # Handle case where there was only 1 episode
+        return [sum(rewards)]
+    start_index = 0
+    for end_index in episode_end_steps:
+        episode_reward = sum(rewards[start_index:end_index])
+        episode_rewards.append(episode_reward)
+        start_index = end_index
+    return episode_rewards
+
+def calculate_rolling_average(episode_rewards: list, window_size: int) -> list:
+    """
+    Calculate the rolling average of the episode rewards using a specified window size.
+    """
+    window_size = int(window_size)
+    rolling_averages = []
+    for i in range(len(episode_rewards)):
+        # Calculate the start index for the window; ensure it's not negative
+        start_index = max(0, i - window_size + 1)
+        # Calculate the running average for the current window
+        window_average = np.mean(episode_rewards[start_index:i+1])
+        rolling_averages.append(window_average)
+    return rolling_averages
+
+def calculate_custom_episode_end_steps_for_cliffwalking(rewards: list, existing_end_steps: list) -> list:
+    """
+    Calculate episode end steps based on rewards and append to existing end steps.
+    An episode also ends when the reward is -100 i.e. when the agent falls off the cliff.
+
+    Args:
+    rewards (list): List of rewards for each step in an episode.
+    existing_end_steps (list): List of already identified episode end steps.
+
+    Returns:
+    list: Updated list of indices representing the end of each episode.
+    """
+    new_end_steps = [i + 1 for i, reward in enumerate(rewards) if reward == -100]
+    # Combine existing and new end steps, remove duplicates, and sort
+    combined_end_steps = sorted(set(existing_end_steps + new_end_steps))
+    return combined_end_steps
+
+def extract_results(datadir: Path) -> pd.DataFrame:
+    """
+    Extracts results from the specified directory and returns a DataFrame.
+
+    Args:
+    datadir (Path): Path to the directory containing the experiment results.
+
+    Returns:
+    pd.DataFrame: DataFrame containing the experiment results.
+    """
+    print(f"Extracting results from directory: {datadir}")
+    df_rows = []
+    final_results = get_final_results_from_dir(datadir)
+    if not final_results:
+        print("No results found in directory.")
+        raise ValueError("No results found in directory.")
+
+    for path, results in final_results.items():
+        print(f"Processing file: {path}")
+        spec = extract_spec(path)
+        if not spec:
+            raise ValueError(f"No spec found for {path}")
+        model = spec.get("completion_fns", [None])[0]
+        base_eval = spec.get("base_eval")
+        if not model or base_eval is None:
+            raise ValueError(f"Missing model or base_eval in spec for {path}")
+        
+        environments = results.get('environments', [])
+        for env in environments:
+            metrics = env.get('metrics', {})
+            flattened_metrics = {f"{k}": v for k, v in metrics.items()} # Flatten metrics into separate columns
+            print(f"Extracted {env['env']} metrics for model: {model}")
+            
+            # Calculate custom episode end steps for CliffWalking environment
+            if env['env'] == "CliffWalking-v0 {}":
+                rewards = metrics.get('rewards', [])
+                existing_end_steps = metrics.get('episode_end_steps', [])
+                episode_end_steps = calculate_custom_episode_end_steps_for_cliffwalking(rewards, existing_end_steps)
+                flattened_metrics['episode_end_steps'] = episode_end_steps
+            
+            df_rows.append({"model": model, "base_eval": base_eval, "environment": env['env'], **flattened_metrics})
+
+    df = pd.DataFrame(df_rows)
+
+    if 'episode_rewards' not in df.columns:
+        df['episode_rewards'] = df.apply(calculate_episode_rewards, axis=1)
+
+    # For plots
+    df['cumulative_episode_rewards'] = df['episode_rewards'].apply(np.cumsum)
+    df['average_episode_reward'] = df['episode_rewards'].apply(np.mean)
+    df['window_size'] = df['environment'].map(WINDOW_SIZES).fillna(WINDOW_SIZES.get('default', 20))
+    df['rolling_average_rewards'] = df.apply(lambda row: calculate_rolling_average(row['episode_rewards'], row['window_size']), axis=1)
+
+    # We also calculate the rolling average across different window sizes
+    df['rolling_average_rewards_5_episodes'] = df.apply(lambda row: calculate_rolling_average(row['episode_rewards'], 5), axis=1)
+    df['rolling_average_rewards_10_episodes'] = df.apply(lambda row: calculate_rolling_average(row['episode_rewards'], 10), axis=1)
+    df['rolling_average_rewards_20_episodes'] = df.apply(lambda row: calculate_rolling_average(row['episode_rewards'], 20), axis=1)
+    df['rolling_average_rewards_50_episodes'] = df.apply(lambda row: calculate_rolling_average(row['episode_rewards'], 50), axis=1)
+    
+    # We also calculate the average reward for the last 5, 10, 20, and 50 episodes. For older runs, we may not have this information.
+    if 'average_reward_last_5_episodes' not in df.columns:
+        df['average_reward_last_5_episodes'] = df['episode_rewards'].apply(lambda rewards: np.mean(rewards[-5:]))
+    if 'average_reward_last_10_episodes' not in df.columns:
+        df['average_reward_last_10_episodes'] = df['episode_rewards'].apply(lambda rewards: np.mean(rewards[-10:]))
+    if 'average_reward_last_20_episodes' not in df.columns:
+        df['average_reward_last_20_episodes'] = df['episode_rewards'].apply(lambda rewards: np.mean(rewards[-20:]))
+    if 'average_reward_last_50_episodes' not in df.columns:
+        df['average_reward_last_50_episodes'] = df['episode_rewards'].apply(lambda rewards: np.mean(rewards[-50:]))
+
+    print(f"Extraction complete. {len(df_rows)} rows in DataFrame.")
+    return df
+
+def plot_rewards(df, environment, reward_type, out_dir, window_size=None):
+    """
+    Generalized function to plot episode, cumulative, or running average rewards for different models
+    on the same graph for a specific environment. It automatically determines the plot type (line or scatter)
+    based on the number of episodes and includes the 95% confidence intervals for line plots.
+
+    Args:
+    df (pd.DataFrame): DataFrame containing the experiment results.
+    environment (str): Name of the environment to plot.
+    reward_type (str): Type of reward to plot. Must be one of 'episode_rewards', 'cumulative_episode_rewards', or 'rolling_average_rewards'.
+    out_dir (Path): Path to the directory to save the plots.
+    window_size (int): Window size for calculating rolling averages. If None, the window size will be determined based on the environment.
+    """
+    valid_reward_types = ['episode_rewards', 'cumulative_episode_rewards', 'rolling_average_rewards']
+    if reward_type not in valid_reward_types:
+        raise ValueError(f"Invalid reward_type. Expected one of {valid_reward_types}, got {reward_type}")
+
+    # Filter the DataFrame for the specific environment
+    filtered_df = df[df['environment'] == environment]
+
+    # Explode the specified reward list into separate rows and prepare for plotting
+    rewards_df = filtered_df.explode(reward_type).reset_index()  # Each row will be a single episode
+    rewards_df['episode'] = rewards_df.groupby(['model', 'index']).cumcount() + 1  # Add episode number as a column
+    rewards_df['reward'] = rewards_df[reward_type]  # Rename the column for clarity
+
+    truncate_per_model = True
+    if environment == "CliffWalking-v0 {}":
+        truncate_per_model = False  # Hacky workaround to make better plots since some models only have 1 episode on CliffWalking
+
+    if truncate_per_model:
+        filtered_rewards_df = pd.DataFrame()
+        for model, group in rewards_df.groupby('model'):
+            # Count the number of runs for each episode number
+            episode_counts = group.groupby('episode').size()
+            # Check if there are at least 3 runs for any episode number
+            if episode_counts.max() >= 3:
+                # Find the maximum episode number where at least 3 runs are available
+                max_episode_with_at_least_3_runs = episode_counts[episode_counts >= 3].index.max()
+                # Filter the group DataFrame to only include data up to this episode number
+                model_filtered = group[group['episode'] <= max_episode_with_at_least_3_runs]
+            else:
+                # If there are fewer than 3 runs for all episodes, include all data for this model
+                model_filtered = group
+            # Append the filtered data for the current model to the overall filtered DataFrame
+            filtered_rewards_df = pd.concat([filtered_rewards_df, model_filtered], ignore_index=True)
+        rewards_df = filtered_rewards_df
+
+    plt.figure(figsize=(10, 5))
+    ax = plt.gca()
+
+    # Determine the plot type based on the number of episodes
+    num_episodes = len(rewards_df['episode'].unique())
+    if num_episodes > 1:
+        # Iterate over each unique model in the DataFrame
+        for model in rewards_df['model'].unique():
+            # Filter the DataFrame for the current model
+            model_df = rewards_df[rewards_df['model'] == model]
+            # Get the custom style for the current model using the helper function
+            custom_style = MODEL_STYLES.get(model, MODEL_STYLES['default'])
+            pretty_model_name = PRETTY_MODEL_NAMES.get(model, model)
+            # Plot the data for the current model on the same axes with custom settings
+            lineplot = sns.lineplot(data=model_df, x='episode', y='reward', estimator='mean', errorbar=('ci', 95), 
+                                    linestyle=custom_style['line_style'], color=custom_style['color'], 
+                                    alpha=custom_style['alpha'], label=pretty_model_name, ax=ax,
+                                    err_kws={'alpha': 0.035})
+            # Add labels to the final value on the x axis
+            for line in lineplot.get_lines():
+                x, y = line.get_data()
+                if len(x) > 0:  # Check if there is data to plot
+                    ax.text(x[-1], y[-1], f"{y[-1]:.2f}", color=line.get_color(), fontsize=9)
+    else:
+        # For a single episode, use scatter plot, differentiating models by color
+        scatterplot = sns.scatterplot(data=rewards_df, x='episode', y='reward', hue='model', ax=ax)
+        # Add labels to the final value on the x axis
+        for line in scatterplot.collections:
+            offsets = line.get_offsets()
+            if offsets.size > 0:  # Check if there are points to plot
+                last_point = offsets[-1]
+                ax.text(last_point[0], last_point[1], f"{last_point[1]:.2f}", fontsize=9)
+
+    pretty_env_title = PRETTY_ENV_TITLES.get(environment, environment)
+    plt.title(f'{reward_type.replace("_", " ").title()} in {pretty_env_title} (Window Size: {window_size})' if reward_type == 'rolling_average_rewards' else f'{reward_type.replace("_", " ").title()} in {pretty_env_title}')
+    plt.xlabel('Episode')
+    plt.ylabel('Reward')
+    plt.legend(title='Model', bbox_to_anchor=(1.05, 1), loc='upper left')
+    plt.xlim(1, num_episodes)
+    plt.tight_layout()
+    plot_dir = out_dir / reward_type
+    plot_dir.mkdir(parents=True, exist_ok=True)
+    plt.savefig(plot_dir / f'{environment}.png')
+    plt.show()
+
+def calculate_rolling_averages(df: pd.DataFrame, max_items: int = 200):
+    """
+    Calculate the averaged final and max rolling averages for the first N items in each model and environment.
+    Args:
+    df (pd.DataFrame): DataFrame containing the experiment results.
+    max_items (int): Maximum number of items to consider for calculating rolling averages.
+    Returns:
+    dict: Dictionary containing the averaged final and max rolling averages for each model and environment.
+    """
+
+    model_env_averages_info = {}
+    for model in df['model'].unique():
+        model_df = df[df['model'] == model]
+        model_env_averages_info[model] = {}
+        all_final_rolling_averages = []  # To store all final rolling averages across environments for each model
+        for env in model_df['environment'].unique():
+            env_df = model_df[model_df['environment'] == env]
+            # Determine the last shared episode across all runs for the current model and environment, limited to the first max_items items
+            max_shared_episode = min(max_items, env_df['rolling_average_rewards'].apply(lambda rewards: len(rewards[:max_items])).min())
+            # Truncate each run's rolling_average_rewards to the max shared episode and then calculate averages
+            truncated_averages = env_df['rolling_average_rewards'].apply(lambda rewards: rewards[:max_shared_episode])
+            final_rolling_averages = round(truncated_averages.apply(lambda rewards: rewards[-1] if len(rewards) > 0 else None).mean(), 2)
+            max_rolling_averages = round(truncated_averages.apply(lambda rewards: max(rewards) if len(rewards) > 0 else None).mean(), 2)
+            
+            all_final_rolling_averages.append(final_rolling_averages)  # Append the final rolling average for the current environment
+            
+            model_env_averages_info[model][env] = {
+                'average_final_rolling_averages': final_rolling_averages,
+                'average_max_rolling_averages': max_rolling_averages,
+            }
+        
+        # Calculate the average final rolling average across all environments for the current model
+        average_final_across_envs = round(sum(all_final_rolling_averages) / len(all_final_rolling_averages), 2) if all_final_rolling_averages else None
+        model_env_averages_info[model]['average_final_rolling_averages_across_envs'] = average_final_across_envs
+    return model_env_averages_info
+
+def json_of_results(df: pd.DataFrame, out_dir: Path):
+    """
+    JSON dump of the results.
+
+    Each model will have the following information, grouping by environment:
+    - Average episode reward
+    - Last rolling average reward for each of 5, 10, 20, and 50 episodes
+    - Max rolling average reward across the 5, 10, 20, and 50 episodes
+    - Invalid response rate
+
+    Where there are multiple runs for a model and environment, the average of the above values will be calculated.
+    """
+
+    model_info = {}
+    for model in df['model'].unique():
+        model_df = df[df['model'] == model]
+        model_info[model] = {}
+        for env in model_df['environment'].unique():
+            env_df = model_df[model_df['environment'] == env]
+            # Calculate the average rolling averages across all runs for each window size, then find the max
+            average_rolling_averages_5 = env_df['rolling_average_rewards_5_episodes'].apply(pd.Series).mean().max()
+            average_rolling_averages_10 = env_df['rolling_average_rewards_10_episodes'].apply(pd.Series).mean().max()
+            average_rolling_averages_20 = env_df['rolling_average_rewards_20_episodes'].apply(pd.Series).mean().max()
+            average_rolling_averages_50 = env_df['rolling_average_rewards_50_episodes'].apply(pd.Series).mean().max()
+
+            model_info[model][env] = {
+                'average_episode_reward': round(env_df['average_episode_reward'].mean(), 2),
+                'average_reward_last_5_episodes': round(env_df['average_reward_last_5_episodes'].mean(), 2),
+                'average_reward_last_10_episodes': round(env_df['average_reward_last_10_episodes'].mean(), 2),
+                'average_reward_last_20_episodes': round(env_df['average_reward_last_20_episodes'].mean(), 2),
+                'average_reward_last_50_episodes': round(env_df['average_reward_last_50_episodes'].mean(), 2),
+                'max_rolling_average_rewards_5_episodes': round(average_rolling_averages_5, 2),
+                'max_rolling_average_rewards_10_episodes': round(average_rolling_averages_10, 2),
+                'max_rolling_average_rewards_20_episodes': round(average_rolling_averages_20, 2),
+                'max_rolling_average_rewards_50_episodes': round(average_rolling_averages_50, 2),
+                'invalid_response_rate': round(env_df['invalid_response_rate'].mean(), 2),
+            }
+    with open(out_dir / 'model_info.json', 'w') as f:
+        json.dump(model_info, f, indent=4)
+
+def main(log_dir: str = None, out_dir: str = None):
+
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--log_dir", "-d", type=str, required=not log_dir)
+    parser.add_argument("--out_dir", "-o", type=str, required=not out_dir)
+    args = parser.parse_args()
+    log_dir = Path(log_dir) if log_dir else Path(args.log_dir)
+    out_dir = Path(out_dir) if out_dir else Path(args.out_dir)
+
+    # Extract results from directory
+    df = extract_results(log_dir)
+
+    # # Plot episode rewards with 95% confidence intervals
+    for env in df['environment'].unique():
+        plot_rewards(df, env, 'episode_rewards', out_dir)
+        plot_rewards(df, env, 'cumulative_episode_rewards', out_dir)
+        window_size = df[df['environment'] == env]['window_size'].iloc[0]
+        plot_rewards(df, env, 'rolling_average_rewards', out_dir, window_size)
+
+    # JSON dump of the results
+    json_of_results(df, out_dir)
+    
+
+if __name__ == "__main__":
+    main()
+
diff --git a/evals/elsuite/incontext_rl/scripts/qlearning_baseline.ipynb b/evals/elsuite/incontext_rl/scripts/qlearning_baseline.ipynb
new file mode 100644
index 0000000000..bb2dc7ae44
--- /dev/null
+++ b/evals/elsuite/incontext_rl/scripts/qlearning_baseline.ipynb
@@ -0,0 +1,402 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "!pip install gymnasium\n",
+    "!pip install numpy\n",
+    "!pip install git+https://github.com/james-aung/gymnasium-bandits\n",
+    "!pip install tqdm"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import gymnasium as gym\n",
+    "import random\n",
+    "import json\n",
+    "\n",
+    "import gymnasium_bandits"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Training parameters\n",
+    "n_training_episodes = 10000  # Total training episodes\n",
+    "n_training_steps = 200    # Total training steps\n",
+    "learning_rate = 0.7          # Learning rate\n",
+    "\n",
+    "# Evaluation parameters\n",
+    "reward_window_size = 25     # Number of steps to consider when calculating average reward\n",
+    "\n",
+    "# Environment parameters\n",
+    "gamma = 0.95                 # Discounting rate\n",
+    "\n",
+    "# Exploration parameters\n",
+    "max_epsilon = 1.0             # Exploration probability at start\n",
+    "min_epsilon = 0.05            # Minimum exploration probability\n",
+    "decay_rate = 0.0005            # Exponential decay rate for exploration prob"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def initialize_q_table(state_space, action_space):\n",
+    "  Qtable = np.zeros((state_space, action_space))\n",
+    "  return Qtable"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def greedy_policy(Qtable, state):\n",
+    "  # Exploitation: take the action with the highest state, action value\n",
+    "  action = np.argmax(Qtable[state][:])\n",
+    "\n",
+    "  return action"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def epsilon_greedy_policy(Qtable, state, epsilon):\n",
+    "  # Randomly generate a number between 0 and 1\n",
+    "  random_num = random.uniform(0,1)\n",
+    "  # if random_num > greater than epsilon --> exploitation\n",
+    "  if random_num > epsilon:\n",
+    "    # Take the action with the highest value given a state\n",
+    "    # np.argmax can be useful here\n",
+    "    action = greedy_policy(Qtable, state)\n",
+    "  # else --> exploration\n",
+    "  else:\n",
+    "    action = env.action_space.sample()\n",
+    "\n",
+    "  return action"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(n_training_steps, min_epsilon, max_epsilon, decay_rate, env, Qtable, reward_window_size=25):\n",
+    "\n",
+    "  actions, rewards = [], []\n",
+    "  total_steps = 0\n",
+    "  episode_end_steps = []\n",
+    "\n",
+    "  for _ in range(n_training_steps):\n",
+    "    if total_steps >= n_training_steps:\n",
+    "      break\n",
+    "    # Reduce epsilon (because we need less and less exploration)\n",
+    "    epsilon = min_epsilon + (max_epsilon - min_epsilon)*np.exp(-decay_rate*len(episode_end_steps))\n",
+    "    # Reset the environment\n",
+    "    state, info = env.reset()\n",
+    "    terminated = False\n",
+    "    truncated = False\n",
+    "\n",
+    "    while not terminated and not truncated and total_steps < n_training_steps:\n",
+    "      # Choose the action At using epsilon greedy policy\n",
+    "      action = epsilon_greedy_policy(Qtable, state, epsilon)\n",
+    "\n",
+    "      # Take action At and observe Rt+1 and St+1\n",
+    "      new_state, reward, terminated, truncated, info = env.step(action)\n",
+    "\n",
+    "      actions.append(int(action))\n",
+    "      rewards.append(float(reward))\n",
+    "      total_steps += 1\n",
+    "\n",
+    "      # Update Q(s,a):= Q(s,a) + lr [R(s,a) + gamma * max Q(s',a') - Q(s,a)]\n",
+    "      Qtable[state][action] = Qtable[state][action] + learning_rate * (reward + gamma * np.max(Qtable[new_state]) - Qtable[state][action])\n",
+    "\n",
+    "      # Our next state is the new state\n",
+    "      state = new_state\n",
+    "\n",
+    "      if terminated or truncated:\n",
+    "        episode_end_steps.append(total_steps)\n",
+    "\n",
+    "  training_summary = {\n",
+    "    \"reward_window_size\": reward_window_size,\n",
+    "    \"average_reward_at_end\": sum(rewards[-reward_window_size:])/reward_window_size,\n",
+    "    \"total_reward\": sum(rewards),\n",
+    "    \"total_steps\": len(actions),\n",
+    "    \"actions\": list(actions),\n",
+    "    \"rewards\": list(rewards),\n",
+    "    \"episode_end_steps\": episode_end_steps,\n",
+    "  }\n",
+    "  \n",
+    "  print(f\"Training completed for {env.spec.id} at {total_steps} steps.\")\n",
+    "  \n",
+    "  return training_summary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def evaluate(env, Qtable, n_evaluation_steps=200):\n",
+    "\n",
+    "  actions, rewards = [], []\n",
+    "  total_steps = 0\n",
+    "  episode_end_steps = []\n",
+    "\n",
+    "  while total_steps < n_evaluation_steps:\n",
+    "    # Reset the environment at the start of each new episode\n",
+    "    state, info = env.reset()\n",
+    "    episode_end_steps.append(total_steps)\n",
+    "    terminated = False\n",
+    "    truncated = False\n",
+    "\n",
+    "    while not terminated and not truncated and total_steps < n_evaluation_steps:\n",
+    "      # Choose the action At using greedy policy\n",
+    "      action = greedy_policy(Qtable, state)\n",
+    "\n",
+    "      # Take action At and observe Rt+1 and St+1\n",
+    "      new_state, reward, terminated, truncated, info = env.step(action)\n",
+    "\n",
+    "      actions.append(int(action))\n",
+    "      rewards.append(float(reward))\n",
+    "      total_steps += 1\n",
+    "\n",
+    "      # Our next state is the new state\n",
+    "      state = new_state\n",
+    "\n",
+    "\n",
+    "  evaluation_summary = {\n",
+    "    \"average_reward_at_end\": sum(rewards[-25:])/min(25, len(rewards)),\n",
+    "    \"total_reward\": sum(rewards),\n",
+    "    \"total_steps\": len(actions),\n",
+    "    \"actions\": list(actions),\n",
+    "    \"rewards\": list(rewards),\n",
+    "    \"episode_end_steps\": episode_end_steps,\n",
+    "  }\n",
+    "  \n",
+    "  print(f\"Evaluation completed for {env.spec.id} at {total_steps} steps.\")\n",
+    "  \n",
+    "  return evaluation_summary"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "frozenlake = gym.make(\"FrozenLake-v1\", is_slippery=False)\n",
+    "frozenlakecustom = gym.make(\"FrozenLake-v1\", is_slippery=False, desc =['SFFF', 'FHFH', 'FFFH', 'GFFH'])\n",
+    "twobandits = gym.make(\"BanditTwoArmedHighLowFixed-v0\")\n",
+    "tenbandits = gym.make(\"BanditTenArmedRandomFixed-v0\")\n",
+    "cliffwalking = gym.make(\"CliffWalking-v0\")\n",
+    "\n",
+    "envs = [frozenlake, frozenlakecustom, twobandits, tenbandits, cliffwalking]\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training FrozenLake-v1 with args {'map_name': '4x4', 'is_slippery': False}...\n",
+      "Training completed for FrozenLake-v1 at 200 steps.\n",
+      "Training FrozenLake-v1 with args {'map_name': '4x4', 'is_slippery': False, 'desc': ['SFFF', 'FHFH', 'FFFH', 'GFFH']}...\n",
+      "Training completed for FrozenLake-v1 at 200 steps.\n",
+      "Training BanditTwoArmedHighLowFixed-v0 with args {}...\n",
+      "Training completed for BanditTwoArmedHighLowFixed-v0 at 200 steps.\n",
+      "Training BanditTenArmedRandomFixed-v0 with args {}...\n",
+      "Training completed for BanditTenArmedRandomFixed-v0 at 200 steps.\n",
+      "Training CliffWalking-v0 with args {}...\n",
+      "Training completed for CliffWalking-v0 at 200 steps.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from datetime import datetime\n",
+    "\n",
+    "environment_results = []\n",
+    "\n",
+    "for env in envs:\n",
+    "    print(f\"Training {env.spec.id} with args {env.spec.kwargs}...\")\n",
+    "    Qtable = initialize_q_table(env.observation_space.n, env.action_space.n)\n",
+    "    results = train(n_training_steps, min_epsilon, max_epsilon, decay_rate, env, Qtable, reward_window_size)\n",
+    "    # train(n_training_steps, min_epsilon, max_epsilon, decay_rate, env, Qtable, reward_window_size)\n",
+    "    # results = evaluate(env, Qtable)\n",
+    "    env_result = {\"env\": f\"{env.spec.id} {env.spec.kwargs}\", \"metrics\": results}\n",
+    "    environment_results.append(env_result)\n",
+    "\n",
+    "current_time = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n",
+    "spec = {\"spec\": {\"completion_fns\": [\"incontext_rl/qlearning\"], \"eval_name\": \"incontext_rl.v0\", \"base_eval\": \"incontext_rl\", \"split\": \"v0\", \"created_at\": current_time}}\n",
+    "final_report = {\"final_report\": {\"environments\": environment_results}}\n",
+    "\n",
+    "with open('./logs/qlearning_incontext_rl.log', 'w') as f:\n",
+    "    json.dump(spec, f)\n",
+    "    f.write(\"\\n\")\n",
+    "    json.dump(final_report, f)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 76,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting running average reward for FrozenLake-v1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting running average reward for FrozenLake-v1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting running average reward for BanditTwoArmedHighLowFixed-v0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting running average reward for BanditTenArmedRandomFixed-v0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Plotting running average reward for CliffWalking-v0\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "def plot_running_average(rewards, window_size=10000):\n",
+    "    running_avg = np.convolve(rewards, np.ones(window_size)/window_size, mode='valid')\n",
+    "    plt.plot(running_avg)\n",
+    "    plt.title('Running Average Reward Over Time')\n",
+    "    plt.xlabel('Step Number')\n",
+    "    plt.ylabel('Running Average Reward')\n",
+    "    plt.show()\n",
+    "\n",
+    "# Assuming `rewards` is a list of rewards from each episode\n",
+    "for env in environment_results:\n",
+    "    rewards = env[\"metrics\"][\"rewards\"]\n",
+    "    print(f\"Plotting running average reward for {env['env_id']}\")\n",
+    "    plot_running_average(rewards)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": ".venv",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/evals/elsuite/incontext_rl/scripts/run_experiments.sh b/evals/elsuite/incontext_rl/scripts/run_experiments.sh
new file mode 100755
index 0000000000..9d8765dc22
--- /dev/null
+++ b/evals/elsuite/incontext_rl/scripts/run_experiments.sh
@@ -0,0 +1,39 @@
+#!/bin/bash
+logdir=./logs
+outputdir=./outputs
+
+timestamp=$(date +%Y%m%d_%H%M%S)
+logpathbase=$logdir/$timestamp/
+
+mkdir -p ${logpathbase}
+
+echo Running experiments and logging to $logpathbase
+read -p "Enter the number of runs: " num_runs
+
+set -x # Enable printing of each command before it's executed
+# Random baselines
+oaieval incontext_rl/random incontext_rl.v0 --record_path ${logpathbase}explanations/random.log
+oaieval incontext_rl/random incontext_rl.raw.v0 --record_path ${logpathbase}raw/random.log
+
+for (( run=1; run<=num_runs; run++ ))
+do
+    echo "Run #$run"
+    # Use explanations variant
+    # Direct
+    oaieval generation/direct/gpt-4-turbo-preview incontext_rl.v0 --record_path ${logpathbase}explanations/gpt-4-turbo-preview_${run}.log
+    oaieval generation/direct/gpt-3.5-turbo incontext_rl.v0 --record_path ${logpathbase}explanations/gpt-3.5-turbo_${run}.log
+
+    # Raw variant
+    # Direct
+    oaieval generation/direct/gpt-4-turbo-preview incontext_rl.raw.v0 --record_path ${logpathbase}raw/gpt-4-turbo-preview_${run}.log
+    oaieval generation/direct/gpt-3.5-turbo incontext_rl.raw.v0 --record_path ${logpathbase}raw/gpt-3.5-turbo_${run}.log
+
+done
+
+echo Done running experiments, all logs in $logpathbase
+
+echo Producing plots for use_explanations variant, outputs to $outputdir
+python plot_experiments.py --log_dir $logpathbase/explanations --out_dir $outputdir/explanations
+echo Producing plots for raw variant, outputs to $outputdir
+python plot_experiments.py --log_dir $logpathbase/raw --out_dir $outputdir/raw
+set +x # Disable printing of each command after they've been executed
diff --git a/evals/registry/data/incontext_rl/samples.jsonl b/evals/registry/data/incontext_rl/samples.jsonl
new file mode 100644
index 0000000000..acacbee595
--- /dev/null
+++ b/evals/registry/data/incontext_rl/samples.jsonl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a675930c0b31dcee9dca9f653085f9eb2b856c1284c289ed5501d44bd94fec5
+size 4138
diff --git a/evals/registry/data/incontext_rl/samples_dev.jsonl b/evals/registry/data/incontext_rl/samples_dev.jsonl
new file mode 100644
index 0000000000..110af6c8cf
--- /dev/null
+++ b/evals/registry/data/incontext_rl/samples_dev.jsonl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:863664b313c3c8e77e3da6ad6f0ef695e8f86ff9d1ecdd7d5fcf0d408bf464da
+size 1617
diff --git a/evals/registry/data/incontext_rl/samples_gymnasium_only.jsonl b/evals/registry/data/incontext_rl/samples_gymnasium_only.jsonl
new file mode 100644
index 0000000000..d0448241d0
--- /dev/null
+++ b/evals/registry/data/incontext_rl/samples_gymnasium_only.jsonl
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7314053ae7203d627611fadb2d5f04f2aa6b001def00047bca206d0db43cb62b
+size 3455
diff --git a/evals/registry/evals/incontext_rl.yaml b/evals/registry/evals/incontext_rl.yaml
new file mode 100644
index 0000000000..e66f358569
--- /dev/null
+++ b/evals/registry/evals/incontext_rl.yaml
@@ -0,0 +1,62 @@
+incontext_rl: 
+  id: incontext_rl.gymnasium.v0
+  metrics: []
+
+incontext_rl.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: True
+    samples_jsonl: incontext_rl/samples.jsonl
+
+incontext_rl.raw.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: False
+    samples_jsonl: incontext_rl/samples.jsonl
+
+incontext_rl.gymnasium.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: True
+    samples_jsonl: incontext_rl/samples_gymnasium_only.jsonl
+
+incontext_rl.gymnasium.raw.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: False
+    samples_jsonl: incontext_rl/samples_gymnasium_only.jsonl
+
+incontext_rl.short.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: True
+    max_steps: 100
+    samples_jsonl: incontext_rl/samples.jsonl
+
+incontext_rl.raw.short.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: False
+    max_steps: 100
+    samples_jsonl: incontext_rl/samples.jsonl
+
+incontext_rl.gymnasium.short.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: True
+    max_steps: 100
+    samples_jsonl: incontext_rl/samples_gymnasium_only.jsonl
+
+incontext_rl.gymnasium.raw.short.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: False
+    max_steps: 100
+    samples_jsonl: incontext_rl/samples_gymnasium_only.jsonl
+
+incontext_rl.dev.v0:
+  class: evals.elsuite.incontext_rl.eval:InContextRl
+  args: 
+    use_explanations: True
+    max_steps: 5
+    samples_jsonl: incontext_rl/samples.jsonl
\ No newline at end of file
diff --git a/evals/registry/solvers/incontext_rl.yaml b/evals/registry/solvers/incontext_rl.yaml
new file mode 100644
index 0000000000..e374f2e75d
--- /dev/null
+++ b/evals/registry/solvers/incontext_rl.yaml
@@ -0,0 +1,27 @@
+incontext_rl/random:
+  class: evals.elsuite.incontext_rl.baselines:RandomSolver
+
+incontext_rl/q-learning:
+  class: evals.elsuite.incontext_rl.baselines:QlearningSolver
+
+incontext_rl/anti-cot/gpt-3.5-turbo:
+  class: evals.elsuite.incontext_rl.anti-cot_solver:AntiCoTSolver
+  args:
+    solver: 
+      class: evals.solvers.openai_solver:OpenAISolver
+      args:
+        completion_fn_options:
+          model: gpt-3.5-turbo
+          extra_options:
+            temperature: 1
+
+incontext_rl/anti-cot/gpt-4-turbo-preview:
+  class: evals.elsuite.incontext_rl.anti-cot_solver:AntiCoTSolver
+  args:
+    solver: 
+      class: evals.solvers.openai_solver:OpenAISolver
+      args:
+        completion_fn_options:
+          model: gpt-4-turbo-preview
+          extra_options:
+            temperature: 1
\ No newline at end of file
diff --git a/pyproject.toml b/pyproject.toml
index 057f38b9eb..bc146903aa 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -34,6 +34,7 @@ dependencies = [
     "jiwer",
     "seaborn",
     "statsmodels",
+    "gymnasium",
     "networkx",
     "chess",
 ]