diff --git a/.env.template b/.env.template
deleted file mode 100644
index 431883d8b..000000000
--- a/.env.template
+++ /dev/null
@@ -1,13 +0,0 @@
-# .env template
-
-# Path for logs
-LOG_FOLDER=
-
-# Your HPC account code
-NYU_HPC_ACCOUNT=
-
-# NYU ID
-USERNAME=
-
-SINGULARITY_IMAGE=
-OVERLAY_FILE=
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index d19bef1b1..9643d59e8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,9 +27,11 @@ data/raw/*
 data/processed/validation/*
 data/processed/training/*
 data/processed/testing/*
-data/processed/sampled/*
+data/processed/pop_play/*
 data/processed/hand_designed/*
 analyze/figures/*
+data/other/*
+wosac/
 
 # Logging
 /wandb
diff --git a/baselines/ppo/config/ppo_base_puffer.yaml b/baselines/ppo/config/ppo_base_puffer.yaml
index e5618de81..84cff17f2 100644
--- a/baselines/ppo/config/ppo_base_puffer.yaml
+++ b/baselines/ppo/config/ppo_base_puffer.yaml
@@ -8,20 +8,31 @@ model_cpt: null
 
 environment: # Overrides default environment configs (see pygpudrive/env/config.py)
   name: "gpudrive"
-  num_worlds: 75 # Number of parallel environments
-  k_unique_scenes: 75  # Number of unique scenes to sample from
+  num_worlds: 100 # Number of parallel environments
+  k_unique_scenes: 100 # Number of unique scenes to sample from
   max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp
   ego_state: true
   road_map_obs: true
   partner_obs: true
   norm_obs: true
-  add_goal_state: true # If true, the goal state is added to the ego observation
+  add_reference_path: false
   remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists)
   lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types
-  reward_type: "weighted_combination"
+  reward_type: "weighted_combination" # Options: "weighted_combination", "reward_conditioned"
   collision_weight: -0.75
   off_road_weight: -0.75
   goal_achieved_weight: 1.0
+  init_mode: all_non_trivial
+
+  # If reward_type is "reward_conditioned", the following parameters are used
+  condition_mode: random
+  collision_weight_lb: -3.0
+  collision_weight_ub: 0.01
+  goal_achieved_weight_lb: 1.0
+  goal_achieved_weight_ub: 3.0
+  off_road_weight_lb: -3.0
+  off_road_weight_ub: 0.0
+
   dynamics_model: "classic"
   collision_behavior: "ignore" # Options: "remove", "stop", "ignore"
   goal_behavior: "remove" # Options: "remove", "stop", "ignore"
@@ -39,8 +50,8 @@ environment: # Overrides default environment configs (see pygpudrive/env/config.
 
 wandb:
   entity: ""
-  project: "clean_tests"
-  group: " "
+  project: "gpudrive"
+  group: ""
   mode: "online" # Options: online, offline, disabled
   tags: ["ppo", "ff"]
 
@@ -54,7 +65,7 @@ train:
   compile_mode: "reduce-overhead"
 
   # # # Data sampling # # #
-  resample_scenes: false
+  resample_scenes: true
   resample_dataset_size: 10_000 # Number of unique scenes to sample from
   resample_interval: 2_000_000
   sample_with_replacement: true
@@ -62,8 +73,8 @@ train:
 
   # # # PPO # # #
   torch_deterministic: false
-  total_timesteps: 1_000_000_000
-  batch_size: 131_072
+  total_timesteps: 2_000_000_000
+  batch_size: 262_144
   minibatch_size: 8192
   learning_rate: 3e-4
   anneal_lr: false
@@ -89,7 +100,7 @@ train:
     num_parameters: 0 # Total trainable parameters, to be filled at runtime
 
   # # # Checkpointing # # #
-  checkpoint_interval: 400 # Save policy every k iterations
+  checkpoint_interval: 500 # Save policy every k iterations
   checkpoint_path: "./runs"
 
   # # # Rendering # # #
diff --git a/baselines/ppo/config/ppo_population.yaml b/baselines/ppo/config/ppo_population.yaml
new file mode 100644
index 000000000..4ff05427c
--- /dev/null
+++ b/baselines/ppo/config/ppo_population.yaml
@@ -0,0 +1,119 @@
+mode: "train"
+use_rnn: false
+eval_model_path: null
+baseline: false
+data_dir: data/processed/pop_play
+continue_training: false
+model_cpt: null
+
+environment: # Overrides default environment configs (see pygpudrive/env/config.py)
+  name: "gpudrive"
+  num_worlds: 100 # Number of parallel environments
+  k_unique_scenes: 100 # Number of unique scenes to sample from
+  max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp
+  ego_state: true
+  road_map_obs: true
+  partner_obs: true
+  norm_obs: true
+  remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists)
+  lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types
+  reward_type: "reward_conditioned" # Options: "weighted_combination", "reward_conditioned", "follow_waypoints"
+  collision_weight: -0.75
+  off_road_weight: -0.75
+  goal_achieved_weight: 1.0
+  init_mode: all_non_trivial
+
+  # If reward_type is "reward_conditioned", the following parameters are used
+  randomize_rewards: true
+  condition_mode: random # Options: random, fixed
+  collision_weight_lb: -3.0
+  collision_weight_ub: 0.0
+  goal_achieved_weight_lb: 1.0
+  goal_achieved_weight_ub: 3.0
+  off_road_weight_lb: -3.0
+  off_road_weight_ub: 0.0
+
+  dynamics_model: "classic"
+  collision_behavior: "ignore" # Options: "remove", "stop", "ignore"
+  dist_to_goal_threshold: 2.0
+  polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount
+  sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random
+  obs_radius: 50.0 # Visibility radius of the agents
+  action_space_steer_disc: 13
+  action_space_accel_disc: 7
+  init_steps: 0 # Warmup steps
+  # Versatile Behavior Diffusion (VBD): This will slow down training
+  use_vbd: false
+  vbd_model_path: "gpudrive/integrations/vbd/weights/epoch=18.ckpt"
+  vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function
+  vbd_in_obs: false
+
+wandb:
+  entity: ""
+  project: "kshotagents"
+  group: "separate_actor_critic"
+  mode: "online" # Options: online, offline, disabled
+  tags: ["ppo", "ff"]
+
+train:
+  exp_id: # Set dynamically in the script if needed
+  seed: 42
+  cpu_offload: false
+  device: "cuda"  # Dynamically set to cuda if available, else cpu
+  bptt_horizon: 1
+  compile: false
+  compile_mode: "reduce-overhead"
+
+  # # # Data sampling # # #
+  resample_scenes: false
+  resample_dataset_size: 500 # Number of unique scenes to sample from
+  resample_interval: 2_000_000
+  sample_with_replacement: false
+  shuffle_dataset: false
+
+  # # # PPO # # #
+  torch_deterministic: false
+  total_timesteps: 2_000_000_000
+  batch_size: 131072
+  minibatch_size: 8192
+  learning_rate: 3e-4
+  anneal_lr: true
+  gamma: 0.99
+  gae_lambda: 0.95
+  update_epochs: 4
+  norm_adv: true
+  clip_coef: 0.2
+  clip_vloss: false
+  vf_clip_coef: 0.2
+  ent_coef: 0.001
+  vf_coef: 0.5
+  max_grad_norm: 0.5
+  target_kl: null
+  log_window: 1000
+
+  # # # Network # # #
+  network:
+    embed_dim: 64 # Embedding of the input features
+    dropout: 0.01
+    class_name: "Agent"
+    num_parameters: 0 # Total trainable parameters, to be filled at runtime
+
+  # # # Checkpointing # # #
+  checkpoint_interval: 250 # Save policy every k iterations
+  checkpoint_path: "./runs"
+
+  # # # Rendering # # #
+  render: false # Determines whether to render the environment (note: will slow down training)
+  render_3d: false # Render simulator state in 3d or 2d
+  render_interval: 50 # Render every k iterations
+  render_k_scenarios: 1 # Number of scenarios to render
+  render_format: "mp4" # Options: gif, mp4
+  render_fps: 20 # Frames per second
+  zoom_radius: 100
+  plot_waypoints: true
+
+vec:
+  backend: "native" # Only native is currently supported
+  num_workers: 1
+  env_batch_size: 1
+  zero_copy: false
diff --git a/baselines/ppo/config/ppo_waypoint.yaml b/baselines/ppo/config/ppo_waypoint.yaml
new file mode 100644
index 000000000..7f44980b9
--- /dev/null
+++ b/baselines/ppo/config/ppo_waypoint.yaml
@@ -0,0 +1,122 @@
+mode: "train"
+use_rnn: false
+eval_model_path: null
+baseline: false
+data_dir: data/processed/wosac/validation_json_100
+continue_training: false
+model_cpt: null
+
+environment: # Overrides default environment configs (see pygpudrive/env/config.py)
+  name: "gpudrive"
+  num_worlds: 100 # Number of parallel environments
+  k_unique_scenes: 100 # Number of unique scenes to sample from
+  max_controlled_agents: 64 # Maximum number of agents controlled by the model. Make sure this aligns with the variable kMaxAgentCount in src/consts.hpp
+  ego_state: true
+  road_map_obs: true
+  partner_obs: true
+  norm_obs: true
+  remove_non_vehicles: false
+  collision_behavior: "ignore"
+  goal_behavior: "ignore"
+  reward_type: "follow_waypoints"
+  waypoint_distance_scale: 0.01
+  speed_distance_scale: 0.01
+  jerk_smoothness_scale: 0.001
+
+  init_mode: all_non_trivial #womd_tracks_to_predict
+  dynamics_model: "classic"
+  polyline_reduction_threshold: 0.1 # Rate at which to sample points from the polyline (0 is use all closest points, 1 maximum sparsity), needs to be balanced with kMaxAgentMapObservationsCount
+  sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random
+  obs_radius: 50.0 # Visibility radius of the agents
+  action_space_steer_disc: 15
+  action_space_accel_disc: 11
+  init_steps: 0 # Warmup steps
+  goal_achieved_weight: 0.0
+  collision_weight: -0.2
+  off_road_weight: -0.2
+
+  # Versatile Behavior Diffusion (VBD)
+  use_vbd: false
+  init_steps: 0
+  vbd_trajectory_weight: 0.1 # Importance of distance to the vbd trajectories in the reward function
+  vbd_in_obs: false
+
+  # Planning guidance
+  add_reference_path: true # If true, a reference path is added to the ego observation
+  add_reference_speed: true # If true, the reference speed (scalar) is added to the ego observation
+  prob_reference_dropout: 0.0 # Value between 0 and 1, probability of a reference point to be zeroed out
+
+wandb:
+  entity: ""
+  project: "humanlike"
+  group: "debug"
+  mode: "online" # Options: online, offline, disabled
+  tags: ["ppo", "ff"]
+
+train:
+  exp_id: waypoint_rs # Set dynamically in the script if needed
+  seed: 42
+  cpu_offload: false
+  device: "cuda" # Dynamically set to cuda if available, else cpu
+  bptt_horizon: 1
+  compile: false
+  compile_mode: "reduce-overhead"
+
+  # # # Data sampling # # #
+  resample_scenes: false
+  resample_dataset_size: 500 # Number of unique scenes to sample from
+  resample_interval: 2_000_000
+  sample_with_replacement: true
+  shuffle_dataset: true
+  file_prefix: ""
+
+  # # # PPO # # #
+  torch_deterministic: false
+  total_timesteps: 2_000_000_000
+  batch_size: 131072
+  minibatch_size: 8192
+  learning_rate: 3e-4
+  anneal_lr: true
+  gamma: 0.99
+  gae_lambda: 0.95
+  update_epochs: 4
+  norm_adv: true
+  clip_coef: 0.2
+  clip_vloss: false
+  vf_clip_coef: 0.2
+  ent_coef: 0.001
+  vf_coef: 0.5
+  max_grad_norm: 0.5
+  target_kl: null
+
+  # # # Logging # # #
+  log_window: 500
+  track_realism_metrics: true # Log human-like metrics
+  track_n_worlds: 3 # Number of worlds to track
+
+  # # # Network # # #
+  network:
+    embed_dim: 64 # Embedding of the input features
+    dropout: 0.01
+    class_name: "Agent"
+    num_parameters: 0 # Total trainable parameters, to be filled at runtime
+
+  # # # Checkpointing # # #
+  checkpoint_interval: 500 # Save policy every k iterations
+  checkpoint_path: "./runs"
+
+  # # # Rendering # # #
+  render: false # Determines whether to render the environment (note: will slow down training)
+  render_3d: false # Render simulator state in 3d or 2d
+  render_interval: 150 # Render every k iterations
+  render_k_scenarios: 2 # Number of scenarios to render
+  render_format: "mp4" # Options: gif, mp4
+  render_fps: 20 # Frames per second
+  zoom_radius: 100
+  plot_waypoints: true
+
+vec:
+  backend: "native" # Only native is currently supported
+  num_workers: 1
+  env_batch_size: 1
+  zero_copy: false
diff --git a/baselines/ppo/ppo_pufferlib.py b/baselines/ppo/ppo_pufferlib.py
index dd692e369..b92467459 100644
--- a/baselines/ppo/ppo_pufferlib.py
+++ b/baselines/ppo/ppo_pufferlib.py
@@ -161,11 +161,13 @@ def run(
     # fmt: off
     # Environment options
     num_worlds: Annotated[Optional[int], typer.Option(help="Number of parallel envs")] = None,
+    max_controlled_agents: Annotated[Optional[int], typer.Option(help="Number of controlled agents")] = None,
     k_unique_scenes: Annotated[Optional[int], typer.Option(help="The number of unique scenes to sample")] = None,
     collision_weight: Annotated[Optional[float], typer.Option(help="The weight for collision penalty")] = None,
     off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None,
     goal_achieved_weight: Annotated[Optional[float], typer.Option(help="The weight for goal-achieved reward")] = None,
     dist_to_goal_threshold: Annotated[Optional[float], typer.Option(help="The distance threshold for goal-achieved")] = None,
+    randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 0,
     sampling_seed: Annotated[Optional[int], typer.Option(help="The seed for sampling scenes")] = None,
     obs_radius: Annotated[Optional[float], typer.Option(help="The radius for the observation")] = None,
     collision_behavior: Annotated[Optional[str], typer.Option(help="The collision behavior; 'ignore' or 'remove'")] = None,
@@ -200,9 +202,20 @@ def run(
     # Load default configs
     config = load_config(config_path)
 
+    if config.environment.reward_type == "reward_conditioned":
+        if bool(randomize_rewards):
+            config.environment.condition_mode = "random"
+            config.train.exp_id = "random_weights"
+        else:
+            config.environment.condition_mode = (
+                "fixed"  # Use the same type for every agent
+            )
+            config.train.exp_id = "fixed_weights"
+
     # Override configs with command-line arguments
     env_config = {
         "num_worlds": num_worlds,
+        "max_controlled_agents": max_controlled_agents,
         "k_unique_scenes": k_unique_scenes,
         "collision_weight": collision_weight,
         "off_road_weight": off_road_weight,
diff --git a/baselines/ppo/ppo_waypoint.py b/baselines/ppo/ppo_waypoint.py
new file mode 100644
index 000000000..621055635
--- /dev/null
+++ b/baselines/ppo/ppo_waypoint.py
@@ -0,0 +1,274 @@
+"""
+This implementation is adapted from the demo in PufferLib by Joseph Suarez,
+which in turn is adapted from Costa Huang's CleanRL PPO + LSTM implementation.
+Links
+- PufferLib: https://github.com/PufferAI/PufferLib/blob/dev/demo.py
+- Cleanrl: https://github.com/vwxyzjn/cleanrl/blob/master/cleanrl/ppo.py
+"""
+
+import os
+from typing import Optional
+from typing_extensions import Annotated
+import yaml
+from datetime import datetime
+import torch
+import numpy as np
+import wandb
+from box import Box
+
+from gpudrive.integrations.puffer import ppo
+from gpudrive.env.env_puffer import PufferGPUDrive
+from gpudrive.networks.agents import Agent
+from gpudrive.env.dataset import SceneDataLoader
+
+import pufferlib
+from rich.console import Console
+
+import typer
+from typer import Typer
+
+app = Typer()
+
+
+def get_model_parameters(policy):
+    """Helper function to count the number of trainable parameters."""
+    params = filter(lambda p: p.requires_grad, policy.parameters())
+    return sum([np.prod(p.size()) for p in params])
+
+
+def load_config(config_path):
+    """Load the configuration file."""
+    with open(config_path, "r") as f:
+        config = Box(yaml.safe_load(f))
+    return pufferlib.namespace(**config)
+
+
+def make_agent(env, config):
+    """Create a policy based on the environment."""
+    return Agent(
+        config=config.environment,
+        embed_dim=config.train.network.embed_dim,
+        action_dim=env.single_action_space.n,
+    )
+
+
+def train(args, vecenv):
+    """Main training loop for the PPO agent."""
+    policy = make_agent(env=vecenv.driver_env, config=args).to(
+        args.train.device
+    )
+
+    args.train.network.num_parameters = get_model_parameters(policy)
+    args.train.env = args.environment.name
+
+    args.wandb = init_wandb(args, args.train.exp_id, id=args.train.exp_id)
+    args.train.__dict__.update(dict(args.wandb.config.train))
+
+    data = ppo.create(args.train, vecenv, policy, wandb=args.wandb)
+    while data.global_step < args.train.total_timesteps:
+        try:
+            ppo.evaluate(data)  # Rollout
+            ppo.train(data)  # Update policy
+        except KeyboardInterrupt:
+            ppo.close(data)
+            os._exit(0)
+        except Exception as e:
+            print(f"An error occurred: {e}")  # Log the error
+            Console().print_exception()
+            os._exit(1)  # Exit with a non-zero status to indicate an error
+
+    ppo.evaluate(data)
+    ppo.close(data)
+
+
+def init_wandb(args, name, id=None, resume=True):
+    wandb.init(
+        id=id or wandb.util.generate_id(),
+        project=args.wandb.project,
+        entity=args.wandb.entity,
+        group=args.wandb.group,
+        mode=args.wandb.mode,
+        tags=args.wandb.tags,
+        config={
+            "environment": dict(args.environment),
+            "train": dict(args.train),
+            "vec": dict(args.vec),
+        },
+        name=name,
+        save_code=True,
+        resume=False,
+    )
+
+    return wandb
+
+
+@app.command()
+def run(
+    config_path: Annotated[
+        str, typer.Argument(help="The path to the default configuration file")
+    ] = "baselines/ppo/config/ppo_waypoint.yaml",
+    *,
+    # fmt: off
+    # Environment options
+    num_worlds: Annotated[Optional[int], typer.Option(help="Number of parallel envs")] = None,
+    max_controlled_agents: Annotated[Optional[int], typer.Option(help="Number of controlled agents")] = None,
+    k_unique_scenes: Annotated[Optional[int], typer.Option(help="The number of unique scenes to sample")] = None,
+    collision_weight: Annotated[Optional[float], typer.Option(help="The weight for collision penalty")] = None,
+    off_road_weight: Annotated[Optional[float], typer.Option(help="The weight for off-road penalty")] = None,
+    goal_achieved_weight: Annotated[Optional[float], typer.Option(help="The weight for goal-achieved reward")] = None,
+    waypoint_distance_scale: Annotated[Optional[float], typer.Option(help="Scale for realism rewards")] = None,
+    speed_distance_scale: Annotated[Optional[float], typer.Option(help="Scale for realism rewards")] = None,
+    jerk_smoothness_scale: Annotated[Optional[float], typer.Option(help="Scale for realism rewards")] = None,
+    dist_to_goal_threshold: Annotated[Optional[float], typer.Option(help="The distance threshold for goal-achieved")] = None,
+    randomize_rewards: Annotated[Optional[int], typer.Option(help="If reward_type == reward_conditioned, choose the condition_mode; 0 or 1")] = 0,
+    sampling_seed: Annotated[Optional[int], typer.Option(help="The seed for sampling scenes")] = None,
+    obs_radius: Annotated[Optional[float], typer.Option(help="The radius for the observation")] = None,
+    collision_behavior: Annotated[Optional[str], typer.Option(help="The collision behavior; 'ignore' or 'remove'")] = None,
+    remove_non_vehicles: Annotated[Optional[int], typer.Option(help="Remove non-vehicles from the scene; 0 or 1")] = None,
+    use_vbd: Annotated[Optional[bool], typer.Option(help="Use VBD model for trajectory predictions")] = False,
+    vbd_model_path: Annotated[Optional[str], typer.Option(help="Path to VBD model checkpoint")] = None,
+    vbd_trajectory_weight: Annotated[Optional[float], typer.Option(help="Weight for VBD trajectory deviation penalty")] = 0.1,
+    vbd_in_obs: Annotated[Optional[bool], typer.Option(help="Include VBD predictions in the observation")] = False,
+    init_steps: Annotated[Optional[int], typer.Option(help="Environment warmup steps")] = 0,
+    
+    # Train options
+    seed: Annotated[Optional[int], typer.Option(help="The seed for training")] = None,
+    learning_rate: Annotated[Optional[float], typer.Option(help="The learning rate for training")] = None,
+    anneal_lr: Annotated[Optional[int], typer.Option(help="Whether to anneal the learning rate over time; 0 or 1")] = None,
+    resample_scenes: Annotated[Optional[int], typer.Option(help="Whether to resample scenes during training; 0 or 1")] = None,
+    resample_interval: Annotated[Optional[int], typer.Option(help="The interval for resampling scenes")] = None,
+    resample_dataset_size: Annotated[Optional[int], typer.Option(help="The size of the dataset to sample from")] = None,
+    total_timesteps: Annotated[Optional[int], typer.Option(help="The total number of training steps")] = None,
+    ent_coef: Annotated[Optional[float], typer.Option(help="Entropy coefficient")] = None,
+    update_epochs: Annotated[Optional[int], typer.Option(help="The number of epochs for updating the policy")] = None,
+    batch_size: Annotated[Optional[int], typer.Option(help="The batch size for training")] = None,
+    minibatch_size: Annotated[Optional[int], typer.Option(help="The minibatch size for training")] = None,
+    gamma: Annotated[Optional[float], typer.Option(help="The discount factor for rewards")] = None,
+    vf_coef: Annotated[Optional[float], typer.Option(help="Weight for vf_loss")] = None,
+    # Wandb logging options
+    project: Annotated[Optional[str], typer.Option(help="WandB project name")] = None,
+    entity: Annotated[Optional[str], typer.Option(help="WandB entity name")] = None,
+    group: Annotated[Optional[str], typer.Option(help="WandB group name")] = None,
+    render: Annotated[Optional[int], typer.Option(help="Whether to render the environment; 0 or 1")] = None,
+):
+    """Run PPO training with the given configuration."""
+    # fmt: on
+
+    # Load default configs
+    config = load_config(config_path)
+
+    if config.environment.reward_type == "reward_conditioned":
+        if bool(randomize_rewards):
+            config.environment.condition_mode = "random"
+            config.train.exp_id = "random_weights"
+        else:
+            config.environment.condition_mode = (
+                "fixed"  # Use the same type for every agent
+            )
+            config.train.exp_id = "fixed_weights"
+
+    # Override configs with command-line arguments
+    env_config = {
+        "num_worlds": num_worlds,
+        "max_controlled_agents": max_controlled_agents,
+        "k_unique_scenes": k_unique_scenes,
+        "collision_weight": collision_weight,
+        "off_road_weight": off_road_weight,
+        "goal_achieved_weight": goal_achieved_weight,
+        "waypoint_distance_scale": waypoint_distance_scale,
+        "jerk_smoothness_scale": jerk_smoothness_scale,
+        "speed_distance_scale": speed_distance_scale,
+        "dist_to_goal_threshold": dist_to_goal_threshold,
+        "sampling_seed": sampling_seed,
+        "obs_radius": obs_radius,
+        "collision_behavior": collision_behavior,
+        "remove_non_vehicles": None
+        if remove_non_vehicles is None
+        else bool(remove_non_vehicles),
+        "use_vbd": use_vbd,
+        "vbd_model_path": vbd_model_path,
+        "vbd_trajectory_weight": vbd_trajectory_weight,
+        "vbd_in_obs": vbd_in_obs,
+        "init_steps": init_steps,
+    }
+    config.environment.update(
+        {k: v for k, v in env_config.items() if v is not None}
+    )
+
+    train_config = {
+        "seed": seed,
+        "learning_rate": learning_rate,
+        "anneal_lr": None if anneal_lr is None else bool(anneal_lr),
+        "resample_scenes": None
+        if resample_scenes is None
+        else bool(resample_scenes),
+        "resample_interval": resample_interval,
+        "resample_dataset_size": resample_dataset_size,
+        "total_timesteps": total_timesteps,
+        "ent_coef": ent_coef,
+        "update_epochs": update_epochs,
+        "batch_size": batch_size,
+        "minibatch_size": minibatch_size,
+        "render": None if render is None else bool(render),
+        "gamma": gamma,
+        "vf_coef": vf_coef,
+    }
+    config.train.update(
+        {k: v for k, v in train_config.items() if v is not None}
+    )
+
+    wandb_config = {
+        "project": project,
+        "entity": entity,
+        "group": group,
+    }
+    config.wandb.update(
+        {k: v for k, v in wandb_config.items() if v is not None}
+    )
+
+    datetime_ = datetime.now().strftime("%m_%d_%H_%M_%S_%f")[:-3]
+
+    if config["train"]["resample_scenes"]:
+        if config["train"]["resample_scenes"]:
+            dataset_size = config["train"]["resample_dataset_size"]
+        config["train"][
+            "exp_id"
+        ] = f'{config["train"]["exp_id"]}__R_{dataset_size}__{datetime_}'
+    else:
+        dataset_size = str(config["environment"]["k_unique_scenes"])
+        config["train"][
+            "exp_id"
+        ] = f'{config["train"]["exp_id"]}__S_{dataset_size}__{datetime_}'
+
+    config["environment"]["dataset_size"] = dataset_size
+    config["train"]["device"] = config["train"].get(
+        "device", "cpu"
+    )  # Default to 'cpu' if not set
+    if torch.cuda.is_available():
+        config["train"]["device"] = "cuda"  # Set to 'cuda' if available
+
+    # Make dataloader
+    train_loader = SceneDataLoader(
+        root=config.data_dir,
+        batch_size=config.environment.num_worlds,
+        dataset_size=config.train.resample_dataset_size
+        if config.train.resample_scenes
+        else config.environment.k_unique_scenes,
+        sample_with_replacement=config.train.sample_with_replacement,
+        shuffle=config.train.shuffle_dataset,
+        file_prefix=config.train.file_prefix,
+    )
+
+    # Make environment
+    vecenv = PufferGPUDrive(
+        data_loader=train_loader,
+        **config.environment,
+        **config.train,
+    )
+
+    train(config, vecenv)
+
+
+if __name__ == "__main__":
+
+    app()
diff --git a/examples/experimental/config/eval_config.yaml b/examples/experimental/config/eval_config.yaml
index 48202ab2b..41085195e 100644
--- a/examples/experimental/config/eval_config.yaml
+++ b/examples/experimental/config/eval_config.yaml
@@ -1,17 +1,17 @@
 res_path: examples/experimental/dataframes # Store dataframes here
-test_dataset_size: 10_000 # Number of test scenarios to evaluate on
+test_dataset_size: 10000 # Number of test scenarios to evaluate on
 
 # Environment settings
 train_dir: data/processed/training 
 test_dir: data/processed/validation 
 
-num_worlds: 50 # Number of parallel environments for evaluation
+num_worlds: 100 # Number of parallel environments for evaluation
 max_controlled_agents: 64 # Maximum number of agents controlled by the model.
 ego_state: true
 road_map_obs: true
 partner_obs: true
 norm_obs: true
-remove_non_vehicles: true # If false, all agents are included (vehicles, pedestrians, cyclists)
+remove_non_vehicles: false # If false, all agents are included (vehicles, pedestrians, cyclists)
 lidar_obs: false # NOTE: Setting this to true currently turns of the other observation types
 reward_type: "weighted_combination"
 collision_weight: -0.75
@@ -24,8 +24,13 @@ polyline_reduction_threshold: 0.1 # Rate at which to sample points from the poly
 sampling_seed: 42 # If given, the set of scenes to sample from will be deterministic, if None, the set of scenes will be random
 obs_radius: 50.0 # Visibility radius of the agents
 init_roadgraph: False
+init_mode: all_valid #all_non_trivial
 render_3d: True
 
+# Reward conditioning
+condition_mode: None
+agent_type: None
+
 # Number of discretizations in the action space
 # Note: Make sure that this equals the discretizations that the policy
 # has been trained with
diff --git a/examples/experimental/get_model_performance.py b/examples/experimental/get_model_performance.py
index 70443d852..c6b84b715 100644
--- a/examples/experimental/get_model_performance.py
+++ b/examples/experimental/get_model_performance.py
@@ -4,13 +4,13 @@
 import numpy as np
 import os
 import logging
+
+from eval_utils import evaluate_policy
+
+from gpudrive.utils.env import make_env
+from gpudrive.utils.config import load_config
+from gpudrive.utils.checkpoint import load_policy
 from gpudrive.env.dataset import SceneDataLoader
-from eval_utils import (
-    load_config,
-    make_env,
-    load_policy,
-    evaluate_policy,
-)
 
 import random
 import torch
@@ -52,7 +52,6 @@ def set_seed(seed: int):
             path_to_cpt=model_config.models_path,
             model_name=model.name,
             device=eval_config.device,
-            env=env,
         )
 
         # Create dataloaders for train and test sets
diff --git a/examples/experimental/notebooks/04_reward_cond_agents.ipynb b/examples/experimental/notebooks/04_reward_cond_agents.ipynb
new file mode 100644
index 000000000..d71ef81cb
--- /dev/null
+++ b/examples/experimental/notebooks/04_reward_cond_agents.ipynb
@@ -0,0 +1,564 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import dataclasses\n",
+    "import mediapy\n",
+    "from huggingface_hub import PyTorchModelHubMixin\n",
+    "from huggingface_hub import ModelCard\n",
+    "from gpudrive.networks.late_fusion import NeuralNet\n",
+    "import matplotlib.pyplot as plt\n",
+    "from collections import defaultdict\n",
+    "import random\n",
+    "import torch\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "from tqdm import tqdm\n",
+    "\n",
+    "\n",
+    "from gpudrive.env.config import EnvConfig\n",
+    "from gpudrive.env.env_torch import GPUDriveTorchEnv\n",
+    "from gpudrive.visualize.utils import img_from_fig\n",
+    "from gpudrive.env.dataset import SceneDataLoader\n",
+    "from gpudrive.utils.config import load_config\n",
+    "from gpudrive.utils.checkpoint import load_policy\n",
+    "from gpudrive.utils.rollout import rollout\n",
+    "\n",
+    "from PIL import Image"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'mode': 'train', 'use_rnn': False, 'eval_model_path': None, 'baseline': False, 'data_dir': 'data/processed/training', 'continue_training': False, 'model_cpt': None, 'environment': {'name': 'gpudrive', 'num_worlds': 50, 'k_unique_scenes': 50, 'max_controlled_agents': 64, 'ego_state': True, 'road_map_obs': True, 'partner_obs': True, 'norm_obs': True, 'remove_non_vehicles': False, 'lidar_obs': False, 'reward_type': 'reward_conditioned', 'collision_weight': -0.75, 'off_road_weight': -0.75, 'goal_achieved_weight': 1.0, 'init_mode': 'all_non_trivial', 'condition_mode': 'random', 'collision_weight_lb': -3.0, 'collision_weight_ub': 0.01, 'goal_achieved_weight_lb': 1.0, 'goal_achieved_weight_ub': 3.0, 'off_road_weight_lb': -3.0, 'off_road_weight_ub': 0.0, 'dynamics_model': 'classic', 'collision_behavior': 'ignore', 'dist_to_goal_threshold': 2.0, 'polyline_reduction_threshold': 0.1, 'sampling_seed': 42, 'obs_radius': 50.0, 'action_space_steer_disc': 13, 'action_space_accel_disc': 7, 'use_vbd': False, 'vbd_model_path': 'gpudrive/integrations/vbd/weights/epoch=18.ckpt', 'init_steps': 11, 'vbd_trajectory_weight': 0.1, 'vbd_in_obs': False}, 'wandb': {'entity': '', 'project': 'kshotagents', 'group': 'reward_conditioned', 'mode': 'online', 'tags': ['ppo', 'ff']}, 'train': {'exp_id': 'PPO', 'seed': 42, 'cpu_offload': False, 'device': 'cuda', 'bptt_horizon': 1, 'compile': False, 'compile_mode': 'reduce-overhead', 'resample_scenes': True, 'resample_dataset_size': 10000, 'resample_interval': 2000000, 'sample_with_replacement': True, 'shuffle_dataset': False, 'torch_deterministic': False, 'total_timesteps': 2000000000, 'batch_size': 262144, 'minibatch_size': 8192, 'learning_rate': '3e-4', 'anneal_lr': False, 'gamma': 0.99, 'gae_lambda': 0.95, 'update_epochs': 4, 'norm_adv': True, 'clip_coef': 0.2, 'clip_vloss': False, 'vf_clip_coef': 0.2, 'ent_coef': 0.0001, 'vf_coef': 0.3, 'max_grad_norm': 0.5, 'target_kl': None, 'log_window': 1000, 'network': {'input_dim': 64, 'hidden_dim': 128, 'dropout': 0.01, 'class_name': 'NeuralNet', 'num_parameters': 0}, 'checkpoint_interval': 500, 'checkpoint_path': './runs', 'render': False, 'render_3d': True, 'render_interval': 1, 'render_k_scenarios': 10, 'render_format': 'mp4', 'render_fps': 15, 'zoom_radius': 50}, 'vec': {'backend': 'native', 'num_workers': 1, 'env_batch_size': 1, 'zero_copy': False}}\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Configs model has been trained with\n",
+    "config = load_config(\"/home/emerge/gpudrive/baselines/ppo/config/ppo_base_puffer\")\n",
+    "\n",
+    "print(config)\n",
+    "\n",
+    "num_envs = 4\n",
+    "device = \"cpu\"\n",
+    "max_agents = 64\n",
+    "\n",
+    "config.environment.reward_type = \"reward_conditioned\"\n",
+    "config.environment.condition_mode = \"fixed\"\n",
+    "config.environment.agent_type = torch.Tensor([-0.2, 1.0, -0.2])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Load model from /home/emerge/gpudrive/examples/experimental/models/rew_conditioned_0321.pt\n"
+     ]
+    }
+   ],
+   "source": [
+    "agent = load_policy(\n",
+    "    model_name=\"rew_conditioned_0321\",\n",
+    "    path_to_cpt=\"/home/emerge/gpudrive/examples/experimental/models\",\n",
+    "    env_config=config.environment,\n",
+    "    device=device\n",
+    ");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create data loader\n",
+    "train_loader = SceneDataLoader(\n",
+    "    root='/home/emerge/gpudrive/data/processed/examples/',\n",
+    "    batch_size=num_envs,\n",
+    "    dataset_size=100,\n",
+    "    sample_with_replacement=False,\n",
+    ")\n",
+    "\n",
+    "# Set params\n",
+    "config = config.environment\n",
+    "env_config = dataclasses.replace(\n",
+    "    EnvConfig(),\n",
+    "    norm_obs=config.norm_obs,\n",
+    "    dynamics_model=config.dynamics_model,\n",
+    "    collision_behavior=config.collision_behavior,\n",
+    "    dist_to_goal_threshold=config.dist_to_goal_threshold,\n",
+    "    polyline_reduction_threshold=config.polyline_reduction_threshold,\n",
+    "    remove_non_vehicles=config.remove_non_vehicles,\n",
+    "    lidar_obs=config.lidar_obs,\n",
+    "    disable_classic_obs=config.lidar_obs,\n",
+    "    obs_radius=config.obs_radius,\n",
+    "    steer_actions = torch.round(\n",
+    "        torch.linspace(-torch.pi, torch.pi, config.action_space_steer_disc), decimals=3  \n",
+    "    ),\n",
+    "    accel_actions = torch.round(\n",
+    "        torch.linspace(-4.0, 4.0, config.action_space_accel_disc), decimals=3\n",
+    "    ),\n",
+    "    reward_type=config.reward_type,\n",
+    "    condition_mode=config.condition_mode,\n",
+    "    agent_type=config.agent_type,\n",
+    ")\n",
+    "\n",
+    "# Make env\n",
+    "env = GPUDriveTorchEnv(\n",
+    "    config=env_config,\n",
+    "    data_loader=train_loader,\n",
+    "    max_cont_agents=1, #config.max_controlled_agents,\n",
+    "    device=device,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def run_multiple_rollouts(\n",
+    "    env, \n",
+    "    agent, \n",
+    "    num_rollouts=2, \n",
+    "    device='cpu',\n",
+    "    sample_collision_weights=True,\n",
+    "    sample_goal_weights=False,\n",
+    "    sample_offroad_weights=False,\n",
+    "    agent_type=None,\n",
+    "):\n",
+    "    \"\"\"\n",
+    "    Run multiple rollouts with different collision weights and store trajectories.\n",
+    "    Stores agent positions as a tensor of shape [num_envs, num_rollouts, agents, steps, 2].\n",
+    "    \n",
+    "    Args:\n",
+    "        env: The environment (can be batched with multiple environments)\n",
+    "        agent: The policy\n",
+    "        num_rollouts: Number of rollouts to perform\n",
+    "        device: Device to run on\n",
+    "        \n",
+    "    Returns:\n",
+    "        all_trajectories: Dictionary containing trajectories and weights\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    all_agent_positions = []\n",
+    "    collision_weights = []\n",
+    "    goal_weights = []\n",
+    "    offroad_weights = []\n",
+    "    all_goal_achieved = []\n",
+    "    all_collided = []\n",
+    "    all_off_road = []\n",
+    "    all_episode_lengths = []\n",
+    "    \n",
+    "    print(f\"Running {num_rollouts} rollouts, sampling weights: collision={sample_collision_weights}, goal={sample_goal_weights}, offroad={sample_offroad_weights}\\n\")\n",
+    "    \n",
+    "    for i in tqdm(range(num_rollouts), desc=\"Processing rollouts\", unit=\"rollout\"):\n",
+    "        \n",
+    "        # Sample weights\n",
+    "        if agent_type is not None:\n",
+    "            agent_weights = agent_type\n",
+    "            collision_weight = agent_weights[0].item()\n",
+    "            goal_weight = agent_weights[1].item()\n",
+    "            off_road_weight = agent_weights[2].item()\n",
+    "        else:\n",
+    "            if sample_collision_weights:\n",
+    "                collision_weight = random.uniform(-3.0, 1.0)\n",
+    "            else:\n",
+    "                collision_weight = -3.0\n",
+    "            if sample_goal_weights:\n",
+    "                goal_weight = random.uniform(1.0, 3.0)\n",
+    "            else:\n",
+    "                goal_weight = 1.0\n",
+    "            if sample_offroad_weights:\n",
+    "                off_road_weight = random.uniform(-3.0, 1.0)\n",
+    "            else:\n",
+    "                off_road_weight = -3.0\n",
+    "\n",
+    "            agent_weights = torch.Tensor([collision_weight, goal_weight, off_road_weight])\n",
+    "        \n",
+    "        # Run rollout with these weights\n",
+    "        (\n",
+    "            goal_achieved_count,\n",
+    "            frac_goal_achieved,\n",
+    "            collided_count,\n",
+    "            frac_collided,\n",
+    "            off_road_count,\n",
+    "            frac_off_road,\n",
+    "            not_goal_nor_crash_count,\n",
+    "            frac_not_goal_nor_crash_per_scene,\n",
+    "            controlled_agents_per_scene,\n",
+    "            sim_state_frames,\n",
+    "            agent_positions,\n",
+    "            episode_lengths\n",
+    "        ) = rollout(\n",
+    "            env=env,\n",
+    "            policy=agent,\n",
+    "            device=device,\n",
+    "            deterministic=False,\n",
+    "            return_agent_positions=True,\n",
+    "            set_agent_type=True,\n",
+    "            agent_weights=agent_weights,\n",
+    "        )\n",
+    "        \n",
+    "        # Store weights and positions\n",
+    "        collision_weights.append(collision_weight)\n",
+    "        goal_weights.append(goal_weight)\n",
+    "        offroad_weights.append(off_road_weight)\n",
+    "        all_agent_positions.append(agent_positions.clone().detach())\n",
+    "        \n",
+    "        # Store other metrics\n",
+    "        all_goal_achieved.append(goal_achieved_count)\n",
+    "        all_collided.append(collided_count)\n",
+    "        all_off_road.append(off_road_count)\n",
+    "        all_episode_lengths.append(episode_lengths)\n",
+    "    \n",
+    "    # Stack agent positions along a new dimension at position 1 (after num_envs)\n",
+    "    # From list of [num_envs, num_agents, time_steps, 2] to tensor of [num_envs, num_rollouts, num_agents, time_steps, 2]\n",
+    "    stacked_positions = torch.stack(all_agent_positions, dim=1)\n",
+    "    \n",
+    "    # Return organized data\n",
+    "    all_trajectories = {\n",
+    "        'collision_weights': torch.tensor(collision_weights),\n",
+    "        'goal_weights': torch.tensor(goal_weights),\n",
+    "        'offroad_weights': torch.tensor(offroad_weights),\n",
+    "        'agent_positions': stacked_positions,  # Shape: [num_envs, num_rollouts, num_agents, time_steps, 2]\n",
+    "        'goal_achieved': all_goal_achieved,\n",
+    "        'collided': all_collided,\n",
+    "        'off_road': all_off_road,\n",
+    "        'episode_lengths': all_episode_lengths\n",
+    "    }\n",
+    "    \n",
+    "    return all_trajectories"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Define different agent types to compare\n",
+    "agent_configs = { # Collision, Goal, Off-road\n",
+    "    'Nominal': torch.tensor([-0.75, 1.0, -0.75], device=device),\n",
+    "    'Aggressive': torch.tensor([0.0, 2.0, 0.0], device=device),\n",
+    "    'Risk-averse': torch.tensor([-2.0, 0.5, -2.0], device=device),\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Running 50 rollouts, sampling weights: collision=True, goal=False, offroad=False\n",
+      "\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Processing rollouts: 100%|██████████| 50/50 [01:25<00:00,  1.70s/rollout]\n"
+     ]
+    }
+   ],
+   "source": [
+    "trajs = run_multiple_rollouts(\n",
+    "    env=env,\n",
+    "    agent=agent,\n",
+    "    num_rollouts=50,\n",
+    "    device='cpu',\n",
+    "    sample_collision_weights=True,\n",
+    "    sample_goal_weights=False,\n",
+    "    sample_offroad_weights=False,\n",
+    "    #agent_type=agent_configs['Risk-averse'],\n",
+    ");"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=800x800>"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "env.vis.figsize = (8, 8)\n",
+    "\n",
+    "# Plot simulator state with the stacked trajectories\n",
+    "_ = env.reset(agent_type=torch.Tensor([-0.2, 1.0, -0.2]))\n",
+    "img = env.vis.plot_simulator_state(\n",
+    "    env_indices=[1], \n",
+    "    agent_positions=trajs['agent_positions'],  # Pass stacked trajectories directly\n",
+    "    zoom_radius=70,\n",
+    "    multiple_rollouts=True,\n",
+    "    line_alpha=0.5,          \n",
+    "    line_width=1.0,     \n",
+    "    weights=trajs['collision_weights'],     \n",
+    "    colorbar=True, \n",
+    ")[0]\n",
+    "\n",
+    "Image.fromarray(img_from_fig(img))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Figure saved as effect_of_rew_cond.png\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig = img  \n",
+    "filename = \"effect_of_rew_cond.png\"\n",
+    "fig.savefig(filename, dpi=300, bbox_inches='tight', pad_inches=0.1)\n",
+    "print(f\"Figure saved as {filename}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Analyze diversity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Collecting rollout data...\n",
+      "  Rollout 1/2\n",
+      "  Rollout 2/2\n"
+     ]
+    }
+   ],
+   "source": [
+    "agent_configs = {\n",
+    "    'Nominal': torch.tensor([-0.5, 0.1, -0.5], device=device),\n",
+    "}\n",
+    "\n",
+    "print(\"Collecting rollout data...\")\n",
+    "collected_data = {}\n",
+    "\n",
+    "agent_weights = torch.Tensor([-0.2, 1.0, -0.2])\n",
+    "\n",
+    "\n",
+    "div_metrics = collect_rollout_data(\n",
+    "    env, agent, agent_weights, device, 2\n",
+    ")\n",
+    "\n",
+    "#df = store_data_to_dataframe(list(agent_configs.keys()), collected_data)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['situation_responses', 'entropy_values', 'logprob_values'])"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "div_metrics.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([5, 64, 91])"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "div_metrics['entropy_values'].shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Effect on human-replay interaction"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "\n",
+    "# Set up the styling\n",
+    "sns.set(\"notebook\", font_scale=1.05, rc={\"figure.figsize\": (10, 5)})\n",
+    "sns.set_style(\"ticks\", rc={\"figure.facecolor\": \"none\", \"axes.facecolor\": \"none\"})\n",
+    "%config InlineBackend.figure_format = 'svg'\n",
+    "# Prepare the data for the plots\n",
+    "agents = ['Self-play', 'Population play']\n",
+    "\n",
+    "# Data for the first plot: controlling all agents\n",
+    "all_agents_rates = [0.5, 2.85]\n",
+    "all_agents_df = pd.DataFrame({\n",
+    "    'Agent': agents,\n",
+    "    'Collision Rate (%)': all_agents_rates\n",
+    "})\n",
+    "\n",
+    "# Data for the second plot: controlling single agent\n",
+    "single_agent_rates = [6.0, 9.50]\n",
+    "single_agent_df = pd.DataFrame({\n",
+    "    'Agent': agents,\n",
+    "    'Collision Rate (%)': single_agent_rates\n",
+    "})\n",
+    "\n",
+    "# Calculate relative increase as multiples (times increase) for the third plot\n",
+    "relative_increases = []\n",
+    "for i in range(len(agents)):\n",
+    "    # Formula for X times increase: new_value / old_value\n",
+    "    times_increase = single_agent_rates[i] / all_agents_rates[i]\n",
+    "    relative_increases.append(times_increase)\n",
+    "\n",
+    "relative_df = pd.DataFrame({\n",
+    "    'Agent': agents,\n",
+    "    'Performance drop SP -> Human': relative_increases\n",
+    "})\n",
+    "\n",
+    "# Create 1x3 subplots\n",
+    "fig, axs = plt.subplots(1, 3, figsize=(12, 4))\n",
+    "\n",
+    "# Plot 1: Collision rates controlling all agents\n",
+    "sns.barplot(x='Agent', y='Collision Rate (%)', hue='Agent', data=all_agents_df, \n",
+    "           palette='muted', legend=False, ax=axs[0])\n",
+    "axs[0].set_title('Controlling All Agents')\n",
+    "axs[0].set_ylim(0, max(all_agents_rates) * 1.2)  # Add some space above bars\n",
+    "for i, v in enumerate(all_agents_rates):\n",
+    "    axs[0].text(i, v + 0.1, f\"{v}%\", ha='center')\n",
+    "\n",
+    "# Plot 2: Collision rates controlling single agent\n",
+    "sns.barplot(x='Agent', y='Collision Rate (%)', hue='Agent', data=single_agent_df, \n",
+    "           palette='pastel', legend=False, ax=axs[1])\n",
+    "axs[1].set_title('Control Single Agent \\n with Human Replays')\n",
+    "axs[1].set_ylim(0, max(single_agent_rates) * 1.2)  # Add some space above bars\n",
+    "for i, v in enumerate(single_agent_rates):\n",
+    "    axs[1].text(i, v + 0.3, f\"{v}%\", ha='center')\n",
+    "\n",
+    "# Plot 3: Times increase\n",
+    "sns.barplot(x='Agent', y='Performance drop SP -> Human', hue='Agent', data=relative_df, \n",
+    "           palette='dark', legend=False, ax=axs[2])\n",
+    "axs[2].set_title('Rel. Increase in Collision Rates \\n (X times)', y=1.05)\n",
+    "for i, v in enumerate(relative_increases):\n",
+    "    axs[2].text(i, v + 0.3, f\"{v:.1f}x\", ha='center')\n",
+    "\n",
+    "# Add annotation about risk averse agents\n",
+    "fig.text(0.5, 0.01, \n",
+    "         \"Note: The Population play agent type is set to be risk averse.\", \n",
+    "         ha='center', fontsize=10, style='italic')\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.subplots_adjust(bottom=0.2)  # Make room for annotation\n",
+    "sns.despine()\n",
+    "plt.savefig('collision_rates_comparison.png', dpi=300)\n",
+    "\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "gpudrive",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb
new file mode 100644
index 000000000..2e181f503
--- /dev/null
+++ b/examples/experimental/notebooks/05_getting_to_know_the_pop.ipynb
@@ -0,0 +1,3210 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import warnings\n",
+    "import matplotlib as mpl\n",
+    "import matplotlib.pyplot as plt\n",
+    "import datetime\n",
+    "\n",
+    "# Set up the styling\n",
+    "sns.set(\"notebook\", font_scale=1.05, rc={\"figure.figsize\": (10, 5)})\n",
+    "sns.set_style(\"ticks\", rc={\"figure.facecolor\": \"none\", \"axes.facecolor\": \"none\"})\n",
+    "%config InlineBackend.figure_format = 'svg'\n",
+    "warnings.filterwarnings(\"ignore\")\n",
+    "plt.set_loglevel(\"WARNING\")\n",
+    "mpl.rcParams[\"lines.markersize\"] = 8"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "=== Agent Type Comparison ===\n",
+      "\n",
+      "Policy Entropy by Agent Type (higher = more uncertain):\n",
+      "agent_type\n",
+      "Risk-averse    2.230663\n",
+      "Nominal        1.935405\n",
+      "Aggressive     1.706336\n",
+      "Name: mean, dtype: float64\n",
+      "\n",
+      "Average Log Probability (higher = more confident):\n",
+      "agent_type\n",
+      "Aggressive    -1.715222\n",
+      "Nominal       -1.939547\n",
+      "Risk-averse   -2.238968\n",
+      "Name: logprob, dtype: float64\n",
+      "\n",
+      "Average Acceleration by Agent Type:\n",
+      "agent_type\n",
+      "Aggressive     3.117953\n",
+      "Nominal        2.036616\n",
+      "Risk-averse    0.085136\n",
+      "Name: acceleration, dtype: float64\n",
+      "\n",
+      "Average Steering by Agent Type (absolute value - measures turning intensity):\n",
+      "agent_type\n",
+      "Risk-averse    2.363364\n",
+      "Nominal        2.156945\n",
+      "Aggressive     2.056634\n",
+      "dtype: float64\n",
+      "\n",
+      "Average Goal Achievement Rate by Agent Type:\n",
+      "agent_type\n",
+      "Aggressive     1.000000\n",
+      "Nominal        0.966185\n",
+      "Risk-averse    0.756087\n",
+      "Name: frac_goal_achieved, dtype: float64\n",
+      "\n",
+      "Average Collision Rate by Agent Type:\n",
+      "agent_type\n",
+      "Nominal        0.132341\n",
+      "Aggressive     0.110032\n",
+      "Risk-averse    0.090811\n",
+      "Name: frac_collided, dtype: float64\n",
+      "\n",
+      "Variation Across Scenarios (higher = less consistent behavior):\n",
+      "             acceleration  steering\n",
+      "agent_type                         \n",
+      "Aggressive       0.361163  0.170644\n",
+      "Nominal          0.982940  0.419780\n",
+      "Risk-averse      1.228092  0.574757\n"
+     ]
+    }
+   ],
+   "source": [
+    "from gpudrive.utils.diversity import compare_agent_types\n",
+    "\n",
+    "# Load the saved DataFrame\n",
+    "df = pd.read_csv(\"/home/emerge/gpudrive/agent_type_comparison_data.csv\")\n",
+    "\n",
+    "results = compare_agent_types(df)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "dict_keys(['acceleration_distribution', 'steering_distribution', 'entropy_stats', 'action_diversity', 'avg_logprob', 'time_series', 'goal_rate', 'collision_rate'])"
+      ]
+     },
+     "execution_count": 3,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results.keys()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>mean</th>\n",
+       "      <th>std</th>\n",
+       "      <th>min</th>\n",
+       "      <th>max</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>agent_type</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Aggressive</th>\n",
+       "      <td>1.706336</td>\n",
+       "      <td>0.702564</td>\n",
+       "      <td>0.000793</td>\n",
+       "      <td>3.484450</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Nominal</th>\n",
+       "      <td>1.935405</td>\n",
+       "      <td>0.737693</td>\n",
+       "      <td>0.001746</td>\n",
+       "      <td>3.495515</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Risk-averse</th>\n",
+       "      <td>2.230663</td>\n",
+       "      <td>0.685508</td>\n",
+       "      <td>0.014702</td>\n",
+       "      <td>3.733659</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                 mean       std       min       max\n",
+       "agent_type                                         \n",
+       "Aggressive   1.706336  0.702564  0.000793  3.484450\n",
+       "Nominal      1.935405  0.737693  0.001746  3.495515\n",
+       "Risk-averse  2.230663  0.685508  0.014702  3.733659"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "results['entropy_stats']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%matplotlib inline\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/svg+xml": [
+       "<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n",
+       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
+       "  \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
+       "<svg xmlns:xlink=\"http://www.w3.org/1999/xlink\" width=\"699.500234pt\" height=\"565.248359pt\" viewBox=\"0 0 699.500234 565.248359\" xmlns=\"http://www.w3.org/2000/svg\" version=\"1.1\">\n",
+       " <metadata>\n",
+       "  <rdf:RDF xmlns:dc=\"http://purl.org/dc/elements/1.1/\" xmlns:cc=\"http://creativecommons.org/ns#\" xmlns:rdf=\"http://www.w3.org/1999/02/22-rdf-syntax-ns#\">\n",
+       "   <cc:Work>\n",
+       "    <dc:type rdf:resource=\"http://purl.org/dc/dcmitype/StillImage\"/>\n",
+       "    <dc:date>2025-04-07T12:56:17.566570</dc:date>\n",
+       "    <dc:format>image/svg+xml</dc:format>\n",
+       "    <dc:creator>\n",
+       "     <cc:Agent>\n",
+       "      <dc:title>Matplotlib v3.9.0, https://matplotlib.org/</dc:title>\n",
+       "     </cc:Agent>\n",
+       "    </dc:creator>\n",
+       "   </cc:Work>\n",
+       "  </rdf:RDF>\n",
+       " </metadata>\n",
+       " <defs>\n",
+       "  <style type=\"text/css\">*{stroke-linejoin: round; stroke-linecap: butt}</style>\n",
+       " </defs>\n",
+       " <g id=\"figure_1\">\n",
+       "  <g id=\"patch_1\">\n",
+       "   <path d=\"M 0 565.248359 \n",
+       "L 699.500234 565.248359 \n",
+       "L 699.500234 0 \n",
+       "L 0 0 \n",
+       "L 0 565.248359 \n",
+       "z\n",
+       "\" style=\"fill: none\"/>\n",
+       "  </g>\n",
+       "  <g id=\"axes_1\">\n",
+       "   <g id=\"patch_2\">\n",
+       "    <path d=\"M 48.746234 168.156 \n",
+       "L 337.934234 168.156 \n",
+       "L 337.934234 54.456 \n",
+       "L 48.746234 54.456 \n",
+       "L 48.746234 168.156 \n",
+       "z\n",
+       "\" style=\"fill: none\"/>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_1\">\n",
+       "    <g id=\"xtick_1\">\n",
+       "     <g id=\"line2d_1\">\n",
+       "      <defs>\n",
+       "       <path id=\"mff7ad7bf4a\" d=\"M 0 0 \n",
+       "L 0 6 \n",
+       "\" style=\"stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </defs>\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"96.944234\" y=\"168.156\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_1\">\n",
+       "      <!-- Aggressive -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(65.271066 186.432195) scale(0.1155 -0.1155)\">\n",
+       "       <defs>\n",
+       "        <path id=\"DejaVuSans-41\" d=\"M 2188 4044 \n",
+       "L 1331 1722 \n",
+       "L 3047 1722 \n",
+       "L 2188 4044 \n",
+       "z\n",
+       "M 1831 4666 \n",
+       "L 2547 4666 \n",
+       "L 4325 0 \n",
+       "L 3669 0 \n",
+       "L 3244 1197 \n",
+       "L 1141 1197 \n",
+       "L 716 0 \n",
+       "L 50 0 \n",
+       "L 1831 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-67\" d=\"M 2906 1791 \n",
+       "Q 2906 2416 2648 2759 \n",
+       "Q 2391 3103 1925 3103 \n",
+       "Q 1463 3103 1205 2759 \n",
+       "Q 947 2416 947 1791 \n",
+       "Q 947 1169 1205 825 \n",
+       "Q 1463 481 1925 481 \n",
+       "Q 2391 481 2648 825 \n",
+       "Q 2906 1169 2906 1791 \n",
+       "z\n",
+       "M 3481 434 \n",
+       "Q 3481 -459 3084 -895 \n",
+       "Q 2688 -1331 1869 -1331 \n",
+       "Q 1566 -1331 1297 -1286 \n",
+       "Q 1028 -1241 775 -1147 \n",
+       "L 775 -588 \n",
+       "Q 1028 -725 1275 -790 \n",
+       "Q 1522 -856 1778 -856 \n",
+       "Q 2344 -856 2625 -561 \n",
+       "Q 2906 -266 2906 331 \n",
+       "L 2906 616 \n",
+       "Q 2728 306 2450 153 \n",
+       "Q 2172 0 1784 0 \n",
+       "Q 1141 0 747 490 \n",
+       "Q 353 981 353 1791 \n",
+       "Q 353 2603 747 3093 \n",
+       "Q 1141 3584 1784 3584 \n",
+       "Q 2172 3584 2450 3431 \n",
+       "Q 2728 3278 2906 2969 \n",
+       "L 2906 3500 \n",
+       "L 3481 3500 \n",
+       "L 3481 434 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-72\" d=\"M 2631 2963 \n",
+       "Q 2534 3019 2420 3045 \n",
+       "Q 2306 3072 2169 3072 \n",
+       "Q 1681 3072 1420 2755 \n",
+       "Q 1159 2438 1159 1844 \n",
+       "L 1159 0 \n",
+       "L 581 0 \n",
+       "L 581 3500 \n",
+       "L 1159 3500 \n",
+       "L 1159 2956 \n",
+       "Q 1341 3275 1631 3429 \n",
+       "Q 1922 3584 2338 3584 \n",
+       "Q 2397 3584 2469 3576 \n",
+       "Q 2541 3569 2628 3553 \n",
+       "L 2631 2963 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-65\" d=\"M 3597 1894 \n",
+       "L 3597 1613 \n",
+       "L 953 1613 \n",
+       "Q 991 1019 1311 708 \n",
+       "Q 1631 397 2203 397 \n",
+       "Q 2534 397 2845 478 \n",
+       "Q 3156 559 3463 722 \n",
+       "L 3463 178 \n",
+       "Q 3153 47 2828 -22 \n",
+       "Q 2503 -91 2169 -91 \n",
+       "Q 1331 -91 842 396 \n",
+       "Q 353 884 353 1716 \n",
+       "Q 353 2575 817 3079 \n",
+       "Q 1281 3584 2069 3584 \n",
+       "Q 2775 3584 3186 3129 \n",
+       "Q 3597 2675 3597 1894 \n",
+       "z\n",
+       "M 3022 2063 \n",
+       "Q 3016 2534 2758 2815 \n",
+       "Q 2500 3097 2075 3097 \n",
+       "Q 1594 3097 1305 2825 \n",
+       "Q 1016 2553 972 2059 \n",
+       "L 3022 2063 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-73\" d=\"M 2834 3397 \n",
+       "L 2834 2853 \n",
+       "Q 2591 2978 2328 3040 \n",
+       "Q 2066 3103 1784 3103 \n",
+       "Q 1356 3103 1142 2972 \n",
+       "Q 928 2841 928 2578 \n",
+       "Q 928 2378 1081 2264 \n",
+       "Q 1234 2150 1697 2047 \n",
+       "L 1894 2003 \n",
+       "Q 2506 1872 2764 1633 \n",
+       "Q 3022 1394 3022 966 \n",
+       "Q 3022 478 2636 193 \n",
+       "Q 2250 -91 1575 -91 \n",
+       "Q 1294 -91 989 -36 \n",
+       "Q 684 19 347 128 \n",
+       "L 347 722 \n",
+       "Q 666 556 975 473 \n",
+       "Q 1284 391 1588 391 \n",
+       "Q 1994 391 2212 530 \n",
+       "Q 2431 669 2431 922 \n",
+       "Q 2431 1156 2273 1281 \n",
+       "Q 2116 1406 1581 1522 \n",
+       "L 1381 1569 \n",
+       "Q 847 1681 609 1914 \n",
+       "Q 372 2147 372 2553 \n",
+       "Q 372 3047 722 3315 \n",
+       "Q 1072 3584 1716 3584 \n",
+       "Q 2034 3584 2315 3537 \n",
+       "Q 2597 3491 2834 3397 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-69\" d=\"M 603 3500 \n",
+       "L 1178 3500 \n",
+       "L 1178 0 \n",
+       "L 603 0 \n",
+       "L 603 3500 \n",
+       "z\n",
+       "M 603 4863 \n",
+       "L 1178 4863 \n",
+       "L 1178 4134 \n",
+       "L 603 4134 \n",
+       "L 603 4863 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-76\" d=\"M 191 3500 \n",
+       "L 800 3500 \n",
+       "L 1894 563 \n",
+       "L 2988 3500 \n",
+       "L 3597 3500 \n",
+       "L 2284 0 \n",
+       "L 1503 0 \n",
+       "L 191 3500 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       </defs>\n",
+       "       <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"131.884766\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"195.361328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"234.224609\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"295.748047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"347.847656\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"399.947266\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"427.730469\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"486.910156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_2\">\n",
+       "     <g id=\"line2d_2\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"193.340234\" y=\"168.156\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_2\">\n",
+       "      <!-- Nominal -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(169.453391 186.432195) scale(0.1155 -0.1155)\">\n",
+       "       <defs>\n",
+       "        <path id=\"DejaVuSans-4e\" d=\"M 628 4666 \n",
+       "L 1478 4666 \n",
+       "L 3547 763 \n",
+       "L 3547 4666 \n",
+       "L 4159 4666 \n",
+       "L 4159 0 \n",
+       "L 3309 0 \n",
+       "L 1241 3903 \n",
+       "L 1241 0 \n",
+       "L 628 0 \n",
+       "L 628 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-6f\" d=\"M 1959 3097 \n",
+       "Q 1497 3097 1228 2736 \n",
+       "Q 959 2375 959 1747 \n",
+       "Q 959 1119 1226 758 \n",
+       "Q 1494 397 1959 397 \n",
+       "Q 2419 397 2687 759 \n",
+       "Q 2956 1122 2956 1747 \n",
+       "Q 2956 2369 2687 2733 \n",
+       "Q 2419 3097 1959 3097 \n",
+       "z\n",
+       "M 1959 3584 \n",
+       "Q 2709 3584 3137 3096 \n",
+       "Q 3566 2609 3566 1747 \n",
+       "Q 3566 888 3137 398 \n",
+       "Q 2709 -91 1959 -91 \n",
+       "Q 1206 -91 779 398 \n",
+       "Q 353 888 353 1747 \n",
+       "Q 353 2609 779 3096 \n",
+       "Q 1206 3584 1959 3584 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-6d\" d=\"M 3328 2828 \n",
+       "Q 3544 3216 3844 3400 \n",
+       "Q 4144 3584 4550 3584 \n",
+       "Q 5097 3584 5394 3201 \n",
+       "Q 5691 2819 5691 2113 \n",
+       "L 5691 0 \n",
+       "L 5113 0 \n",
+       "L 5113 2094 \n",
+       "Q 5113 2597 4934 2840 \n",
+       "Q 4756 3084 4391 3084 \n",
+       "Q 3944 3084 3684 2787 \n",
+       "Q 3425 2491 3425 1978 \n",
+       "L 3425 0 \n",
+       "L 2847 0 \n",
+       "L 2847 2094 \n",
+       "Q 2847 2600 2669 2842 \n",
+       "Q 2491 3084 2119 3084 \n",
+       "Q 1678 3084 1418 2786 \n",
+       "Q 1159 2488 1159 1978 \n",
+       "L 1159 0 \n",
+       "L 581 0 \n",
+       "L 581 3500 \n",
+       "L 1159 3500 \n",
+       "L 1159 2956 \n",
+       "Q 1356 3278 1631 3431 \n",
+       "Q 1906 3584 2284 3584 \n",
+       "Q 2666 3584 2933 3390 \n",
+       "Q 3200 3197 3328 2828 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-6e\" d=\"M 3513 2113 \n",
+       "L 3513 0 \n",
+       "L 2938 0 \n",
+       "L 2938 2094 \n",
+       "Q 2938 2591 2744 2837 \n",
+       "Q 2550 3084 2163 3084 \n",
+       "Q 1697 3084 1428 2787 \n",
+       "Q 1159 2491 1159 1978 \n",
+       "L 1159 0 \n",
+       "L 581 0 \n",
+       "L 581 3500 \n",
+       "L 1159 3500 \n",
+       "L 1159 2956 \n",
+       "Q 1366 3272 1645 3428 \n",
+       "Q 1925 3584 2291 3584 \n",
+       "Q 2894 3584 3203 3211 \n",
+       "Q 3513 2838 3513 2113 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-61\" d=\"M 2194 1759 \n",
+       "Q 1497 1759 1228 1600 \n",
+       "Q 959 1441 959 1056 \n",
+       "Q 959 750 1161 570 \n",
+       "Q 1363 391 1709 391 \n",
+       "Q 2188 391 2477 730 \n",
+       "Q 2766 1069 2766 1631 \n",
+       "L 2766 1759 \n",
+       "L 2194 1759 \n",
+       "z\n",
+       "M 3341 1997 \n",
+       "L 3341 0 \n",
+       "L 2766 0 \n",
+       "L 2766 531 \n",
+       "Q 2569 213 2275 61 \n",
+       "Q 1981 -91 1556 -91 \n",
+       "Q 1019 -91 701 211 \n",
+       "Q 384 513 384 1019 \n",
+       "Q 384 1609 779 1909 \n",
+       "Q 1175 2209 1959 2209 \n",
+       "L 2766 2209 \n",
+       "L 2766 2266 \n",
+       "Q 2766 2663 2505 2880 \n",
+       "Q 2244 3097 1772 3097 \n",
+       "Q 1472 3097 1187 3025 \n",
+       "Q 903 2953 641 2809 \n",
+       "L 641 3341 \n",
+       "Q 956 3463 1253 3523 \n",
+       "Q 1550 3584 1831 3584 \n",
+       "Q 2591 3584 2966 3190 \n",
+       "Q 3341 2797 3341 1997 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-6c\" d=\"M 603 4863 \n",
+       "L 1178 4863 \n",
+       "L 1178 0 \n",
+       "L 603 0 \n",
+       "L 603 4863 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       </defs>\n",
+       "       <use xlink:href=\"#DejaVuSans-4e\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6f\" x=\"74.804688\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6d\" x=\"135.986328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"233.398438\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6e\" x=\"261.181641\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"324.560547\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6c\" x=\"385.839844\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_3\">\n",
+       "     <g id=\"line2d_3\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"289.736234\" y=\"168.156\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_3\">\n",
+       "      <!-- Risk-averse -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(256.236723 186.432195) scale(0.1155 -0.1155)\">\n",
+       "       <defs>\n",
+       "        <path id=\"DejaVuSans-52\" d=\"M 2841 2188 \n",
+       "Q 3044 2119 3236 1894 \n",
+       "Q 3428 1669 3622 1275 \n",
+       "L 4263 0 \n",
+       "L 3584 0 \n",
+       "L 2988 1197 \n",
+       "Q 2756 1666 2539 1819 \n",
+       "Q 2322 1972 1947 1972 \n",
+       "L 1259 1972 \n",
+       "L 1259 0 \n",
+       "L 628 0 \n",
+       "L 628 4666 \n",
+       "L 2053 4666 \n",
+       "Q 2853 4666 3247 4331 \n",
+       "Q 3641 3997 3641 3322 \n",
+       "Q 3641 2881 3436 2590 \n",
+       "Q 3231 2300 2841 2188 \n",
+       "z\n",
+       "M 1259 4147 \n",
+       "L 1259 2491 \n",
+       "L 2053 2491 \n",
+       "Q 2509 2491 2742 2702 \n",
+       "Q 2975 2913 2975 3322 \n",
+       "Q 2975 3731 2742 3939 \n",
+       "Q 2509 4147 2053 4147 \n",
+       "L 1259 4147 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-6b\" d=\"M 581 4863 \n",
+       "L 1159 4863 \n",
+       "L 1159 1991 \n",
+       "L 2875 3500 \n",
+       "L 3609 3500 \n",
+       "L 1753 1863 \n",
+       "L 3688 0 \n",
+       "L 2938 0 \n",
+       "L 1159 1709 \n",
+       "L 1159 0 \n",
+       "L 581 0 \n",
+       "L 581 4863 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "        <path id=\"DejaVuSans-2d\" d=\"M 313 2009 \n",
+       "L 1997 2009 \n",
+       "L 1997 1497 \n",
+       "L 313 1497 \n",
+       "L 313 2009 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       </defs>\n",
+       "       <use xlink:href=\"#DejaVuSans-52\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"69.482422\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"97.265625\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6b\" x=\"149.365234\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2d\" x=\"207.275391\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"243.359375\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"304.638672\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"363.818359\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"425.341797\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"466.455078\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"518.554688\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_4\">\n",
+       "     <!-- Agent Type -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(165.468359 200.432672) scale(0.1 -0.1)\">\n",
+       "      <defs>\n",
+       "       <path id=\"DejaVuSans-74\" d=\"M 1172 4494 \n",
+       "L 1172 3500 \n",
+       "L 2356 3500 \n",
+       "L 2356 3053 \n",
+       "L 1172 3053 \n",
+       "L 1172 1153 \n",
+       "Q 1172 725 1289 603 \n",
+       "Q 1406 481 1766 481 \n",
+       "L 2356 481 \n",
+       "L 2356 0 \n",
+       "L 1766 0 \n",
+       "Q 1100 0 847 248 \n",
+       "Q 594 497 594 1153 \n",
+       "L 594 3053 \n",
+       "L 172 3053 \n",
+       "L 172 3500 \n",
+       "L 594 3500 \n",
+       "L 594 4494 \n",
+       "L 1172 4494 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       <path id=\"DejaVuSans-20\" transform=\"scale(0.015625)\"/>\n",
+       "       <path id=\"DejaVuSans-54\" d=\"M -19 4666 \n",
+       "L 3928 4666 \n",
+       "L 3928 4134 \n",
+       "L 2272 4134 \n",
+       "L 2272 0 \n",
+       "L 1638 0 \n",
+       "L 1638 4134 \n",
+       "L -19 4134 \n",
+       "L -19 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       <path id=\"DejaVuSans-79\" d=\"M 2059 -325 \n",
+       "Q 1816 -950 1584 -1140 \n",
+       "Q 1353 -1331 966 -1331 \n",
+       "L 506 -1331 \n",
+       "L 506 -850 \n",
+       "L 844 -850 \n",
+       "Q 1081 -850 1212 -737 \n",
+       "Q 1344 -625 1503 -206 \n",
+       "L 1606 56 \n",
+       "L 191 3500 \n",
+       "L 800 3500 \n",
+       "L 1894 763 \n",
+       "L 2988 3500 \n",
+       "L 3597 3500 \n",
+       "L 2059 -325 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       <path id=\"DejaVuSans-70\" d=\"M 1159 525 \n",
+       "L 1159 -1331 \n",
+       "L 581 -1331 \n",
+       "L 581 3500 \n",
+       "L 1159 3500 \n",
+       "L 1159 2969 \n",
+       "Q 1341 3281 1617 3432 \n",
+       "Q 1894 3584 2278 3584 \n",
+       "Q 2916 3584 3314 3078 \n",
+       "Q 3713 2572 3713 1747 \n",
+       "Q 3713 922 3314 415 \n",
+       "Q 2916 -91 2278 -91 \n",
+       "Q 1894 -91 1617 61 \n",
+       "Q 1341 213 1159 525 \n",
+       "z\n",
+       "M 3116 1747 \n",
+       "Q 3116 2381 2855 2742 \n",
+       "Q 2594 3103 2138 3103 \n",
+       "Q 1681 3103 1420 2742 \n",
+       "Q 1159 2381 1159 1747 \n",
+       "Q 1159 1113 1420 752 \n",
+       "Q 1681 391 2138 391 \n",
+       "Q 2594 391 2855 752 \n",
+       "Q 3116 1113 3116 1747 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      </defs>\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"131.884766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"193.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"256.787109\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"295.996094\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-54\" x=\"327.783203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"373.242188\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-70\" x=\"432.421875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"495.898438\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_2\">\n",
+       "    <g id=\"ytick_1\">\n",
+       "     <g id=\"line2d_4\">\n",
+       "      <path d=\"M 48.746234 168.156 \n",
+       "L 337.934234 168.156 \n",
+       "\" clip-path=\"url(#pa89534f593)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_5\">\n",
+       "      <defs>\n",
+       "       <path id=\"m8e39b3a308\" d=\"M 0 0 \n",
+       "L -6 0 \n",
+       "\" style=\"stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </defs>\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"168.156\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_5\">\n",
+       "      <!-- 0 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(31.897547 172.544098) scale(0.1155 -0.1155)\">\n",
+       "       <defs>\n",
+       "        <path id=\"DejaVuSans-30\" d=\"M 2034 4250 \n",
+       "Q 1547 4250 1301 3770 \n",
+       "Q 1056 3291 1056 2328 \n",
+       "Q 1056 1369 1301 889 \n",
+       "Q 1547 409 2034 409 \n",
+       "Q 2525 409 2770 889 \n",
+       "Q 3016 1369 3016 2328 \n",
+       "Q 3016 3291 2770 3770 \n",
+       "Q 2525 4250 2034 4250 \n",
+       "z\n",
+       "M 2034 4750 \n",
+       "Q 2819 4750 3233 4129 \n",
+       "Q 3647 3509 3647 2328 \n",
+       "Q 3647 1150 3233 529 \n",
+       "Q 2819 -91 2034 -91 \n",
+       "Q 1250 -91 836 529 \n",
+       "Q 422 1150 422 2328 \n",
+       "Q 422 3509 836 4129 \n",
+       "Q 1250 4750 2034 4750 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       </defs>\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_2\">\n",
+       "     <g id=\"line2d_6\">\n",
+       "      <path d=\"M 48.746234 119.611809 \n",
+       "L 337.934234 119.611809 \n",
+       "\" clip-path=\"url(#pa89534f593)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_7\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"119.611809\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_6\">\n",
+       "      <!-- 1 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(31.897547 123.999907) scale(0.1155 -0.1155)\">\n",
+       "       <defs>\n",
+       "        <path id=\"DejaVuSans-31\" d=\"M 794 531 \n",
+       "L 1825 531 \n",
+       "L 1825 4091 \n",
+       "L 703 3866 \n",
+       "L 703 4441 \n",
+       "L 1819 4666 \n",
+       "L 2450 4666 \n",
+       "L 2450 531 \n",
+       "L 3481 531 \n",
+       "L 3481 0 \n",
+       "L 794 0 \n",
+       "L 794 531 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       </defs>\n",
+       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_3\">\n",
+       "     <g id=\"line2d_8\">\n",
+       "      <path d=\"M 48.746234 71.067618 \n",
+       "L 337.934234 71.067618 \n",
+       "\" clip-path=\"url(#pa89534f593)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_9\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"71.067618\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_7\">\n",
+       "      <!-- 2 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(31.897547 75.455716) scale(0.1155 -0.1155)\">\n",
+       "       <defs>\n",
+       "        <path id=\"DejaVuSans-32\" d=\"M 1228 531 \n",
+       "L 3431 531 \n",
+       "L 3431 0 \n",
+       "L 469 0 \n",
+       "L 469 531 \n",
+       "Q 828 903 1448 1529 \n",
+       "Q 2069 2156 2228 2338 \n",
+       "Q 2531 2678 2651 2914 \n",
+       "Q 2772 3150 2772 3378 \n",
+       "Q 2772 3750 2511 3984 \n",
+       "Q 2250 4219 1831 4219 \n",
+       "Q 1534 4219 1204 4116 \n",
+       "Q 875 4013 500 3803 \n",
+       "L 500 4441 \n",
+       "Q 881 4594 1212 4672 \n",
+       "Q 1544 4750 1819 4750 \n",
+       "Q 2544 4750 2975 4387 \n",
+       "Q 3406 4025 3406 3419 \n",
+       "Q 3406 3131 3298 2873 \n",
+       "Q 3191 2616 2906 2266 \n",
+       "Q 2828 2175 2409 1742 \n",
+       "Q 1991 1309 1228 531 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       </defs>\n",
+       "       <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_8\">\n",
+       "     <!-- Average Entropy -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(25.817859 152.852094) rotate(-90) scale(0.1 -0.1)\">\n",
+       "      <defs>\n",
+       "       <path id=\"DejaVuSans-45\" d=\"M 628 4666 \n",
+       "L 3578 4666 \n",
+       "L 3578 4134 \n",
+       "L 1259 4134 \n",
+       "L 1259 2753 \n",
+       "L 3481 2753 \n",
+       "L 3481 2222 \n",
+       "L 1259 2222 \n",
+       "L 1259 531 \n",
+       "L 3634 531 \n",
+       "L 3634 0 \n",
+       "L 628 0 \n",
+       "L 628 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      </defs>\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-76\" x=\"62.533203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"121.712891\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-72\" x=\"183.236328\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-61\" x=\"224.349609\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"285.628906\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"349.105469\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"410.628906\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-45\" x=\"442.416016\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"505.599609\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"568.978516\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-72\" x=\"608.1875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"647.050781\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-70\" x=\"708.232422\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"771.708984\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"patch_3\">\n",
+       "    <path d=\"M 58.385834 168.156 \n",
+       "L 135.502634 168.156 \n",
+       "L 135.502634 85.32332 \n",
+       "L 58.385834 85.32332 \n",
+       "z\n",
+       "\" clip-path=\"url(#pa89534f593)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_4\">\n",
+       "    <path d=\"M 154.781834 168.156 \n",
+       "L 231.898634 168.156 \n",
+       "L 231.898634 74.203339 \n",
+       "L 154.781834 74.203339 \n",
+       "z\n",
+       "\" clip-path=\"url(#pa89534f593)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_5\">\n",
+       "    <path d=\"M 251.177834 168.156 \n",
+       "L 328.294634 168.156 \n",
+       "L 328.294634 59.870286 \n",
+       "L 251.177834 59.870286 \n",
+       "z\n",
+       "\" clip-path=\"url(#pa89534f593)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_10\">\n",
+       "    <path clip-path=\"url(#pa89534f593)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_11\">\n",
+       "    <path clip-path=\"url(#pa89534f593)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_12\">\n",
+       "    <path clip-path=\"url(#pa89534f593)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_6\">\n",
+       "    <path d=\"M 48.746234 168.156 \n",
+       "L 48.746234 54.456 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_7\">\n",
+       "    <path d=\"M 48.746234 168.156 \n",
+       "L 337.934234 168.156 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"text_9\">\n",
+       "    <!-- 1.706 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(84.061578 84.837878) scale(0.09 -0.09)\">\n",
+       "     <defs>\n",
+       "      <path id=\"DejaVuSans-2e\" d=\"M 684 794 \n",
+       "L 1344 794 \n",
+       "L 1344 0 \n",
+       "L 684 0 \n",
+       "L 684 794 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-37\" d=\"M 525 4666 \n",
+       "L 3525 4666 \n",
+       "L 3525 4397 \n",
+       "L 1831 0 \n",
+       "L 1172 0 \n",
+       "L 2766 4134 \n",
+       "L 525 4134 \n",
+       "L 525 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-36\" d=\"M 2113 2584 \n",
+       "Q 1688 2584 1439 2293 \n",
+       "Q 1191 2003 1191 1497 \n",
+       "Q 1191 994 1439 701 \n",
+       "Q 1688 409 2113 409 \n",
+       "Q 2538 409 2786 701 \n",
+       "Q 3034 994 3034 1497 \n",
+       "Q 3034 2003 2786 2293 \n",
+       "Q 2538 2584 2113 2584 \n",
+       "z\n",
+       "M 3366 4563 \n",
+       "L 3366 3988 \n",
+       "Q 3128 4100 2886 4159 \n",
+       "Q 2644 4219 2406 4219 \n",
+       "Q 1781 4219 1451 3797 \n",
+       "Q 1122 3375 1075 2522 \n",
+       "Q 1259 2794 1537 2939 \n",
+       "Q 1816 3084 2150 3084 \n",
+       "Q 2853 3084 3261 2657 \n",
+       "Q 3669 2231 3669 1497 \n",
+       "Q 3669 778 3244 343 \n",
+       "Q 2819 -91 2113 -91 \n",
+       "Q 1303 -91 875 529 \n",
+       "Q 447 1150 447 2328 \n",
+       "Q 447 3434 972 4092 \n",
+       "Q 1497 4750 2381 4750 \n",
+       "Q 2619 4750 2861 4703 \n",
+       "Q 3103 4656 3366 4563 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "     </defs>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-37\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-36\" x=\"222.65625\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_10\">\n",
+       "    <!-- 1.935 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(180.457578 73.717897) scale(0.09 -0.09)\">\n",
+       "     <defs>\n",
+       "      <path id=\"DejaVuSans-39\" d=\"M 703 97 \n",
+       "L 703 672 \n",
+       "Q 941 559 1184 500 \n",
+       "Q 1428 441 1663 441 \n",
+       "Q 2288 441 2617 861 \n",
+       "Q 2947 1281 2994 2138 \n",
+       "Q 2813 1869 2534 1725 \n",
+       "Q 2256 1581 1919 1581 \n",
+       "Q 1219 1581 811 2004 \n",
+       "Q 403 2428 403 3163 \n",
+       "Q 403 3881 828 4315 \n",
+       "Q 1253 4750 1959 4750 \n",
+       "Q 2769 4750 3195 4129 \n",
+       "Q 3622 3509 3622 2328 \n",
+       "Q 3622 1225 3098 567 \n",
+       "Q 2575 -91 1691 -91 \n",
+       "Q 1453 -91 1209 -44 \n",
+       "Q 966 3 703 97 \n",
+       "z\n",
+       "M 1959 2075 \n",
+       "Q 2384 2075 2632 2365 \n",
+       "Q 2881 2656 2881 3163 \n",
+       "Q 2881 3666 2632 3958 \n",
+       "Q 2384 4250 1959 4250 \n",
+       "Q 1534 4250 1286 3958 \n",
+       "Q 1038 3666 1038 3163 \n",
+       "Q 1038 2656 1286 2365 \n",
+       "Q 1534 2075 1959 2075 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-33\" d=\"M 2597 2516 \n",
+       "Q 3050 2419 3304 2112 \n",
+       "Q 3559 1806 3559 1356 \n",
+       "Q 3559 666 3084 287 \n",
+       "Q 2609 -91 1734 -91 \n",
+       "Q 1441 -91 1130 -33 \n",
+       "Q 819 25 488 141 \n",
+       "L 488 750 \n",
+       "Q 750 597 1062 519 \n",
+       "Q 1375 441 1716 441 \n",
+       "Q 2309 441 2620 675 \n",
+       "Q 2931 909 2931 1356 \n",
+       "Q 2931 1769 2642 2001 \n",
+       "Q 2353 2234 1838 2234 \n",
+       "L 1294 2234 \n",
+       "L 1294 2753 \n",
+       "L 1863 2753 \n",
+       "Q 2328 2753 2575 2939 \n",
+       "Q 2822 3125 2822 3475 \n",
+       "Q 2822 3834 2567 4026 \n",
+       "Q 2313 4219 1838 4219 \n",
+       "Q 1578 4219 1281 4162 \n",
+       "Q 984 4106 628 3988 \n",
+       "L 628 4550 \n",
+       "Q 988 4650 1302 4700 \n",
+       "Q 1616 4750 1894 4750 \n",
+       "Q 2613 4750 3031 4423 \n",
+       "Q 3450 4097 3450 3541 \n",
+       "Q 3450 3153 3228 2886 \n",
+       "Q 3006 2619 2597 2516 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-35\" d=\"M 691 4666 \n",
+       "L 3169 4666 \n",
+       "L 3169 4134 \n",
+       "L 1269 4134 \n",
+       "L 1269 2991 \n",
+       "Q 1406 3038 1543 3061 \n",
+       "Q 1681 3084 1819 3084 \n",
+       "Q 2600 3084 3056 2656 \n",
+       "Q 3513 2228 3513 1497 \n",
+       "Q 3513 744 3044 326 \n",
+       "Q 2575 -91 1722 -91 \n",
+       "Q 1428 -91 1123 -41 \n",
+       "Q 819 9 494 109 \n",
+       "L 494 744 \n",
+       "Q 775 591 1075 516 \n",
+       "Q 1375 441 1709 441 \n",
+       "Q 2250 441 2565 725 \n",
+       "Q 2881 1009 2881 1497 \n",
+       "Q 2881 1984 2565 2268 \n",
+       "Q 2250 2553 1709 2553 \n",
+       "Q 1456 2553 1204 2497 \n",
+       "Q 953 2441 691 2322 \n",
+       "L 691 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "     </defs>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-39\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-33\" x=\"159.033203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-35\" x=\"222.65625\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_11\">\n",
+       "    <!-- 2.231 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(276.853578 59.384844) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-32\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-33\" x=\"159.033203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\" x=\"222.65625\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_12\">\n",
+       "    <!-- Policy Entropy -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(150.868672 48.456) scale(0.12 -0.12)\">\n",
+       "     <defs>\n",
+       "      <path id=\"DejaVuSans-50\" d=\"M 1259 4147 \n",
+       "L 1259 2394 \n",
+       "L 2053 2394 \n",
+       "Q 2494 2394 2734 2622 \n",
+       "Q 2975 2850 2975 3272 \n",
+       "Q 2975 3691 2734 3919 \n",
+       "Q 2494 4147 2053 4147 \n",
+       "L 1259 4147 \n",
+       "z\n",
+       "M 628 4666 \n",
+       "L 2053 4666 \n",
+       "Q 2838 4666 3239 4311 \n",
+       "Q 3641 3956 3641 3272 \n",
+       "Q 3641 2581 3239 2228 \n",
+       "Q 2838 1875 2053 1875 \n",
+       "L 1259 1875 \n",
+       "L 1259 0 \n",
+       "L 628 0 \n",
+       "L 628 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-63\" d=\"M 3122 3366 \n",
+       "L 3122 2828 \n",
+       "Q 2878 2963 2633 3030 \n",
+       "Q 2388 3097 2138 3097 \n",
+       "Q 1578 3097 1268 2742 \n",
+       "Q 959 2388 959 1747 \n",
+       "Q 959 1106 1268 751 \n",
+       "Q 1578 397 2138 397 \n",
+       "Q 2388 397 2633 464 \n",
+       "Q 2878 531 3122 666 \n",
+       "L 3122 134 \n",
+       "Q 2881 22 2623 -34 \n",
+       "Q 2366 -91 2075 -91 \n",
+       "Q 1284 -91 818 406 \n",
+       "Q 353 903 353 1747 \n",
+       "Q 353 2603 823 3093 \n",
+       "Q 1294 3584 2113 3584 \n",
+       "Q 2378 3584 2631 3529 \n",
+       "Q 2884 3475 3122 3366 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "     </defs>\n",
+       "     <use xlink:href=\"#DejaVuSans-50\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" x=\"56.677734\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"117.859375\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-69\" x=\"145.642578\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-63\" x=\"173.425781\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-79\" x=\"228.40625\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" x=\"287.585938\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-45\" x=\"319.373047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" x=\"382.556641\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" x=\"445.935547\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-72\" x=\"485.144531\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" x=\"524.007812\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-70\" x=\"585.189453\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-79\" x=\"648.666016\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "  </g>\n",
+       "  <g id=\"axes_2\">\n",
+       "   <g id=\"patch_8\">\n",
+       "    <path d=\"M 403.112234 168.156 \n",
+       "L 692.300234 168.156 \n",
+       "L 692.300234 54.456 \n",
+       "L 403.112234 54.456 \n",
+       "L 403.112234 168.156 \n",
+       "z\n",
+       "\" style=\"fill: none\"/>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_3\">\n",
+       "    <g id=\"xtick_4\">\n",
+       "     <g id=\"line2d_13\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"451.310234\" y=\"168.156\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_13\">\n",
+       "      <!-- Aggressive -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(419.637066 186.432195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"131.884766\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"195.361328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"234.224609\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"295.748047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"347.847656\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"399.947266\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"427.730469\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"486.910156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_5\">\n",
+       "     <g id=\"line2d_14\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"547.706234\" y=\"168.156\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_14\">\n",
+       "      <!-- Nominal -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(523.819391 186.432195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-4e\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6f\" x=\"74.804688\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6d\" x=\"135.986328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"233.398438\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6e\" x=\"261.181641\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"324.560547\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6c\" x=\"385.839844\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_6\">\n",
+       "     <g id=\"line2d_15\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"644.102234\" y=\"168.156\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_15\">\n",
+       "      <!-- Risk-averse -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(610.602723 186.432195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-52\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"69.482422\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"97.265625\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6b\" x=\"149.365234\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2d\" x=\"207.275391\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"243.359375\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"304.638672\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"363.818359\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"425.341797\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"466.455078\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"518.554688\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_16\">\n",
+       "     <!-- Agent Type -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(519.834359 200.432672) scale(0.1 -0.1)\">\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"131.884766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"193.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"256.787109\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"295.996094\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-54\" x=\"327.783203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"373.242188\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-70\" x=\"432.421875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"495.898438\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_4\">\n",
+       "    <g id=\"ytick_4\">\n",
+       "     <g id=\"line2d_16\">\n",
+       "      <path d=\"M 403.112234 151.184236 \n",
+       "L 692.300234 151.184236 \n",
+       "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_17\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"151.184236\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_17\">\n",
+       "      <!-- −2 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(376.585008 155.572334) scale(0.1155 -0.1155)\">\n",
+       "       <defs>\n",
+       "        <path id=\"DejaVuSans-2212\" d=\"M 678 2272 \n",
+       "L 4684 2272 \n",
+       "L 4684 1741 \n",
+       "L 678 1741 \n",
+       "L 678 2272 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       </defs>\n",
+       "       <use xlink:href=\"#DejaVuSans-2212\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-32\" x=\"83.789062\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_5\">\n",
+       "     <g id=\"line2d_18\">\n",
+       "      <path d=\"M 403.112234 102.820118 \n",
+       "L 692.300234 102.820118 \n",
+       "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_19\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"102.820118\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_18\">\n",
+       "      <!-- −1 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(376.585008 107.208216) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-2212\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-31\" x=\"83.789062\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_6\">\n",
+       "     <g id=\"line2d_20\">\n",
+       "      <path d=\"M 403.112234 54.456 \n",
+       "L 692.300234 54.456 \n",
+       "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_21\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"54.456\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_19\">\n",
+       "      <!-- 0 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(386.263547 58.844098) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_20\">\n",
+       "     <!-- Log Probability -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(370.50532 148.256) rotate(-90) scale(0.1 -0.1)\">\n",
+       "      <defs>\n",
+       "       <path id=\"DejaVuSans-4c\" d=\"M 628 4666 \n",
+       "L 1259 4666 \n",
+       "L 1259 531 \n",
+       "L 3531 531 \n",
+       "L 3531 0 \n",
+       "L 628 0 \n",
+       "L 628 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       <path id=\"DejaVuSans-62\" d=\"M 3116 1747 \n",
+       "Q 3116 2381 2855 2742 \n",
+       "Q 2594 3103 2138 3103 \n",
+       "Q 1681 3103 1420 2742 \n",
+       "Q 1159 2381 1159 1747 \n",
+       "Q 1159 1113 1420 752 \n",
+       "Q 1681 391 2138 391 \n",
+       "Q 2594 391 2855 752 \n",
+       "Q 3116 1113 3116 1747 \n",
+       "z\n",
+       "M 1159 2969 \n",
+       "Q 1341 3281 1617 3432 \n",
+       "Q 1894 3584 2278 3584 \n",
+       "Q 2916 3584 3314 3078 \n",
+       "Q 3713 2572 3713 1747 \n",
+       "Q 3713 922 3314 415 \n",
+       "Q 2916 -91 2278 -91 \n",
+       "Q 1894 -91 1617 61 \n",
+       "Q 1341 213 1159 525 \n",
+       "L 1159 0 \n",
+       "L 581 0 \n",
+       "L 581 4863 \n",
+       "L 1159 4863 \n",
+       "L 1159 2969 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      </defs>\n",
+       "      <use xlink:href=\"#DejaVuSans-4c\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"53.962891\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"115.144531\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"178.621094\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-50\" x=\"210.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-72\" x=\"268.960938\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"307.824219\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-62\" x=\"369.005859\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-61\" x=\"432.482422\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-62\" x=\"493.761719\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-69\" x=\"557.238281\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6c\" x=\"585.021484\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-69\" x=\"612.804688\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"640.587891\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"679.796875\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"patch_9\">\n",
+       "    <path d=\"M 412.751834 54.456 \n",
+       "L 489.868634 54.456 \n",
+       "L 489.868634 137.411219 \n",
+       "L 412.751834 137.411219 \n",
+       "z\n",
+       "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_10\">\n",
+       "    <path d=\"M 509.147834 54.456 \n",
+       "L 586.264634 54.456 \n",
+       "L 586.264634 148.260471 \n",
+       "L 509.147834 148.260471 \n",
+       "z\n",
+       "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_11\">\n",
+       "    <path d=\"M 605.543834 54.456 \n",
+       "L 682.660634 54.456 \n",
+       "L 682.660634 162.741714 \n",
+       "L 605.543834 162.741714 \n",
+       "z\n",
+       "\" clip-path=\"url(#pf74dcec93a)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_22\">\n",
+       "    <path clip-path=\"url(#pf74dcec93a)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_23\">\n",
+       "    <path clip-path=\"url(#pf74dcec93a)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_24\">\n",
+       "    <path clip-path=\"url(#pf74dcec93a)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_12\">\n",
+       "    <path d=\"M 403.112234 168.156 \n",
+       "L 403.112234 54.456 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_13\">\n",
+       "    <path d=\"M 403.112234 168.156 \n",
+       "L 692.300234 168.156 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"text_21\">\n",
+       "    <!-- -1.715 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(436.804063 134.993013) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-2d\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\" x=\"36.083984\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"99.707031\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-37\" x=\"131.494141\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\" x=\"195.117188\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-35\" x=\"258.740234\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_22\">\n",
+       "    <!-- -1.940 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(533.200063 145.842265) scale(0.09 -0.09)\">\n",
+       "     <defs>\n",
+       "      <path id=\"DejaVuSans-34\" d=\"M 2419 4116 \n",
+       "L 825 1625 \n",
+       "L 2419 1625 \n",
+       "L 2419 4116 \n",
+       "z\n",
+       "M 2253 4666 \n",
+       "L 3047 4666 \n",
+       "L 3047 1625 \n",
+       "L 3713 1625 \n",
+       "L 3713 1100 \n",
+       "L 3047 1100 \n",
+       "L 3047 0 \n",
+       "L 2419 0 \n",
+       "L 2419 1100 \n",
+       "L 313 1100 \n",
+       "L 313 1709 \n",
+       "L 2253 4666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "     </defs>\n",
+       "     <use xlink:href=\"#DejaVuSans-2d\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\" x=\"36.083984\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"99.707031\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-39\" x=\"131.494141\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-34\" x=\"195.117188\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"258.740234\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_23\">\n",
+       "    <!-- -2.239 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(629.596063 160.323508) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-2d\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-32\" x=\"36.083984\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"99.707031\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-32\" x=\"131.494141\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-33\" x=\"195.117188\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-39\" x=\"258.740234\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_24\">\n",
+       "    <!-- Agent Confidence | $\\log(p(a_t)$ -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(462.986234 48.456) scale(0.12 -0.12)\">\n",
+       "     <defs>\n",
+       "      <path id=\"DejaVuSans-43\" d=\"M 4122 4306 \n",
+       "L 4122 3641 \n",
+       "Q 3803 3938 3442 4084 \n",
+       "Q 3081 4231 2675 4231 \n",
+       "Q 1875 4231 1450 3742 \n",
+       "Q 1025 3253 1025 2328 \n",
+       "Q 1025 1406 1450 917 \n",
+       "Q 1875 428 2675 428 \n",
+       "Q 3081 428 3442 575 \n",
+       "Q 3803 722 4122 1019 \n",
+       "L 4122 359 \n",
+       "Q 3791 134 3420 21 \n",
+       "Q 3050 -91 2638 -91 \n",
+       "Q 1578 -91 968 557 \n",
+       "Q 359 1206 359 2328 \n",
+       "Q 359 3453 968 4101 \n",
+       "Q 1578 4750 2638 4750 \n",
+       "Q 3056 4750 3426 4639 \n",
+       "Q 3797 4528 4122 4306 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-66\" d=\"M 2375 4863 \n",
+       "L 2375 4384 \n",
+       "L 1825 4384 \n",
+       "Q 1516 4384 1395 4259 \n",
+       "Q 1275 4134 1275 3809 \n",
+       "L 1275 3500 \n",
+       "L 2222 3500 \n",
+       "L 2222 3053 \n",
+       "L 1275 3053 \n",
+       "L 1275 0 \n",
+       "L 697 0 \n",
+       "L 697 3053 \n",
+       "L 147 3053 \n",
+       "L 147 3500 \n",
+       "L 697 3500 \n",
+       "L 697 3744 \n",
+       "Q 697 4328 969 4595 \n",
+       "Q 1241 4863 1831 4863 \n",
+       "L 2375 4863 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-64\" d=\"M 2906 2969 \n",
+       "L 2906 4863 \n",
+       "L 3481 4863 \n",
+       "L 3481 0 \n",
+       "L 2906 0 \n",
+       "L 2906 525 \n",
+       "Q 2725 213 2448 61 \n",
+       "Q 2172 -91 1784 -91 \n",
+       "Q 1150 -91 751 415 \n",
+       "Q 353 922 353 1747 \n",
+       "Q 353 2572 751 3078 \n",
+       "Q 1150 3584 1784 3584 \n",
+       "Q 2172 3584 2448 3432 \n",
+       "Q 2725 3281 2906 2969 \n",
+       "z\n",
+       "M 947 1747 \n",
+       "Q 947 1113 1208 752 \n",
+       "Q 1469 391 1925 391 \n",
+       "Q 2381 391 2643 752 \n",
+       "Q 2906 1113 2906 1747 \n",
+       "Q 2906 2381 2643 2742 \n",
+       "Q 2381 3103 1925 3103 \n",
+       "Q 1469 3103 1208 2742 \n",
+       "Q 947 2381 947 1747 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-7c\" d=\"M 1344 4891 \n",
+       "L 1344 -1509 \n",
+       "L 813 -1509 \n",
+       "L 813 4891 \n",
+       "L 1344 4891 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-28\" d=\"M 1984 4856 \n",
+       "Q 1566 4138 1362 3434 \n",
+       "Q 1159 2731 1159 2009 \n",
+       "Q 1159 1288 1364 580 \n",
+       "Q 1569 -128 1984 -844 \n",
+       "L 1484 -844 \n",
+       "Q 1016 -109 783 600 \n",
+       "Q 550 1309 550 2009 \n",
+       "Q 550 2706 781 3412 \n",
+       "Q 1013 4119 1484 4856 \n",
+       "L 1984 4856 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-Oblique-70\" d=\"M 3175 2156 \n",
+       "Q 3175 2616 2975 2859 \n",
+       "Q 2775 3103 2400 3103 \n",
+       "Q 2144 3103 1911 2972 \n",
+       "Q 1678 2841 1497 2591 \n",
+       "Q 1319 2344 1212 1994 \n",
+       "Q 1106 1644 1106 1300 \n",
+       "Q 1106 863 1306 627 \n",
+       "Q 1506 391 1875 391 \n",
+       "Q 2147 391 2380 519 \n",
+       "Q 2613 647 2778 891 \n",
+       "Q 2956 1147 3065 1494 \n",
+       "Q 3175 1841 3175 2156 \n",
+       "z\n",
+       "M 1394 2969 \n",
+       "Q 1625 3272 1939 3428 \n",
+       "Q 2253 3584 2638 3584 \n",
+       "Q 3175 3584 3472 3232 \n",
+       "Q 3769 2881 3769 2247 \n",
+       "Q 3769 1728 3584 1258 \n",
+       "Q 3400 788 3053 416 \n",
+       "Q 2822 169 2531 39 \n",
+       "Q 2241 -91 1919 -91 \n",
+       "Q 1547 -91 1294 64 \n",
+       "Q 1041 219 916 525 \n",
+       "L 556 -1331 \n",
+       "L -19 -1331 \n",
+       "L 922 3500 \n",
+       "L 1497 3500 \n",
+       "L 1394 2969 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-Oblique-61\" d=\"M 3438 1997 \n",
+       "L 3047 0 \n",
+       "L 2472 0 \n",
+       "L 2578 531 \n",
+       "Q 2325 219 2001 64 \n",
+       "Q 1678 -91 1281 -91 \n",
+       "Q 834 -91 548 182 \n",
+       "Q 263 456 263 884 \n",
+       "Q 263 1497 752 1853 \n",
+       "Q 1241 2209 2100 2209 \n",
+       "L 2900 2209 \n",
+       "L 2931 2363 \n",
+       "Q 2938 2388 2941 2417 \n",
+       "Q 2944 2447 2944 2509 \n",
+       "Q 2944 2788 2717 2942 \n",
+       "Q 2491 3097 2081 3097 \n",
+       "Q 1800 3097 1504 3025 \n",
+       "Q 1209 2953 897 2809 \n",
+       "L 997 3341 \n",
+       "Q 1322 3463 1633 3523 \n",
+       "Q 1944 3584 2234 3584 \n",
+       "Q 2853 3584 3176 3315 \n",
+       "Q 3500 3047 3500 2534 \n",
+       "Q 3500 2431 3484 2292 \n",
+       "Q 3469 2153 3438 1997 \n",
+       "z\n",
+       "M 2816 1759 \n",
+       "L 2241 1759 \n",
+       "Q 1534 1759 1195 1570 \n",
+       "Q 856 1381 856 984 \n",
+       "Q 856 709 1029 553 \n",
+       "Q 1203 397 1509 397 \n",
+       "Q 1978 397 2328 733 \n",
+       "Q 2678 1069 2791 1631 \n",
+       "L 2816 1759 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-Oblique-74\" d=\"M 2706 3500 \n",
+       "L 2619 3053 \n",
+       "L 1472 3053 \n",
+       "L 1100 1153 \n",
+       "Q 1081 1047 1072 975 \n",
+       "Q 1063 903 1063 863 \n",
+       "Q 1063 663 1183 572 \n",
+       "Q 1303 481 1569 481 \n",
+       "L 2150 481 \n",
+       "L 2053 0 \n",
+       "L 1503 0 \n",
+       "Q 991 0 739 200 \n",
+       "Q 488 400 488 806 \n",
+       "Q 488 878 497 964 \n",
+       "Q 506 1050 525 1153 \n",
+       "L 897 3053 \n",
+       "L 409 3053 \n",
+       "L 500 3500 \n",
+       "L 978 3500 \n",
+       "L 1172 4494 \n",
+       "L 1747 4494 \n",
+       "L 1556 3500 \n",
+       "L 2706 3500 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      <path id=\"DejaVuSans-29\" d=\"M 513 4856 \n",
+       "L 1013 4856 \n",
+       "Q 1481 4119 1714 3412 \n",
+       "Q 1947 2706 1947 2009 \n",
+       "Q 1947 1309 1714 600 \n",
+       "Q 1481 -109 1013 -844 \n",
+       "L 513 -844 \n",
+       "Q 928 -128 1133 580 \n",
+       "Q 1338 1288 1338 2009 \n",
+       "Q 1338 2731 1133 3434 \n",
+       "Q 928 4138 513 4856 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "     </defs>\n",
+       "     <use xlink:href=\"#DejaVuSans-41\" transform=\"translate(0 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-67\" transform=\"translate(68.408203 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" transform=\"translate(131.884766 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" transform=\"translate(193.408203 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" transform=\"translate(256.787109 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(295.996094 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-43\" transform=\"translate(327.783203 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" transform=\"translate(397.607422 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" transform=\"translate(458.789062 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-66\" transform=\"translate(522.167969 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-69\" transform=\"translate(557.373047 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-64\" transform=\"translate(585.15625 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" transform=\"translate(648.632812 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" transform=\"translate(710.15625 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-63\" transform=\"translate(773.535156 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" transform=\"translate(828.515625 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(890.039062 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-7c\" transform=\"translate(921.826172 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" transform=\"translate(955.517578 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" transform=\"translate(987.304688 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" transform=\"translate(1015.087891 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-67\" transform=\"translate(1076.269531 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-28\" transform=\"translate(1139.746094 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-Oblique-70\" transform=\"translate(1178.759766 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-28\" transform=\"translate(1242.236328 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-Oblique-61\" transform=\"translate(1281.25 0.578125)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-Oblique-74\" transform=\"translate(1342.529297 -15.828125) scale(0.7)\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-29\" transform=\"translate(1372.709961 0.578125)\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "  </g>\n",
+       "  <g id=\"axes_3\">\n",
+       "   <g id=\"patch_14\">\n",
+       "    <path d=\"M 48.746234 345.924 \n",
+       "L 337.934234 345.924 \n",
+       "L 337.934234 232.224 \n",
+       "L 48.746234 232.224 \n",
+       "L 48.746234 345.924 \n",
+       "z\n",
+       "\" style=\"fill: none\"/>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_5\">\n",
+       "    <g id=\"xtick_7\">\n",
+       "     <g id=\"line2d_25\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"96.944234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_25\">\n",
+       "      <!-- Aggressive -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(65.271066 364.200195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"131.884766\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"195.361328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"234.224609\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"295.748047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"347.847656\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"399.947266\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"427.730469\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"486.910156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_8\">\n",
+       "     <g id=\"line2d_26\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"193.340234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_26\">\n",
+       "      <!-- Nominal -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(169.453391 364.200195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-4e\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6f\" x=\"74.804688\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6d\" x=\"135.986328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"233.398438\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6e\" x=\"261.181641\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"324.560547\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6c\" x=\"385.839844\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_9\">\n",
+       "     <g id=\"line2d_27\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"289.736234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_27\">\n",
+       "      <!-- Risk-averse -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(256.236723 364.200195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-52\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"69.482422\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"97.265625\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6b\" x=\"149.365234\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2d\" x=\"207.275391\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"243.359375\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"304.638672\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"363.818359\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"425.341797\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"466.455078\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"518.554688\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_28\">\n",
+       "     <!-- Agent Type -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(165.468359 378.200672) scale(0.1 -0.1)\">\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"131.884766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"193.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"256.787109\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"295.996094\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-54\" x=\"327.783203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"373.242188\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-70\" x=\"432.421875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"495.898438\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_6\">\n",
+       "    <g id=\"ytick_7\">\n",
+       "     <g id=\"line2d_28\">\n",
+       "      <path d=\"M 48.746234 345.924 \n",
+       "L 337.934234 345.924 \n",
+       "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_29\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_29\">\n",
+       "      <!-- 0 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(31.897547 350.312098) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_8\">\n",
+       "     <g id=\"line2d_30\">\n",
+       "      <path d=\"M 48.746234 311.194255 \n",
+       "L 337.934234 311.194255 \n",
+       "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_31\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"311.194255\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_30\">\n",
+       "      <!-- 1 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(31.897547 315.582353) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_9\">\n",
+       "     <g id=\"line2d_32\">\n",
+       "      <path d=\"M 48.746234 276.46451 \n",
+       "L 337.934234 276.46451 \n",
+       "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_33\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"276.46451\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_31\">\n",
+       "      <!-- 2 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(31.897547 280.852608) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_10\">\n",
+       "     <g id=\"line2d_34\">\n",
+       "      <path d=\"M 48.746234 241.734765 \n",
+       "L 337.934234 241.734765 \n",
+       "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_35\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"241.734765\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_32\">\n",
+       "      <!-- 3 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(31.897547 246.122863) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-33\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_33\">\n",
+       "     <!-- Acceleration -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(25.817859 320.144312) rotate(-90) scale(0.1 -0.1)\">\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-63\" x=\"66.658203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-63\" x=\"121.638672\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"176.619141\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6c\" x=\"238.142578\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"265.925781\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-72\" x=\"327.449219\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-61\" x=\"368.5625\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"429.841797\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-69\" x=\"469.050781\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"496.833984\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"558.015625\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"patch_15\">\n",
+       "    <path d=\"M 58.385834 345.924 \n",
+       "L 135.502634 345.924 \n",
+       "L 135.502634 237.638286 \n",
+       "L 58.385834 237.638286 \n",
+       "z\n",
+       "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_16\">\n",
+       "    <path d=\"M 154.781834 345.924 \n",
+       "L 231.898634 345.924 \n",
+       "L 231.898634 275.192849 \n",
+       "L 154.781834 275.192849 \n",
+       "z\n",
+       "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_17\">\n",
+       "    <path d=\"M 251.177834 345.924 \n",
+       "L 328.294634 345.924 \n",
+       "L 328.294634 342.967242 \n",
+       "L 251.177834 342.967242 \n",
+       "z\n",
+       "\" clip-path=\"url(#p70a88f4f01)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_36\">\n",
+       "    <path clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_37\">\n",
+       "    <path clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_38\">\n",
+       "    <path clip-path=\"url(#p70a88f4f01)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_18\">\n",
+       "    <path d=\"M 48.746234 345.924 \n",
+       "L 48.746234 232.224 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_19\">\n",
+       "    <path d=\"M 48.746234 345.924 \n",
+       "L 337.934234 345.924 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"text_34\">\n",
+       "    <!-- 3.12 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(86.924703 234.165311) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-33\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-32\" x=\"159.033203\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_35\">\n",
+       "    <!-- 2.04 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(183.320703 271.719875) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-34\" x=\"159.033203\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_36\">\n",
+       "    <!-- 0.09 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(279.716703 339.494268) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-39\" x=\"159.033203\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_37\">\n",
+       "    <!-- Average Acceleration -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(129.509609 226.224) scale(0.12 -0.12)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-76\" x=\"62.533203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"121.712891\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-72\" x=\"183.236328\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-61\" x=\"224.349609\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-67\" x=\"285.628906\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"349.105469\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" x=\"410.628906\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-41\" x=\"442.416016\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-63\" x=\"509.074219\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-63\" x=\"564.054688\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"619.035156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"680.558594\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"708.341797\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-72\" x=\"769.865234\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-61\" x=\"810.978516\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" x=\"872.257812\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-69\" x=\"911.466797\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" x=\"939.25\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" x=\"1000.431641\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "  </g>\n",
+       "  <g id=\"axes_4\">\n",
+       "   <g id=\"patch_20\">\n",
+       "    <path d=\"M 403.112234 345.924 \n",
+       "L 692.300234 345.924 \n",
+       "L 692.300234 232.224 \n",
+       "L 403.112234 232.224 \n",
+       "L 403.112234 345.924 \n",
+       "z\n",
+       "\" style=\"fill: none\"/>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_7\">\n",
+       "    <g id=\"xtick_10\">\n",
+       "     <g id=\"line2d_39\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"451.310234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_38\">\n",
+       "      <!-- Aggressive -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(419.637066 364.200195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"131.884766\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"195.361328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"234.224609\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"295.748047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"347.847656\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"399.947266\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"427.730469\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"486.910156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_11\">\n",
+       "     <g id=\"line2d_40\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"547.706234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_39\">\n",
+       "      <!-- Nominal -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(523.819391 364.200195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-4e\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6f\" x=\"74.804688\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6d\" x=\"135.986328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"233.398438\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6e\" x=\"261.181641\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"324.560547\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6c\" x=\"385.839844\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_12\">\n",
+       "     <g id=\"line2d_41\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"644.102234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_40\">\n",
+       "      <!-- Risk-averse -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(610.602723 364.200195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-52\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"69.482422\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"97.265625\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6b\" x=\"149.365234\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2d\" x=\"207.275391\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"243.359375\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"304.638672\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"363.818359\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"425.341797\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"466.455078\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"518.554688\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_41\">\n",
+       "     <!-- Agent Type -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(519.834359 378.200672) scale(0.1 -0.1)\">\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"131.884766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"193.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"256.787109\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"295.996094\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-54\" x=\"327.783203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"373.242188\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-70\" x=\"432.421875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"495.898438\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_8\">\n",
+       "    <g id=\"ytick_11\">\n",
+       "     <g id=\"line2d_42\">\n",
+       "      <path d=\"M 403.112234 345.924 \n",
+       "L 692.300234 345.924 \n",
+       "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_43\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"345.924\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_42\">\n",
+       "      <!-- 0 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(386.263547 350.312098) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_12\">\n",
+       "     <g id=\"line2d_44\">\n",
+       "      <path d=\"M 403.112234 300.105532 \n",
+       "L 692.300234 300.105532 \n",
+       "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_45\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"300.105532\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_43\">\n",
+       "      <!-- 1 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(386.263547 304.493629) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_13\">\n",
+       "     <g id=\"line2d_46\">\n",
+       "      <path d=\"M 403.112234 254.287064 \n",
+       "L 692.300234 254.287064 \n",
+       "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_47\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"254.287064\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_44\">\n",
+       "      <!-- 2 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(386.263547 258.675161) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_45\">\n",
+       "     <!-- Avg Absolute Steering -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(380.183859 344.440406) rotate(-90) scale(0.1 -0.1)\">\n",
+       "      <defs>\n",
+       "       <path id=\"DejaVuSans-75\" d=\"M 544 1381 \n",
+       "L 544 3500 \n",
+       "L 1119 3500 \n",
+       "L 1119 1403 \n",
+       "Q 1119 906 1312 657 \n",
+       "Q 1506 409 1894 409 \n",
+       "Q 2359 409 2629 706 \n",
+       "Q 2900 1003 2900 1516 \n",
+       "L 2900 3500 \n",
+       "L 3475 3500 \n",
+       "L 3475 0 \n",
+       "L 2900 0 \n",
+       "L 2900 538 \n",
+       "Q 2691 219 2414 64 \n",
+       "Q 2138 -91 1772 -91 \n",
+       "Q 1169 -91 856 284 \n",
+       "Q 544 659 544 1381 \n",
+       "z\n",
+       "M 1991 3584 \n",
+       "L 1991 3584 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "       <path id=\"DejaVuSans-53\" d=\"M 3425 4513 \n",
+       "L 3425 3897 \n",
+       "Q 3066 4069 2747 4153 \n",
+       "Q 2428 4238 2131 4238 \n",
+       "Q 1616 4238 1336 4038 \n",
+       "Q 1056 3838 1056 3469 \n",
+       "Q 1056 3159 1242 3001 \n",
+       "Q 1428 2844 1947 2747 \n",
+       "L 2328 2669 \n",
+       "Q 3034 2534 3370 2195 \n",
+       "Q 3706 1856 3706 1288 \n",
+       "Q 3706 609 3251 259 \n",
+       "Q 2797 -91 1919 -91 \n",
+       "Q 1588 -91 1214 -16 \n",
+       "Q 841 59 441 206 \n",
+       "L 441 856 \n",
+       "Q 825 641 1194 531 \n",
+       "Q 1563 422 1919 422 \n",
+       "Q 2459 422 2753 634 \n",
+       "Q 3047 847 3047 1241 \n",
+       "Q 3047 1584 2836 1778 \n",
+       "Q 2625 1972 2144 2069 \n",
+       "L 1759 2144 \n",
+       "Q 1053 2284 737 2584 \n",
+       "Q 422 2884 422 3419 \n",
+       "Q 422 4038 858 4394 \n",
+       "Q 1294 4750 2059 4750 \n",
+       "Q 2388 4750 2728 4690 \n",
+       "Q 3069 4631 3425 4513 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      </defs>\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-76\" x=\"62.533203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"121.712891\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"185.189453\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-41\" x=\"216.976562\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-62\" x=\"285.384766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-73\" x=\"348.861328\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"400.960938\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6c\" x=\"462.142578\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-75\" x=\"489.925781\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"553.304688\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"592.513672\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"654.037109\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-53\" x=\"685.824219\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"749.300781\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"788.509766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"850.033203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-72\" x=\"911.556641\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-69\" x=\"952.669922\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"980.453125\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"1043.832031\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"patch_21\">\n",
+       "    <path d=\"M 412.751834 345.924 \n",
+       "L 489.868634 345.924 \n",
+       "L 489.868634 251.692202 \n",
+       "L 412.751834 251.692202 \n",
+       "z\n",
+       "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_22\">\n",
+       "    <path d=\"M 509.147834 345.924 \n",
+       "L 586.264634 345.924 \n",
+       "L 586.264634 247.096095 \n",
+       "L 509.147834 247.096095 \n",
+       "z\n",
+       "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_23\">\n",
+       "    <path d=\"M 605.543834 345.924 \n",
+       "L 682.660634 345.924 \n",
+       "L 682.660634 237.638286 \n",
+       "L 605.543834 237.638286 \n",
+       "z\n",
+       "\" clip-path=\"url(#p8b19814f01)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_48\">\n",
+       "    <path clip-path=\"url(#p8b19814f01)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_49\">\n",
+       "    <path clip-path=\"url(#p8b19814f01)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_50\">\n",
+       "    <path clip-path=\"url(#p8b19814f01)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_24\">\n",
+       "    <path d=\"M 403.112234 345.924 \n",
+       "L 403.112234 232.224 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_25\">\n",
+       "    <path d=\"M 403.112234 345.924 \n",
+       "L 692.300234 345.924 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"text_46\">\n",
+       "    <!-- 2.06 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(441.290703 247.110355) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-36\" x=\"159.033203\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_47\">\n",
+       "    <!-- 2.16 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(537.686703 242.514248) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-36\" x=\"159.033203\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_48\">\n",
+       "    <!-- 2.36 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(634.082703 233.056439) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-32\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-33\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-36\" x=\"159.033203\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_49\">\n",
+       "    <!-- Absolute Steering Angle -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(475.304047 226.224) scale(0.12 -0.12)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-62\" x=\"68.408203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-73\" x=\"131.884766\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" x=\"183.984375\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"245.166016\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-75\" x=\"272.949219\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" x=\"336.328125\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"375.537109\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" x=\"437.060547\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-53\" x=\"468.847656\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" x=\"532.324219\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"571.533203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"633.056641\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-72\" x=\"694.580078\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-69\" x=\"735.693359\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" x=\"763.476562\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-67\" x=\"826.855469\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" x=\"890.332031\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-41\" x=\"922.119141\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" x=\"990.527344\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-67\" x=\"1053.90625\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"1117.382812\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"1145.166016\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "  </g>\n",
+       "  <g id=\"axes_5\">\n",
+       "   <g id=\"patch_26\">\n",
+       "    <path d=\"M 48.746234 523.692 \n",
+       "L 337.934234 523.692 \n",
+       "L 337.934234 409.992 \n",
+       "L 48.746234 409.992 \n",
+       "L 48.746234 523.692 \n",
+       "z\n",
+       "\" style=\"fill: none\"/>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_9\">\n",
+       "    <g id=\"xtick_13\">\n",
+       "     <g id=\"line2d_51\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"96.944234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_50\">\n",
+       "      <!-- Aggressive -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(65.271066 541.968195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"131.884766\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"195.361328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"234.224609\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"295.748047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"347.847656\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"399.947266\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"427.730469\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"486.910156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_14\">\n",
+       "     <g id=\"line2d_52\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"193.340234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_51\">\n",
+       "      <!-- Nominal -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(169.453391 541.968195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-4e\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6f\" x=\"74.804688\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6d\" x=\"135.986328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"233.398438\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6e\" x=\"261.181641\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"324.560547\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6c\" x=\"385.839844\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_15\">\n",
+       "     <g id=\"line2d_53\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"289.736234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_52\">\n",
+       "      <!-- Risk-averse -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(256.236723 541.968195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-52\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"69.482422\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"97.265625\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6b\" x=\"149.365234\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2d\" x=\"207.275391\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"243.359375\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"304.638672\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"363.818359\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"425.341797\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"466.455078\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"518.554688\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_53\">\n",
+       "     <!-- Agent Type -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(165.468359 555.968672) scale(0.1 -0.1)\">\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"131.884766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"193.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"256.787109\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"295.996094\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-54\" x=\"327.783203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"373.242188\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-70\" x=\"432.421875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"495.898438\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_10\">\n",
+       "    <g id=\"ytick_14\">\n",
+       "     <g id=\"line2d_54\">\n",
+       "      <path d=\"M 48.746234 523.692 \n",
+       "L 337.934234 523.692 \n",
+       "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_55\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_54\">\n",
+       "      <!-- 0.0 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(20.878125 528.080098) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_15\">\n",
+       "     <g id=\"line2d_56\">\n",
+       "      <path d=\"M 48.746234 469.549143 \n",
+       "L 337.934234 469.549143 \n",
+       "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_57\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"469.549143\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_55\">\n",
+       "      <!-- 0.5 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(20.878125 473.937241) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-35\" x=\"95.410156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_16\">\n",
+       "     <g id=\"line2d_58\">\n",
+       "      <path d=\"M 48.746234 415.406286 \n",
+       "L 337.934234 415.406286 \n",
+       "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_59\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"48.746234\" y=\"415.406286\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_56\">\n",
+       "      <!-- 1.0 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(20.878125 419.794383) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-31\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_57\">\n",
+       "     <!-- Goal Rate -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(14.798438 491.280281) rotate(-90) scale(0.1 -0.1)\">\n",
+       "      <defs>\n",
+       "       <path id=\"DejaVuSans-47\" d=\"M 3809 666 \n",
+       "L 3809 1919 \n",
+       "L 2778 1919 \n",
+       "L 2778 2438 \n",
+       "L 4434 2438 \n",
+       "L 4434 434 \n",
+       "Q 4069 175 3628 42 \n",
+       "Q 3188 -91 2688 -91 \n",
+       "Q 1594 -91 976 548 \n",
+       "Q 359 1188 359 2328 \n",
+       "Q 359 3472 976 4111 \n",
+       "Q 1594 4750 2688 4750 \n",
+       "Q 3144 4750 3555 4637 \n",
+       "Q 3966 4525 4313 4306 \n",
+       "L 4313 3634 \n",
+       "Q 3963 3931 3569 4081 \n",
+       "Q 3175 4231 2741 4231 \n",
+       "Q 1884 4231 1454 3753 \n",
+       "Q 1025 3275 1025 2328 \n",
+       "Q 1025 1384 1454 906 \n",
+       "Q 1884 428 2741 428 \n",
+       "Q 3075 428 3337 486 \n",
+       "Q 3600 544 3809 666 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "      </defs>\n",
+       "      <use xlink:href=\"#DejaVuSans-47\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"77.490234\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-61\" x=\"138.671875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6c\" x=\"199.951172\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"227.734375\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-52\" x=\"259.521484\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-61\" x=\"326.753906\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"388.033203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"427.242188\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"patch_27\">\n",
+       "    <path d=\"M 58.385834 523.692 \n",
+       "L 135.502634 523.692 \n",
+       "L 135.502634 415.406286 \n",
+       "L 58.385834 415.406286 \n",
+       "z\n",
+       "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_28\">\n",
+       "    <path d=\"M 154.781834 523.692 \n",
+       "L 231.898634 523.692 \n",
+       "L 231.898634 419.068005 \n",
+       "L 154.781834 419.068005 \n",
+       "z\n",
+       "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_29\">\n",
+       "    <path d=\"M 251.177834 523.692 \n",
+       "L 328.294634 523.692 \n",
+       "L 328.294634 441.818602 \n",
+       "L 251.177834 441.818602 \n",
+       "z\n",
+       "\" clip-path=\"url(#paf0fe61c91)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_60\">\n",
+       "    <path clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_61\">\n",
+       "    <path clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_62\">\n",
+       "    <path clip-path=\"url(#paf0fe61c91)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_30\">\n",
+       "    <path d=\"M 48.746234 523.692 \n",
+       "L 48.746234 409.992 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_31\">\n",
+       "    <path d=\"M 48.746234 523.692 \n",
+       "L 337.934234 523.692 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"text_58\">\n",
+       "    <!-- 1.000 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(84.061578 412.157714) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-31\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-30\" x=\"222.65625\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_59\">\n",
+       "    <!-- 0.966 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(180.457578 415.819434) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-39\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-36\" x=\"159.033203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-36\" x=\"222.65625\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_60\">\n",
+       "    <!-- 0.756 -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(276.853578 438.570031) scale(0.09 -0.09)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-37\" x=\"95.410156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-36\" x=\"222.65625\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"text_61\">\n",
+       "    <!-- Goal Achievement Rate -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(122.713672 403.992) scale(0.12 -0.12)\">\n",
+       "     <defs>\n",
+       "      <path id=\"DejaVuSans-68\" d=\"M 3513 2113 \n",
+       "L 3513 0 \n",
+       "L 2938 0 \n",
+       "L 2938 2094 \n",
+       "Q 2938 2591 2744 2837 \n",
+       "Q 2550 3084 2163 3084 \n",
+       "Q 1697 3084 1428 2787 \n",
+       "Q 1159 2491 1159 1978 \n",
+       "L 1159 0 \n",
+       "L 581 0 \n",
+       "L 581 4863 \n",
+       "L 1159 4863 \n",
+       "L 1159 2956 \n",
+       "Q 1366 3272 1645 3428 \n",
+       "Q 1925 3584 2291 3584 \n",
+       "Q 2894 3584 3203 3211 \n",
+       "Q 3513 2838 3513 2113 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "     </defs>\n",
+       "     <use xlink:href=\"#DejaVuSans-47\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" x=\"77.490234\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-61\" x=\"138.671875\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"199.951172\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" x=\"227.734375\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-41\" x=\"259.521484\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-63\" x=\"326.179688\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-68\" x=\"381.160156\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-69\" x=\"444.539062\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"472.322266\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-76\" x=\"533.845703\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"593.025391\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6d\" x=\"654.548828\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"751.960938\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" x=\"813.484375\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" x=\"876.863281\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" x=\"916.072266\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-52\" x=\"947.859375\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-61\" x=\"1015.091797\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" x=\"1076.371094\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"1115.580078\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "  </g>\n",
+       "  <g id=\"axes_6\">\n",
+       "   <g id=\"patch_32\">\n",
+       "    <path d=\"M 403.112234 523.692 \n",
+       "L 692.300234 523.692 \n",
+       "L 692.300234 409.992 \n",
+       "L 403.112234 409.992 \n",
+       "L 403.112234 523.692 \n",
+       "z\n",
+       "\" style=\"fill: none\"/>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_11\">\n",
+       "    <g id=\"xtick_16\">\n",
+       "     <g id=\"line2d_63\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"451.310234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_62\">\n",
+       "      <!-- Aggressive -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(419.637066 541.968195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-67\" x=\"131.884766\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"195.361328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"234.224609\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"295.748047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"347.847656\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"399.947266\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"427.730469\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"486.910156\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_17\">\n",
+       "     <g id=\"line2d_64\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"547.706234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_63\">\n",
+       "      <!-- Nominal -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(523.819391 541.968195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-4e\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6f\" x=\"74.804688\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6d\" x=\"135.986328\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"233.398438\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6e\" x=\"261.181641\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"324.560547\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6c\" x=\"385.839844\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"xtick_18\">\n",
+       "     <g id=\"line2d_65\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#mff7ad7bf4a\" x=\"644.102234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_64\">\n",
+       "      <!-- Risk-averse -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(610.602723 541.968195) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-52\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-69\" x=\"69.482422\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"97.265625\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-6b\" x=\"149.365234\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2d\" x=\"207.275391\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-61\" x=\"243.359375\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-76\" x=\"304.638672\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"363.818359\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-72\" x=\"425.341797\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-73\" x=\"466.455078\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-65\" x=\"518.554688\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_65\">\n",
+       "     <!-- Agent Type -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(519.834359 555.968672) scale(0.1 -0.1)\">\n",
+       "      <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"131.884766\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"193.408203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"256.787109\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"295.996094\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-54\" x=\"327.783203\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-79\" x=\"373.242188\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-70\" x=\"432.421875\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"495.898438\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"matplotlib.axis_12\">\n",
+       "    <g id=\"ytick_17\">\n",
+       "     <g id=\"line2d_66\">\n",
+       "      <path d=\"M 403.112234 523.692 \n",
+       "L 692.300234 523.692 \n",
+       "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_67\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"523.692\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_66\">\n",
+       "      <!-- 0.00 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(367.895438 528.080098) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_18\">\n",
+       "     <g id=\"line2d_68\">\n",
+       "      <path d=\"M 403.112234 482.780405 \n",
+       "L 692.300234 482.780405 \n",
+       "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_69\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"482.780405\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_67\">\n",
+       "      <!-- 0.05 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(367.895438 487.168502) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-30\" x=\"95.410156\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-35\" x=\"159.033203\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"ytick_19\">\n",
+       "     <g id=\"line2d_70\">\n",
+       "      <path d=\"M 403.112234 441.868809 \n",
+       "L 692.300234 441.868809 \n",
+       "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: none; stroke: #cccccc; stroke-opacity: 0.3; stroke-linecap: round\"/>\n",
+       "     </g>\n",
+       "     <g id=\"line2d_71\">\n",
+       "      <g>\n",
+       "       <use xlink:href=\"#m8e39b3a308\" x=\"403.112234\" y=\"441.868809\" style=\"fill: #262626; stroke: #262626; stroke-width: 1.25\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "     <g id=\"text_68\">\n",
+       "      <!-- 0.10 -->\n",
+       "      <g style=\"fill: #262626\" transform=\"translate(367.895438 446.256907) scale(0.1155 -0.1155)\">\n",
+       "       <use xlink:href=\"#DejaVuSans-30\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-2e\" x=\"63.623047\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-31\" x=\"95.410156\"/>\n",
+       "       <use xlink:href=\"#DejaVuSans-30\" x=\"159.033203\"/>\n",
+       "      </g>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "    <g id=\"text_69\">\n",
+       "     <!-- Collision Rate -->\n",
+       "     <g style=\"fill: #262626\" transform=\"translate(361.81575 500.833406) rotate(-90) scale(0.1 -0.1)\">\n",
+       "      <use xlink:href=\"#DejaVuSans-43\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"69.824219\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6c\" x=\"131.005859\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6c\" x=\"158.789062\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-69\" x=\"186.572266\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-73\" x=\"214.355469\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-69\" x=\"266.455078\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6f\" x=\"294.238281\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-6e\" x=\"355.419922\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-20\" x=\"418.798828\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-52\" x=\"450.585938\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-61\" x=\"517.818359\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-74\" x=\"579.097656\"/>\n",
+       "      <use xlink:href=\"#DejaVuSans-65\" x=\"618.306641\"/>\n",
+       "     </g>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "   <g id=\"patch_33\">\n",
+       "    <path d=\"M 412.751834 523.692 \n",
+       "L 489.868634 523.692 \n",
+       "L 489.868634 433.660547 \n",
+       "L 412.751834 433.660547 \n",
+       "z\n",
+       "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: #b55d60; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_34\">\n",
+       "    <path d=\"M 509.147834 523.692 \n",
+       "L 586.264634 523.692 \n",
+       "L 586.264634 415.406286 \n",
+       "L 509.147834 415.406286 \n",
+       "z\n",
+       "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: #5f9e6e; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_35\">\n",
+       "    <path d=\"M 605.543834 523.692 \n",
+       "L 682.660634 523.692 \n",
+       "L 682.660634 449.38723 \n",
+       "L 605.543834 449.38723 \n",
+       "z\n",
+       "\" clip-path=\"url(#p8716c480a9)\" style=\"fill: #5875a4; opacity: 0.8; stroke: #ffffff; stroke-linejoin: miter\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_72\">\n",
+       "    <path clip-path=\"url(#p8716c480a9)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_73\">\n",
+       "    <path clip-path=\"url(#p8716c480a9)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"line2d_74\">\n",
+       "    <path clip-path=\"url(#p8716c480a9)\" style=\"fill: none; stroke: #424242; stroke-width: 2.25; stroke-linecap: round\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_36\">\n",
+       "    <path d=\"M 403.112234 523.692 \n",
+       "L 403.112234 409.992 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"patch_37\">\n",
+       "    <path d=\"M 403.112234 523.692 \n",
+       "L 692.300234 523.692 \n",
+       "\" style=\"fill: none; stroke: #262626; stroke-width: 1.25; stroke-linejoin: miter; stroke-linecap: square\"/>\n",
+       "   </g>\n",
+       "   <g id=\"text_70\">\n",
+       "    <!-- Collision Rate -->\n",
+       "    <g style=\"fill: #262626\" transform=\"translate(506.916547 403.992) scale(0.12 -0.12)\">\n",
+       "     <use xlink:href=\"#DejaVuSans-43\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" x=\"69.824219\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"131.005859\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6c\" x=\"158.789062\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-69\" x=\"186.572266\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-73\" x=\"214.355469\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-69\" x=\"266.455078\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6f\" x=\"294.238281\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-6e\" x=\"355.419922\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-20\" x=\"418.798828\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-52\" x=\"450.585938\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-61\" x=\"517.818359\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-74\" x=\"579.097656\"/>\n",
+       "     <use xlink:href=\"#DejaVuSans-65\" x=\"618.306641\"/>\n",
+       "    </g>\n",
+       "   </g>\n",
+       "  </g>\n",
+       "  <g id=\"text_71\">\n",
+       "   <!-- Agent Population Analysis | 50 scenes; measure at every time step; all agents controlled -->\n",
+       "   <g style=\"fill: #262626\" transform=\"translate(35.182609 17.899062) scale(0.14 -0.14)\">\n",
+       "    <defs>\n",
+       "     <path id=\"DejaVuSans-3b\" d=\"M 750 3309 \n",
+       "L 1409 3309 \n",
+       "L 1409 2516 \n",
+       "L 750 2516 \n",
+       "L 750 3309 \n",
+       "z\n",
+       "M 750 794 \n",
+       "L 1409 794 \n",
+       "L 1409 256 \n",
+       "L 897 -744 \n",
+       "L 494 -744 \n",
+       "L 750 256 \n",
+       "L 750 794 \n",
+       "z\n",
+       "\" transform=\"scale(0.015625)\"/>\n",
+       "    </defs>\n",
+       "    <use xlink:href=\"#DejaVuSans-41\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-67\" x=\"68.408203\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"131.884766\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6e\" x=\"193.408203\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-74\" x=\"256.787109\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"295.996094\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-50\" x=\"327.783203\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6f\" x=\"384.460938\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-70\" x=\"445.642578\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-75\" x=\"509.119141\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6c\" x=\"572.498047\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-61\" x=\"600.28125\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-74\" x=\"661.560547\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-69\" x=\"700.769531\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6f\" x=\"728.552734\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6e\" x=\"789.734375\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"853.113281\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-41\" x=\"884.900391\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6e\" x=\"953.308594\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-61\" x=\"1016.6875\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6c\" x=\"1077.966797\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-79\" x=\"1105.75\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-73\" x=\"1164.929688\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-69\" x=\"1217.029297\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-73\" x=\"1244.8125\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"1296.912109\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-7c\" x=\"1328.699219\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"1362.390625\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-35\" x=\"1394.177734\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-30\" x=\"1457.800781\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"1521.423828\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-73\" x=\"1553.210938\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-63\" x=\"1605.310547\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"1660.291016\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6e\" x=\"1721.814453\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"1785.193359\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-73\" x=\"1846.716797\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-3b\" x=\"1898.816406\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"1932.507812\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6d\" x=\"1964.294922\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"2061.707031\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-61\" x=\"2123.230469\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-73\" x=\"2184.509766\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-75\" x=\"2236.609375\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-72\" x=\"2299.988281\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"2338.851562\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"2400.375\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-61\" x=\"2432.162109\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-74\" x=\"2493.441406\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"2532.650391\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"2564.4375\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-76\" x=\"2625.960938\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"2685.140625\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-72\" x=\"2746.664062\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-79\" x=\"2787.777344\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"2846.957031\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-74\" x=\"2878.744141\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-69\" x=\"2917.953125\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6d\" x=\"2945.736328\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"3043.148438\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"3104.671875\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-73\" x=\"3136.458984\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-74\" x=\"3188.558594\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"3227.767578\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-70\" x=\"3289.291016\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-3b\" x=\"3352.767578\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"3386.458984\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-61\" x=\"3418.246094\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6c\" x=\"3479.525391\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6c\" x=\"3507.308594\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"3535.091797\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-61\" x=\"3566.878906\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-67\" x=\"3628.158203\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"3691.634766\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6e\" x=\"3753.158203\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-74\" x=\"3816.537109\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-73\" x=\"3855.746094\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-20\" x=\"3907.845703\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-63\" x=\"3939.632812\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6f\" x=\"3994.613281\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6e\" x=\"4055.794922\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-74\" x=\"4119.173828\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-72\" x=\"4158.382812\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6f\" x=\"4197.246094\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6c\" x=\"4258.427734\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-6c\" x=\"4286.210938\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-65\" x=\"4313.994141\"/>\n",
+       "    <use xlink:href=\"#DejaVuSans-64\" x=\"4375.517578\"/>\n",
+       "   </g>\n",
+       "  </g>\n",
+       " </g>\n",
+       " <defs>\n",
+       "  <clipPath id=\"pa89534f593\">\n",
+       "   <rect x=\"48.746234\" y=\"54.456\" width=\"289.188\" height=\"113.7\"/>\n",
+       "  </clipPath>\n",
+       "  <clipPath id=\"pf74dcec93a\">\n",
+       "   <rect x=\"403.112234\" y=\"54.456\" width=\"289.188\" height=\"113.7\"/>\n",
+       "  </clipPath>\n",
+       "  <clipPath id=\"p70a88f4f01\">\n",
+       "   <rect x=\"48.746234\" y=\"232.224\" width=\"289.188\" height=\"113.7\"/>\n",
+       "  </clipPath>\n",
+       "  <clipPath id=\"p8b19814f01\">\n",
+       "   <rect x=\"403.112234\" y=\"232.224\" width=\"289.188\" height=\"113.7\"/>\n",
+       "  </clipPath>\n",
+       "  <clipPath id=\"paf0fe61c91\">\n",
+       "   <rect x=\"48.746234\" y=\"409.992\" width=\"289.188\" height=\"113.7\"/>\n",
+       "  </clipPath>\n",
+       "  <clipPath id=\"p8716c480a9\">\n",
+       "   <rect x=\"403.112234\" y=\"409.992\" width=\"289.188\" height=\"113.7\"/>\n",
+       "  </clipPath>\n",
+       " </defs>\n",
+       "</svg>\n"
+      ],
+      "text/plain": [
+       "<Figure size 1000x800 with 6 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# Create a consistent color map for agent types\n",
+    "agent_colors = {\n",
+    "    'Aggressive': 'r',\n",
+    "    'Nominal': 'g',\n",
+    "    'Risk-averse': 'b'\n",
+    "}\n",
+    "\n",
+    "# Define the consistent order of agent types (Nominal in the middle)\n",
+    "agent_order = ['Aggressive', 'Nominal', 'Risk-averse']\n",
+    "\n",
+    "# Create figure with subplots - 3x2 to include acceleration and steering\n",
+    "fig, axes = plt.subplots(3, 2, figsize=(10, 8))\n",
+    "fig.suptitle('Agent Population Analysis | 50 scenes; measure at every time step; all agents controlled', fontsize=14, y=0.98)\n",
+    "\n",
+    "# 1. Policy Entropy by Agent Type (top left)\n",
+    "entropy_df = pd.DataFrame({\n",
+    "    'agent_type': results['entropy_stats'].index, \n",
+    "    'entropy': results['entropy_stats']['mean'].values\n",
+    "})\n",
+    "# Reorder according to our defined order instead of sorting\n",
+    "entropy_df = entropy_df.set_index('agent_type').reindex(agent_order).reset_index()\n",
+    "\n",
+    "colors = [agent_colors[agent] for agent in entropy_df['agent_type']]\n",
+    "sns.barplot(x='agent_type', y='entropy', data=entropy_df, \n",
+    "            palette=colors, alpha=0.8, ax=axes[0, 0])\n",
+    "axes[0, 0].set_title('Policy Entropy', fontsize=12)\n",
+    "axes[0, 0].set_ylabel('Average Entropy', fontsize=10)\n",
+    "axes[0, 0].set_xlabel('Agent Type', fontsize=10)\n",
+    "axes[0, 0].grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# Add values on top of bars\n",
+    "for i, row in enumerate(entropy_df.itertuples()):\n",
+    "    axes[0, 0].text(i, row.entropy + 0.01, f'{row.entropy:.3f}', \n",
+    "                   ha='center', fontsize=9)\n",
+    "\n",
+    "# 2. Agent Confidence via Log Probability (top right)\n",
+    "logprob_df = pd.DataFrame({'agent_type': results['avg_logprob'].index, \n",
+    "                           'logprob': results['avg_logprob'].values})\n",
+    "# Reorder according to our defined order\n",
+    "logprob_df = logprob_df.set_index('agent_type').reindex(agent_order).reset_index()\n",
+    "\n",
+    "colors = [agent_colors[agent] for agent in logprob_df['agent_type']]\n",
+    "sns.barplot(x='agent_type', y='logprob', data=logprob_df, \n",
+    "            palette=colors, alpha=0.8, ax=axes[0, 1])\n",
+    "axes[0, 1].set_title(f'Agent Confidence | $\\log(p(a_t)$', fontsize=12)\n",
+    "axes[0, 1].set_ylabel('Log Probability', fontsize=10)\n",
+    "axes[0, 1].set_xlabel('Agent Type', fontsize=10)\n",
+    "axes[0, 1].grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# Add values on top of bars\n",
+    "for i, row in enumerate(logprob_df.itertuples()):\n",
+    "    y_offset = 0.05 if row.logprob < 0 else -0.05\n",
+    "    axes[0, 1].text(i, row.logprob + y_offset, f'{row.logprob:.3f}', \n",
+    "                   ha='center', fontsize=9)\n",
+    "\n",
+    "# 3. Average Acceleration by Agent Type (middle left)\n",
+    "accel_df = df.groupby('agent_type')['acceleration'].mean().reset_index()\n",
+    "# Reorder according to our defined order\n",
+    "accel_df = accel_df.set_index('agent_type').reindex(agent_order).reset_index()\n",
+    "\n",
+    "colors = [agent_colors[agent] for agent in accel_df['agent_type']]\n",
+    "sns.barplot(x='agent_type', y='acceleration', data=accel_df, \n",
+    "            palette=colors, alpha=0.8, ax=axes[1, 0])\n",
+    "axes[1, 0].set_title('Average Acceleration', fontsize=12)\n",
+    "axes[1, 0].set_ylabel('Acceleration', fontsize=10)\n",
+    "axes[1, 0].set_xlabel('Agent Type', fontsize=10)\n",
+    "axes[1, 0].grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# Add values on top of bars\n",
+    "for i, row in enumerate(accel_df.itertuples()):\n",
+    "    axes[1, 0].text(i, row.acceleration + 0.1, f'{row.acceleration:.2f}', \n",
+    "                   ha='center', fontsize=9)\n",
+    "\n",
+    "# 4. Average Steering by Agent Type (middle right)\n",
+    "# Calculate average absolute steering angle\n",
+    "steering_df = df.groupby('agent_type').apply(lambda x: abs(x['steering']).mean()).reset_index()\n",
+    "steering_df.columns = ['agent_type', 'steering']\n",
+    "# Reorder according to our defined order\n",
+    "steering_df = steering_df.set_index('agent_type').reindex(agent_order).reset_index()\n",
+    "\n",
+    "colors = [agent_colors[agent] for agent in steering_df['agent_type']]\n",
+    "sns.barplot(x='agent_type', y='steering', data=steering_df, \n",
+    "            palette=colors, alpha=0.8, ax=axes[1, 1])\n",
+    "axes[1, 1].set_title('Absolute Steering Angle', fontsize=12)\n",
+    "axes[1, 1].set_ylabel('Avg Absolute Steering', fontsize=10)\n",
+    "axes[1, 1].set_xlabel('Agent Type', fontsize=10)\n",
+    "axes[1, 1].grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# Add values on top of bars\n",
+    "for i, row in enumerate(steering_df.itertuples()):\n",
+    "    axes[1, 1].text(i, row.steering + 0.1, f'{row.steering:.2f}', \n",
+    "                   ha='center', fontsize=9)\n",
+    "\n",
+    "# 5. Goal Achievement Rate (bottom left)\n",
+    "goal_df = pd.DataFrame({\n",
+    "    'agent_type': results['goal_rate'].index,\n",
+    "    'goal_rate': results['goal_rate'].values\n",
+    "})\n",
+    "# Reorder according to our defined order\n",
+    "goal_df = goal_df.set_index('agent_type').reindex(agent_order).reset_index()\n",
+    "\n",
+    "colors = [agent_colors[agent] for agent in goal_df['agent_type']]\n",
+    "sns.barplot(x='agent_type', y='goal_rate', data=goal_df, \n",
+    "            palette=colors, alpha=0.8, ax=axes[2, 0])\n",
+    "axes[2, 0].set_title('Goal Achievement Rate', fontsize=12)\n",
+    "axes[2, 0].set_ylabel('Goal Rate', fontsize=10)\n",
+    "axes[2, 0].set_xlabel('Agent Type', fontsize=10)\n",
+    "axes[2, 0].grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# Add values on top of bars\n",
+    "for i, row in enumerate(goal_df.itertuples()):\n",
+    "    axes[2, 0].text(i, row.goal_rate + 0.03, f'{row.goal_rate:.3f}', \n",
+    "                    ha='center', fontsize=9)\n",
+    "\n",
+    "\n",
+    "# 6. Collision Rate (bottom right)\n",
+    "\n",
+    "collision_df = pd.DataFrame({\n",
+    "    'agent_type': results['collision_rate'].index,\n",
+    "    'collision_rate': results['collision_rate'].values\n",
+    "})\n",
+    "# Reorder according to our defined order\n",
+    "collision_df = collision_df.set_index('agent_type').reindex(agent_order).reset_index()\n",
+    "\n",
+    "colors = [agent_colors[agent] for agent in collision_df['agent_type']]\n",
+    "sns.barplot(x='agent_type', y='collision_rate', data=collision_df, \n",
+    "            palette=colors, alpha=0.8, ax=axes[2, 1])\n",
+    "axes[2, 1].set_title('Collision Rate', fontsize=12)\n",
+    "axes[2, 1].set_ylabel('Collision Rate', fontsize=10)\n",
+    "axes[2, 1].set_xlabel('Agent Type', fontsize=10)\n",
+    "axes[2, 1].grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "# Adjust layout\n",
+    "plt.tight_layout()\n",
+    "#plt.subplots_adjust(top=0.95)\n",
+    "sns.despine()\n",
+    "plt.savefig('agent_population_analysis.pdf', dpi=300, bbox_inches='tight')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "gpudrive",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/experimental/notebooks/debug.ipynb b/examples/experimental/notebooks/debug.ipynb
new file mode 100644
index 000000000..2be729d0a
--- /dev/null
+++ b/examples/experimental/notebooks/debug.ipynb
@@ -0,0 +1,903 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# reload magic\n",
+    "import importlib\n",
+    "import gpudrive\n",
+    "importlib.reload(gpudrive)\n",
+    "from gpudrive.env.env_torch import GPUDriveTorchEnv\n",
+    "from gpudrive.env.config import EnvConfig, RenderConfig\n",
+    "from gpudrive.env.dataset import SceneDataLoader\n",
+    "\n",
+    "from gpudrive.visualize.utils import img_from_fig\n",
+    "\n",
+    "import torch\n",
+    "from PIL import Image\n",
+    "\n",
+    "from matplotlib import pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Make environment"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "env_config = EnvConfig(\n",
+    "    dynamics_model=\"classic\",\n",
+    "    reward_type=\"follow_waypoints\",\n",
+    "    add_reference_path=True,\n",
+    ")\n",
+    "render_config = RenderConfig()\n",
+    "\n",
+    "train_loader = SceneDataLoader(\n",
+    "    root=\"data/processed/examples\",\n",
+    "    batch_size=2,\n",
+    "    dataset_size=100,\n",
+    "    sample_with_replacement=True,\n",
+    "    shuffle=False,\n",
+    ")\n",
+    "\n",
+    "env = GPUDriveTorchEnv(\n",
+    "    config=env_config,\n",
+    "    data_loader=train_loader,\n",
+    "    max_cont_agents=64, \n",
+    "    device=\"cpu\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Controllable agents: tensor([ 0,  1,  2,  4, 12])\n",
+      "Controlling agent 2 in env 0.\n"
+     ]
+    }
+   ],
+   "source": [
+    "env_i = 0\n",
+    "agent_j = 2\n",
+    "\n",
+    "control_mask = env.cont_agent_mask\n",
+    "\n",
+    "print(f'Controllable agents: {torch.where(env.cont_agent_mask[env_i, :])[0]}')\n",
+    "\n",
+    "print(f'Controlling agent {agent_j} in env {env_i}.')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Verify indexing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "obs = env.reset(control_mask)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "obs = env.reset(control_mask)\n",
+    "\n",
+    "expert_actions, _, _, _ = env.get_expert_actions()\n",
+    "\n",
+    "for t in range(5):\n",
+    "    env.step_dynamics(expert_actions[:, :, t, :])\n",
+    "    obs = env.get_obs(control_mask)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([91, 3])"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traj_masked = env.reference_path[2, :, :]\n",
+    "\n",
+    "traj_masked.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "valid: tensor([True, True, True, True, True, True, True, True, True, True, True, True,\n",
+      "        True, True, True, True, True, True, True, True, True, True, True, True,\n",
+      "        True, True, True, True, True, True, True, True, True, True, True, True,\n",
+      "        True, True, True, True, True, True, True, True, True, True, True, True,\n",
+      "        True, True, True, True, True, True, True, True, True, True, True, True,\n",
+      "        True, True, True, True, True, True, True, True, True, True, True, True,\n",
+      "        True, True, True, True, True, True, True, True, True, True, True, True,\n",
+      "        True, True, True, True, True, True, True])\n"
+     ]
+    },
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=700x700>"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traj_masked = env.reference_path[2, :, :]\n",
+    "\n",
+    "agent_obs_masked = env.vis.plot_agent_observation(\n",
+    "    env_idx=env_i,\n",
+    "    agent_idx=agent_j,\n",
+    "    figsize=(7, 7),\n",
+    "    trajectory=traj_masked,\n",
+    ")\n",
+    "\n",
+    "Image.fromarray(img_from_fig(agent_obs_masked))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[-2.8176e+00,  1.6540e-06,  0.0000e+00],\n",
+       "        [-2.2567e+00, -5.4991e-02,  0.0000e+00],\n",
+       "        [-1.6712e+00, -1.1899e-01,  0.0000e+00],\n",
+       "        [-1.1435e+00, -2.1718e-01,  0.0000e+00],\n",
+       "        [-5.8799e-01, -3.4425e-01,  0.0000e+00],\n",
+       "        [-4.9307e-02, -4.9633e-01,  0.0000e+00],\n",
+       "        [ 4.9877e-01, -6.5314e-01,  1.0000e+00],\n",
+       "        [ 1.0278e+00, -8.2594e-01,  0.0000e+00],\n",
+       "        [ 1.5701e+00, -1.0161e+00,  0.0000e+00],\n",
+       "        [ 2.0863e+00, -1.2118e+00,  0.0000e+00],\n",
+       "        [ 2.6098e+00, -1.4267e+00,  0.0000e+00],\n",
+       "        [ 3.1191e+00, -1.6454e+00,  0.0000e+00],\n",
+       "        [ 3.6540e+00, -1.8755e+00,  0.0000e+00],\n",
+       "        [ 4.1953e+00, -2.1215e+00,  0.0000e+00],\n",
+       "        [ 4.7675e+00, -2.3735e+00,  0.0000e+00],\n",
+       "        [ 5.3208e+00, -2.6513e+00,  0.0000e+00],\n",
+       "        [ 5.8825e+00, -2.8995e+00,  0.0000e+00],\n",
+       "        [ 6.4127e+00, -3.1944e+00,  0.0000e+00],\n",
+       "        [ 6.9735e+00, -3.4876e+00,  0.0000e+00],\n",
+       "        [ 7.5203e+00, -3.8051e+00,  0.0000e+00],\n",
+       "        [ 8.0950e+00, -4.1299e+00,  0.0000e+00],\n",
+       "        [ 8.6821e+00, -4.4582e+00,  0.0000e+00],\n",
+       "        [ 9.2876e+00, -4.8013e+00,  0.0000e+00],\n",
+       "        [ 9.9100e+00, -5.1523e+00,  0.0000e+00],\n",
+       "        [ 1.0536e+01, -5.5163e+00,  0.0000e+00],\n",
+       "        [ 1.1209e+01, -5.8927e+00,  0.0000e+00],\n",
+       "        [ 1.1828e+01, -6.2615e+00,  0.0000e+00],\n",
+       "        [ 1.2506e+01, -6.6497e+00,  0.0000e+00],\n",
+       "        [ 1.3193e+01, -7.0484e+00,  0.0000e+00],\n",
+       "        [ 1.3869e+01, -7.4457e+00,  0.0000e+00],\n",
+       "        [ 1.4562e+01, -7.8596e+00,  0.0000e+00],\n",
+       "        [ 1.5258e+01, -8.2762e+00,  0.0000e+00],\n",
+       "        [ 1.5968e+01, -8.6956e+00,  0.0000e+00],\n",
+       "        [ 1.6693e+01, -9.1250e+00,  0.0000e+00],\n",
+       "        [ 1.7441e+01, -9.5761e+00,  0.0000e+00],\n",
+       "        [ 1.8156e+01, -9.9870e+00,  0.0000e+00],\n",
+       "        [ 1.8938e+01, -1.0467e+01,  0.0000e+00],\n",
+       "        [ 1.9656e+01, -1.0894e+01,  0.0000e+00],\n",
+       "        [ 2.0452e+01, -1.1372e+01,  0.0000e+00],\n",
+       "        [ 2.1205e+01, -1.1824e+01,  0.0000e+00],\n",
+       "        [ 2.1998e+01, -1.2283e+01,  0.0000e+00],\n",
+       "        [ 2.2798e+01, -1.2767e+01,  0.0000e+00],\n",
+       "        [ 2.3605e+01, -1.3238e+01,  0.0000e+00],\n",
+       "        [ 2.4404e+01, -1.3717e+01,  0.0000e+00],\n",
+       "        [ 2.5225e+01, -1.4205e+01,  0.0000e+00],\n",
+       "        [ 2.6044e+01, -1.4694e+01,  0.0000e+00],\n",
+       "        [ 2.6874e+01, -1.5197e+01,  0.0000e+00],\n",
+       "        [ 2.7730e+01, -1.5706e+01,  0.0000e+00],\n",
+       "        [ 2.8580e+01, -1.6209e+01,  0.0000e+00],\n",
+       "        [ 2.9454e+01, -1.6734e+01,  0.0000e+00],\n",
+       "        [ 3.0307e+01, -1.7237e+01,  0.0000e+00],\n",
+       "        [ 3.1191e+01, -1.7769e+01,  0.0000e+00],\n",
+       "        [ 3.2098e+01, -1.8292e+01,  0.0000e+00],\n",
+       "        [ 3.2996e+01, -1.8836e+01,  0.0000e+00],\n",
+       "        [ 3.3914e+01, -1.9388e+01,  0.0000e+00],\n",
+       "        [ 3.4817e+01, -1.9921e+01,  0.0000e+00],\n",
+       "        [ 3.5705e+01, -2.0455e+01,  0.0000e+00],\n",
+       "        [ 3.6645e+01, -2.0996e+01,  0.0000e+00],\n",
+       "        [ 3.7594e+01, -2.1556e+01,  0.0000e+00],\n",
+       "        [ 3.8527e+01, -2.2106e+01,  0.0000e+00],\n",
+       "        [ 3.9451e+01, -2.2661e+01,  0.0000e+00],\n",
+       "        [ 4.0428e+01, -2.3217e+01,  0.0000e+00],\n",
+       "        [ 4.1375e+01, -2.3780e+01,  0.0000e+00],\n",
+       "        [ 4.2307e+01, -2.4312e+01,  0.0000e+00],\n",
+       "        [ 4.3282e+01, -2.4874e+01,  0.0000e+00],\n",
+       "        [ 4.4235e+01, -2.5452e+01,  0.0000e+00],\n",
+       "        [ 4.5213e+01, -2.6012e+01,  0.0000e+00],\n",
+       "        [ 4.6172e+01, -2.6576e+01,  0.0000e+00],\n",
+       "        [ 4.7116e+01, -2.7120e+01,  0.0000e+00],\n",
+       "        [ 4.8107e+01, -2.7662e+01,  0.0000e+00],\n",
+       "        [ 4.9131e+01, -2.8236e+01,  0.0000e+00],\n",
+       "        [ 5.0127e+01, -2.8802e+01,  0.0000e+00],\n",
+       "        [ 5.1111e+01, -2.9381e+01,  0.0000e+00],\n",
+       "        [ 5.2130e+01, -2.9930e+01,  0.0000e+00],\n",
+       "        [ 5.3149e+01, -3.0526e+01,  0.0000e+00],\n",
+       "        [ 5.4187e+01, -3.1101e+01,  0.0000e+00],\n",
+       "        [ 5.5308e+01, -3.1733e+01,  0.0000e+00],\n",
+       "        [ 5.6316e+01, -3.2302e+01,  0.0000e+00],\n",
+       "        [ 5.7350e+01, -3.2853e+01,  0.0000e+00],\n",
+       "        [ 5.8433e+01, -3.3481e+01,  0.0000e+00],\n",
+       "        [ 5.9471e+01, -3.4043e+01,  0.0000e+00],\n",
+       "        [ 6.0508e+01, -3.4615e+01,  0.0000e+00],\n",
+       "        [ 6.1611e+01, -3.5201e+01,  0.0000e+00],\n",
+       "        [ 6.2707e+01, -3.5811e+01,  0.0000e+00],\n",
+       "        [ 6.3779e+01, -3.6378e+01,  0.0000e+00],\n",
+       "        [ 6.4890e+01, -3.7002e+01,  0.0000e+00],\n",
+       "        [ 6.5991e+01, -3.7572e+01,  0.0000e+00],\n",
+       "        [-2.3981e+01,  1.1701e+01,  0.0000e+00],\n",
+       "        [-2.3981e+01,  1.1701e+01,  0.0000e+00],\n",
+       "        [-2.3981e+01,  1.1701e+01,  0.0000e+00],\n",
+       "        [-2.3981e+01,  1.1701e+01,  0.0000e+00]])"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traj_masked"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([10, 91, 1])"
+      ]
+     },
+     "execution_count": 41,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "env.log_trajectory.valids.bool()[control_mask].shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#env.log_trajectory.pos_xy[env_i, agent_j]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "\n",
+    "#plt.scatter(traj[:, 0], traj[:, 1], label=\"trajectory\", alpha=0.3)\n",
+    "plt.scatter(traj_masked[:, 0], traj_masked[:, 1], label=\"trajectory\", alpha=0.3)\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "tensor([[    -4.6843,     -0.0000],\n",
+       "        [    -3.7478,      0.0228],\n",
+       "        [    -2.6972,      0.0244],\n",
+       "        [    -1.6492,      0.0099],\n",
+       "        [    -0.5689,     -0.0026],\n",
+       "        [     0.5339,     -0.0228],\n",
+       "        [     1.6032,     -0.0322],\n",
+       "        [     2.7434,     -0.0402],\n",
+       "        [     3.8651,     -0.0452],\n",
+       "        [     5.0059,     -0.0523],\n",
+       "        [     6.1329,     -0.0523],\n",
+       "        [     7.3169,     -0.0725],\n",
+       "        [     8.4740,     -0.0730],\n",
+       "        [     9.6554,     -0.0751],\n",
+       "        [    10.8401,     -0.0971],\n",
+       "        [    12.0179,     -0.1008],\n",
+       "        [    13.1972,     -0.1081],\n",
+       "        [    14.4008,     -0.1100],\n",
+       "        [    15.6533,     -0.1187],\n",
+       "        [    16.8722,     -0.1357],\n",
+       "        [    18.1067,     -0.1230],\n",
+       "        [    19.3222,     -0.1372],\n",
+       "        [    20.5441,     -0.1466],\n",
+       "        [    21.8482,     -0.1608],\n",
+       "        [    23.0581,     -0.1674],\n",
+       "        [    24.3297,     -0.1660],\n",
+       "        [    25.6302,     -0.1674],\n",
+       "        [    26.8703,     -0.1745],\n",
+       "        [    28.1802,     -0.1851],\n",
+       "        [    29.4575,     -0.1919],\n",
+       "        [    30.7170,     -0.1969],\n",
+       "        [    32.0253,     -0.1917],\n",
+       "        [    33.3079,     -0.2276],\n",
+       "        [    34.6077,     -0.2223],\n",
+       "        [    35.9107,     -0.2487],\n",
+       "        [    37.1519,     -0.2415],\n",
+       "        [    38.4949,     -0.2594],\n",
+       "        [    39.8145,     -0.2651],\n",
+       "        [    41.1175,     -0.2745],\n",
+       "        [    42.5277,     -0.2947],\n",
+       "        [    43.9141,     -0.3020],\n",
+       "        [    45.6483,     -0.3042],\n",
+       "        [    46.7122,     -0.3789],\n",
+       "        [    47.9882,     -0.3708],\n",
+       "        [    49.2079,     -0.4041],\n",
+       "        [    50.4362,     -0.4111],\n",
+       "        [    51.7675,     -0.3951],\n",
+       "        [    53.1219,     -0.4074],\n",
+       "        [    54.4872,     -0.3983],\n",
+       "        [    55.8000,     -0.4567],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000],\n",
+       "        [    -0.0000,     -0.0000]])"
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# Set print options to suppress scientific notation\n",
+    "torch.set_printoptions(sci_mode=False)\n",
+    "\n",
+    "traj_masked"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 83,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([91, 2])"
+      ]
+     },
+     "execution_count": 83,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traj_masked.shape"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Plot agent observation with other traj"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=700x700>"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "obs = env.reset()\n",
+    "\n",
+    "traj = env.local_reference_xy[env_i, agent_j, :]\n",
+    "\n",
+    "agent_obs = env.vis.plot_agent_observation(\n",
+    "    env_idx=env_i,\n",
+    "    agent_idx=agent_j,\n",
+    "    figsize=(7, 7),\n",
+    "    trajectory=traj,\n",
+    ")\n",
+    "Image.fromarray(img_from_fig(agent_obs))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([91, 2])"
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traj.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 71,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "torch.Size([91, 2])"
+      ]
+     },
+     "execution_count": 71,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "traj_masked.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "%matplotlib inline\n",
+    "\n",
+    "plt.scatter(traj[:, 0], traj[:, 1], label=\"trajectory\", alpha=0.3)\n",
+    "#plt.scatter(traj_masked[:, 0], traj_masked[:, 1], label=\"masked trajectory\", alpha=0.3)\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "shapes: torch.Size([1, 64, 2]), torch.Size([1, 64]), torch.Size([1, 64, 91, 2])\n"
+     ]
+    }
+   ],
+   "source": [
+    "from gpudrive.datatypes.trajectory import LogTrajectory, to_local_frame\n",
+    "\n",
+    "global_ego_states = (\n",
+    "    env.sim.absolute_self_observation_tensor()\n",
+    "    .to_torch()\n",
+    "    .clone()\n",
+    ")\n",
+    "\n",
+    "X_global = global_ego_states[:, :, :2]\n",
+    "theta_global = global_ego_states[:, :, 7]\n",
+    "Y_global = env.log_trajectory.pos_xy\n",
+    "\n",
+    "print(f\"shapes: {X_global.shape}, {theta_global.shape}, {Y_global.shape}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Ground-truth"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([91, 2])\n",
+      "tensor([[ 0.0000,  0.0000],\n",
+      "        [-0.2891,  0.1440],\n",
+      "        [-0.6191,  0.2827],\n",
+      "        [-0.9414,  0.4409],\n",
+      "        [-1.3057,  0.6079],\n",
+      "        [-1.6631,  0.7720],\n",
+      "        [-2.0215,  0.9507],\n",
+      "        [-2.4121,  1.1333],\n",
+      "        [-2.8125,  1.3320],\n",
+      "        [-3.2266,  1.5381]])\n",
+      " \n",
+      " R = torch.Size([2, 2]) =\n",
+      "tensor([[-0.9079,  0.4191],\n",
+      "        [-0.4191, -0.9079]])\n",
+      " \n",
+      " Y_local = torch.Size([91, 2]) =\n",
+      "tensor([[ 0.0000,  0.0000],\n",
+      "        [ 0.3228, -0.0096],\n",
+      "        [ 0.6806,  0.0028],\n",
+      "        [ 1.0395, -0.0057],\n",
+      "        [ 1.4402, -0.0047]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 1) Translate\n",
+    "Y_bar = Y_global[env_i, agent_j, :] - X_global[env_i, agent_j, :]\n",
+    "\n",
+    "print(Y_bar.shape)\n",
+    "print(Y_bar[:10])\n",
+    "print(\" \")\n",
+    "\n",
+    "# 2) Rotate\n",
+    "cos_yaw = torch.cos(theta_global[env_i, agent_j])\n",
+    "sin_yaw = torch.sin(theta_global[env_i, agent_j])\n",
+    "rotation_matrix = torch.tensor(\n",
+    "    [[cos_yaw, sin_yaw], [-sin_yaw, cos_yaw]]\n",
+    ")\n",
+    "\n",
+    "print(f' R = {rotation_matrix.shape} =')\n",
+    "print(rotation_matrix)\n",
+    "\n",
+    "# 3) Transform\n",
+    "Y_local = torch.matmul(Y_bar, rotation_matrix.T)\n",
+    "\n",
+    "print(\" \")\n",
+    "print(f' Y_local = {Y_local.shape} =')\n",
+    "print(\n",
+    "    Y_local[:5]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Batched"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "torch.Size([91, 2])\n",
+      "tensor([-1.3057,  0.6079])\n",
+      " \n",
+      " R = torch.Size([64, 2, 2]) =\n",
+      "tensor([[-0.9079,  0.4191],\n",
+      "        [-0.4191, -0.9079]])\n",
+      " \n",
+      " Y_local = torch.Size([64, 91, 2]) =\n",
+      "tensor([[ 0.0000e+00,  0.0000e+00],\n",
+      "        [ 3.2282e-01, -9.6245e-03],\n",
+      "        [ 6.8063e-01,  2.8185e-03],\n",
+      "        [ 1.0395e+00, -5.7459e-03],\n",
+      "        [ 1.4402e+00, -4.6898e-03],\n",
+      "        [ 1.8335e+00, -3.8388e-03],\n",
+      "        [ 2.2338e+00, -1.5878e-02],\n",
+      "        [ 2.6650e+00, -1.7957e-02],\n",
+      "        [ 3.1118e+00, -3.0572e-02],\n",
+      "        [ 3.5741e+00, -4.4107e-02]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 1) Translate\n",
+    "Y_bar_batched = Y_global[env_i] - X_global[env_i].unsqueeze(1)\n",
+    "\n",
+    "print(Y_bar.shape)\n",
+    "print(Y_bar[agent_j, :10])\n",
+    "\n",
+    "# 2) Rotate\n",
+    "cos_yaw = torch.cos(theta_global[env_i])\n",
+    "sin_yaw = torch.sin(theta_global[env_i])\n",
+    "R_batched = torch.stack(\n",
+    "    [\n",
+    "        torch.stack([cos_yaw, sin_yaw], dim=1),\n",
+    "        torch.stack([-sin_yaw, cos_yaw], dim=1),\n",
+    "    ],\n",
+    "    dim=1,\n",
+    ") \n",
+    "\n",
+    "print(f' ')\n",
+    "print(f' R = {R_batched.shape} =')\n",
+    "print(R_batched[agent_j, :, :])\n",
+    "\n",
+    "# 3) Transform\n",
+    "Y_local_batched = torch.bmm(\n",
+    "    Y_bar_batched, R_batched.transpose(1, 2)\n",
+    ")\n",
+    "\n",
+    "print(\" \")\n",
+    "print(f' Y_local = {Y_local_batched.shape} =')\n",
+    "print(\n",
+    "    Y_local_batched[agent_j, :10]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "True"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "torch.equal(\n",
+    "    Y_local_batched[agent_j, :], Y_local[:]\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "agent_obs = env.vis.plot_agent_observation(\n",
+    "    env_idx=env_idx,\n",
+    "    agent_idx=highlight_agent,\n",
+    "    figsize=(10, 10),\n",
+    "    trajectory=Y_local,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1000x1000>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "Image.fromarray(img_from_fig(agent_obs))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/jpeg": "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",
+      "image/png": "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",
+      "text/plain": [
+       "<PIL.Image.Image image mode=RGB size=1000x1000>"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "agent_obs = env.vis.plot_agent_observation(\n",
+    "    env_idx=env_idx,\n",
+    "    agent_idx=highlight_agent,\n",
+    "    figsize=(10, 10),\n",
+    "    trajectory=Y_local_batched[agent_j, :]\n",
+    ")\n",
+    "\n",
+    "Image.fromarray(img_from_fig(agent_obs))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "gpudrive",
+   "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.11.9"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/examples/tutorials/08_multiple_policies.ipynb b/examples/tutorials/08_multiple_policies.ipynb
index 7b7bbd13f..04614dda4 100644
--- a/examples/tutorials/08_multiple_policies.ipynb
+++ b/examples/tutorials/08_multiple_policies.ipynb
@@ -1,8 +1,15 @@
 {
  "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Using multiple policies in the same environment"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -16,42 +23,68 @@
     "from gpudrive.env.env_torch import GPUDriveTorchEnv\n",
     "from gpudrive.env.dataset import SceneDataLoader\n",
     "from gpudrive.utils.config import load_config \n",
-    "import sys\n",
-    "import imageio\n",
-    "import numpy as np\n",
-    "import os\n",
-    "from gpudrive.utils.multi_policy_rollout import multi_policy_rollout\n"
+    "\n",
+    "from gpudrive.utils.rollout import multi_policy_rollout"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Helper function"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "def create_policy_masks(env, num_sim_agents=2, num_worlds=10):\n",
+    "    \"\"\"\n",
+    "    Create policy masks for multiple agents across different worlds.\n",
+    "    \n",
+    "    Args:\n",
+    "        env: The environment object containing agent mask information\n",
+    "        num_sim_agents: Number of simultaneous agents to create policies for\n",
+    "        num_worlds: Number of simulation worlds\n",
+    "        \n",
+    "    Returns:\n",
+    "        Dictionary of policy masks with keys 'pi_1', 'pi_2', etc.\n",
+    "    \"\"\"\n",
+    "    # Initialize policy mask with zeros (same shape as cont_agent_mask)\n",
     "    policy_mask = torch.zeros_like(env.cont_agent_mask, dtype=torch.int)\n",
+    "    \n",
+    "    # Get indices of controlled agents\n",
     "    agent_indices = env.cont_agent_mask.nonzero(as_tuple=True)\n",
     "\n",
+    "    # Assign policy numbers (1 to num_sim_agents) to each agent in a round-robin fashion\n",
     "    for i, (world_idx, agent_idx) in enumerate(zip(*agent_indices)):\n",
     "        policy_mask[world_idx, agent_idx] = (i % num_sim_agents) + 1\n",
     "\n",
-    "    policy_masks = {f'pi_{int(policy.item())}': torch.zeros_like(env.cont_agent_mask, dtype=torch.bool,device=device) \n",
-    "                    for policy in policy_mask.unique() if policy.item() != 0}\n",
-    "\n",
+    "    # Create a dictionary of empty boolean masks for each policy\n",
+    "    policy_masks = {\n",
+    "        f'pi_{int(policy.item())}': torch.zeros_like(\n",
+    "            env.cont_agent_mask, \n",
+    "            dtype=torch.bool,\n",
+    "            device=env.cont_agent_mask.device  # Use the same device as the mask\n",
+    "        ) \n",
+    "        for policy in policy_mask.unique() if policy.item() != 0\n",
+    "    }\n",
+    "\n",
+    "    # Fill in the boolean masks for each policy\n",
     "    for p in range(1, num_sim_agents + 1):\n",
     "        policy_masks[f'pi_{p}'] = (policy_mask == p).reshape(num_worlds, -1)\n",
     "\n",
-    "    return policy_masks\n"
+    "    return policy_masks"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Configs model has been trained with\n",
     "config = load_config(\"../../examples/experimental/config/reliable_agents_params\")\n",
     "max_agents = config.max_controlled_agents\n",
@@ -61,25 +94,22 @@
     "FPS = 5\n",
     "\n",
     "sim_agent1 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S10_000_02_27\")\n",
-    "sim_agent2 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S1000_02_27\")\n",
-    "\n",
-    "# Some other info\n",
-    "card = ModelCard.load(\"daphne-cornelisse/policy_S10_000_02_27\")\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "sim_agent1 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S10_000_02_27\")\n",
-    "sim_agent2 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S1000_02_27\")\n"
+    "sim_agent2 = NeuralNet.from_pretrained(\"daphne-cornelisse/policy_S1000_02_27\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Make environment"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "train_loader = SceneDataLoader(\n",
     "    root='../../data/processed/examples',\n",
     "    batch_size=NUM_ENVS,\n",
@@ -111,8 +141,6 @@
     "    ),\n",
     ")\n",
     "\n",
-    "\n",
-    "\n",
     "env = GPUDriveTorchEnv(\n",
     "    config=env_config,\n",
     "    data_loader=train_loader,\n",
@@ -121,61 +149,75 @@
     ")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Rollout"
+   ]
+  },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
     "next_obs = env.reset()\n",
     "\n",
-    "\n",
     "control_mask = env.cont_agent_mask\n",
     "\n",
-    "policy_mask = create_policy_masks(env, 2,NUM_ENVS)\n",
-    "\n",
-    "policies_set = {'pi_1': (sim_agent1,policy_mask['pi_1']),\n",
-    "                'pi_2': (sim_agent2, policy_mask['pi_2'])\n",
-    "                } \n",
-    "        \n",
+    "# Create policy masks for 2 agents across NUM_ENVS worlds\n",
+    "policy_mask = create_policy_masks(env, num_sim_agents=2, num_worlds=NUM_ENVS)\n",
     "\n",
+    "# Define the policy set with agent models and their corresponding masks\n",
+    "policies_set = {\n",
+    "    'pi_1': (sim_agent1, policy_mask['pi_1']),\n",
+    "    'pi_2': (sim_agent2, policy_mask['pi_2'])\n",
+    "}\n",
     "\n",
-    "metrics,frames=multi_policy_rollout(\n",
-    "env,\n",
-    "policies_set, \n",
-    "device,\n",
-    "deterministic=False,\n",
-    "render_sim_state = True,\n",
-    "render_every_n_steps= 5\n",
+    "# Rollout with multiple policies\n",
+    "metrics, frames = multi_policy_rollout(\n",
+    "    env=env,\n",
+    "    policies=policies_set,\n",
+    "    device=device,\n",
+    "    deterministic=False,\n",
+    "    render_sim_state=True,\n",
+    "    render_every_n_steps=5\n",
     ")\n",
     "\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "\n",
-    "env.close()\n"
+    "env.close()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<table class=\"show_videos\" style=\"border-spacing:0px;\"><tr><td style=\"padding:1px;\"><div style=\"display:flex; align-items:left;\">\n",
+       "      <div style=\"display:flex; flex-direction:column; align-items:center;\">\n",
+       "      <div>0</div><div><img width=\"500\" height=\"500\" style=\"image-rendering:auto; object-fit:cover;\" src=\"data:image/gif;base64,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\"/></div></div></div></td><td style=\"padding:1px;\"><div style=\"display:flex; align-items:left;\">\n",
+       "      <div style=\"display:flex; flex-direction:column; align-items:center;\">\n",
+       "      <div>1</div><div><img width=\"500\" height=\"500\" style=\"image-rendering:auto; object-fit:cover;\" src=\"data:image/gif;base64,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\"/></div></div></div></td></tr></table>"
+      ],
+      "text/plain": [
+       "<IPython.core.display.HTML object>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "\n",
-    "mediapy.show_videos(frames, fps=15, width=500, height=500, columns=2, codec='gif')"
+    "mediapy.show_videos(frames, fps=10, width=500, height=500, columns=2, codec='gif')"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "gpudriveenv",
+   "display_name": "gpudrive",
    "language": "python",
    "name": "python3"
   },
@@ -189,7 +231,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.11"
+   "version": "3.11.9"
   }
  },
  "nbformat": 4,
diff --git a/gpudrive/datatypes/observation.py b/gpudrive/datatypes/observation.py
index fefc0bff5..8f4208307 100644
--- a/gpudrive/datatypes/observation.py
+++ b/gpudrive/datatypes/observation.py
@@ -118,6 +118,7 @@ def __init__(self, abs_self_obs_tensor: torch.Tensor):
         self.pos_x = abs_self_obs_tensor[:, :, 0]
         self.pos_y = abs_self_obs_tensor[:, :, 1]
         self.pos_z = abs_self_obs_tensor[:, :, 2]
+        self.pos_xy = abs_self_obs_tensor[:, :, :2]
         self.rotation_as_quaternion = abs_self_obs_tensor[:, :, 3:7]
         self.rotation_angle = abs_self_obs_tensor[:, :, 7]
         self.goal_x = abs_self_obs_tensor[:, :, 8]
diff --git a/gpudrive/datatypes/trajectory.py b/gpudrive/datatypes/trajectory.py
index ae1571735..92541571b 100644
--- a/gpudrive/datatypes/trajectory.py
+++ b/gpudrive/datatypes/trajectory.py
@@ -5,6 +5,39 @@
 TRAJ_LEN = 91  # Length of the logged trajectory
 
 
+def to_local_frame(
+    global_pos_xy: torch.Tensor,
+    ego_pos: torch.Tensor,
+    ego_yaw: torch.Tensor,
+    device: str,
+) -> torch.Tensor:
+    """
+    Transform trajectory from global coordinates to ego-centric frame.
+    Args:
+        global_pos_xy: Shape (time_steps, 2) containing x,y coordinates in global frame
+        ego_pos: Shape (2,) containing ego x,y position
+        ego_yaw: Shape (1,) containing ego yaw angle in radians
+    Returns:
+        transformed_trajectory: Shape (time_steps, 2) in ego-centric frame
+    """
+    # Step 1: Translate trajectory to be relative to ego position
+    translated = global_pos_xy - ego_pos
+
+    # Step 2: Rotate trajectory to align with ego orientation
+    # Create rotation matrix
+    cos_yaw = torch.cos(ego_yaw).to(device)
+    sin_yaw = torch.sin(ego_yaw).to(device)
+    rotation_matrix = torch.tensor(
+        [[cos_yaw, sin_yaw], [-sin_yaw, cos_yaw]]
+    ).to(device)
+
+    # Apply rotation matrix to the translated trajectory
+    # We need to transpose rotation_matrix for batch matrix multiplication
+    transformed_trajectory = torch.matmul(translated, rotation_matrix.T)
+
+    return transformed_trajectory
+
+
 @dataclass
 class LogTrajectory:
     """A class to represent the logged human trajectories. Initialized from `expert_trajectory_tensor` (src/bindings.cpp).
@@ -28,15 +61,23 @@ def __init__(
         self.vel_xy = raw_logs[:, :, 2 * TRAJ_LEN : 4 * TRAJ_LEN].view(
             num_worlds, max_agents, TRAJ_LEN, -1
         )
-        self.yaw = raw_logs[:, :, 4 * TRAJ_LEN: 5 * TRAJ_LEN].view(
+        self.yaw = raw_logs[:, :, 4 * TRAJ_LEN : 5 * TRAJ_LEN].view(
             num_worlds, max_agents, TRAJ_LEN, -1
         )
-        self.valids = raw_logs[:, :, 5 * TRAJ_LEN:6 * TRAJ_LEN].view(
-            num_worlds, max_agents, TRAJ_LEN, -1
-        ).to(torch.int32)
-        self.inferred_actions = raw_logs[:, :, 6 * TRAJ_LEN: 16 * TRAJ_LEN].view(
-            num_worlds, max_agents, TRAJ_LEN, -1
+        self.valids = (
+            raw_logs[:, :, 5 * TRAJ_LEN : 6 * TRAJ_LEN]
+            .view(num_worlds, max_agents, TRAJ_LEN, -1)
+            .to(torch.int32)
         )
+        self.inferred_actions = raw_logs[
+            :, :, 6 * TRAJ_LEN : 16 * TRAJ_LEN
+        ].view(num_worlds, max_agents, TRAJ_LEN, -1)
+
+        # Zero-out invalid timesteps
+        self.pos_xy = self.pos_xy * self.valids
+        self.vel_xy = self.vel_xy * self.valids
+        self.yaw = self.yaw * self.valids
+        self.ref_speed = self.comp_reference_speed()
 
     @classmethod
     def from_tensor(
@@ -50,7 +91,9 @@ def from_tensor(
         """Creates an LogTrajectory from a tensor."""
         if backend == "torch":
             return cls(
-                expert_traj_tensor.to_torch().clone().to(device), num_worlds, max_agents
+                expert_traj_tensor.to_torch().clone().to(device),
+                num_worlds,
+                max_agents,
             )  # Pass the entire tensor
         elif backend == "jax":
             raise NotImplementedError("JAX backend not implemented yet.")
@@ -60,11 +103,18 @@ def restore_mean(self, mean_x, mean_y):
         # Reshape for broadcasting: [num_worlds, agents, time_steps]
         mean_x_reshaped = mean_x.view(-1, 1, 1)
         mean_y_reshaped = mean_y.view(-1, 1, 1)
-        
+
         # Apply to x and y coordinates
         self.pos_xy[:, :, :, 0] += mean_x_reshaped
         self.pos_xy[:, :, :, 1] += mean_y_reshaped
 
+    def comp_reference_speed(self):
+        """Returns the average speed of the trajectory."""
+        return torch.sqrt(
+            self.vel_xy[:, :, :, 0] ** 2 + self.vel_xy[:, :, :, 1] ** 2
+        )
+
+
 @dataclass
 class VBDTrajectory:
     """A class to represent the VBD predicted trajectories.
@@ -76,16 +126,14 @@ class VBDTrajectory:
             position (x, y), heading (yaw), and velocity (vx, vy) for each timestep.
     """
 
-    def __init__(
-        self, vbd_traj_tensor: torch.Tensor
-    ):
+    def __init__(self, vbd_traj_tensor: torch.Tensor):
         """Initializes the VBD trajectory with a tensor."""
         self.pos_x = vbd_traj_tensor[:, :, :, 0]
         self.pos_y = vbd_traj_tensor[:, :, :, 1]
         self.pos_xy = torch.stack([self.pos_x, self.pos_y], dim=3)
         self.yaw = vbd_traj_tensor[:, :, :, 2]
         self.vel_x = vbd_traj_tensor[:, :, :, 3]
-        self.vel_y = vbd_traj_tensor[:, :, :, 4] 
+        self.vel_y = vbd_traj_tensor[:, :, :, 4]
 
     @classmethod
     def from_tensor(
@@ -105,7 +153,7 @@ def from_tensor(
     #     # Reshape for broadcasting
     #     mean_x_reshaped = mean_x.view(-1, 1, 1)
     #     mean_y_reshaped = mean_y.view(-1, 1, 1)
-        
+
     #     # Apply to x and y coordinates
     #     self.trajectories[..., 0] += mean_x_reshaped
-    #     self.trajectories[..., 1] += mean_y_reshaped
\ No newline at end of file
+    #     self.trajectories[..., 1] += mean_y_reshaped
diff --git a/gpudrive/env/base_env.py b/gpudrive/env/base_env.py
index bea58ac75..e6ce32886 100755
--- a/gpudrive/env/base_env.py
+++ b/gpudrive/env/base_env.py
@@ -62,7 +62,7 @@ def _set_reward_params(self):
         if (
             self.config.reward_type == "sparse_on_goal_achieved"
             or self.config.reward_type == "weighted_combination"
-            or self.config.reward_type == "distance_to_logs"
+            or self.config.reward_type == "follow_waypoints"
             or self.config.reward_type == "reward_conditioned"
         ):
             reward_params.rewardType = (
diff --git a/gpudrive/env/config.py b/gpudrive/env/config.py
index 8df19bd05..186aca52c 100755
--- a/gpudrive/env/config.py
+++ b/gpudrive/env/config.py
@@ -3,7 +3,7 @@
 
 from dataclasses import dataclass
 from enum import Enum
-from typing import Tuple, Optional
+from typing import Tuple, Optional, Union
 import torch
 
 import madrona_gpudrive
@@ -55,7 +55,7 @@ class EnvConfig:
     # Action space settings (if discretized)
     # Classic or Invertible Bicycle dynamics model
     steer_actions: torch.Tensor = torch.round(
-        torch.linspace(-torch.pi, torch.pi, 13), decimals=3
+        torch.linspace(-torch.pi / 3, torch.pi / 3, 13), decimals=3
     )
     accel_actions: torch.Tensor = torch.round(
         torch.linspace(-4.0, 4.0, 7), decimals=3
@@ -86,31 +86,53 @@ class EnvConfig:
     collision_behavior: str = "ignore"  # Options: "remove", "stop", "ignore"
 
     # Scene configuration
-    remove_non_vehicles: bool = True  # Remove non-vehicle entities from scene
+    remove_non_vehicles: bool = False  # Remove non-vehicle entities from scene
 
     # Initialization steps: Number of steps to take before the episode starts
     init_steps: int = 0
 
     # Goal behavior settings
-    goal_behavior: str = "remove"  # Options: "stop", "ignore", "remove"
-    add_goal_state: bool = False  # Add goal state to the scene
+    goal_behavior: str = "ignore"  # Options: "stop", "ignore", "remove"
+
+    # Reference points settings
+    add_reference_speed: bool = (
+        False  # Include reference speed in observations
+    )
+    add_reference_path: bool = False
+    prob_reference_dropout: float = (
+        0.0  # Probability of dropping reference points
+    )
+    min_reference_points: int = 1  # Minimum number of reference points
 
     # Reward settings
     reward_type: str = "sparse_on_goal_achieved"
-    # Alternatively, "weighted_combination", "distance_to_logs", "distance_to_vdb_trajs", "reward_conditioned"
+    # Alternatively, "weighted_combination", "follow_waypoints", "distance_to_vdb_trajs", "reward_conditioned"
 
+    # If reward_type is "follow_waypoints", the following parameters are used
+    waypoint_sample_interval: int = 1  # Interval for sampling waypoints
+    waypoint_distance_scale: float = (
+        0.01  # Importance of distance to waypoints
+    )
+    speed_distance_scale: float = 0.0
+    jerk_smoothness_scale: float = 0.0
+
+    # If reward_type is "reward_conditioned", the following parameters are used
     # Weights for the reward components
     collision_weight: float = 0.0
     goal_achieved_weight: float = 1.0
     off_road_weight: float = 0.0
 
     condition_mode: str = "random"  # Options: "random", "fixed", "preset"
+    # If condition_mode is "fixed", set the agent weights here
+    agent_type: Optional[Union[str, torch.Tensor]] = torch.Tensor(
+        [-0.75, 1.0, -0.75]
+    )  # weights for collision, goal_achieved, off_road
 
     # Define upper and lower bounds for reward components if using reward_conditioned
     collision_weight_lb: float = -1.0
     collision_weight_ub: float = 0.0
     goal_achieved_weight_lb: float = 1.0
-    goal_achieved_weight_ub: float = 2.0
+    goal_achieved_weight_ub: float = 3.0
     off_road_weight_lb: float = -1.0
     off_road_weight_ub: float = 0.0
 
@@ -137,9 +159,7 @@ class EnvConfig:
     agent_size_scale: float = madrona_gpudrive.vehicleScale
 
     # Initialization mode
-    init_mode: str = (
-        "all_non_trivial"  # Options: all_non_trivial, all_objects, all_valid, womd_tracks_to_predict
-    )
+    init_mode: str = "all_non_trivial"  # Options: all_non_trivial, all_objects, all_valid, womd_tracks_to_predict
 
     # VBD model settings
     use_vbd: bool = False
diff --git a/gpudrive/env/constants.py b/gpudrive/env/constants.py
index 76562a903..f457cf223 100644
--- a/gpudrive/env/constants.py
+++ b/gpudrive/env/constants.py
@@ -13,6 +13,8 @@
 MAX_REL_AGENT_POS = 1000
 MAX_ORIENTATION_RAD = 2 * np.pi
 
+MAX_REF_POINT = 1000
+
 # Road graph constants
 MIN_RG_COORD = -1000
 MAX_RG_COORD = 1000
@@ -20,7 +22,7 @@
 MAX_ROAD_SCALE = 100
 
 # Feature shape constants
-EGO_FEAT_DIM = 6 # Ego state base fields
+EGO_FEAT_DIM = 6  # Ego state base fields
 PARTNER_FEAT_DIM = 6
 ROAD_GRAPH_FEAT_DIM = 13
 
@@ -30,3 +32,9 @@
 # BEV observation constants
 BEV_RASTERIZATION_RESOLUTION = 200
 NUM_MADRONA_ENTITY_TYPES = 11
+
+# Action values
+MAX_ACTION_VALUE = 4.0
+
+# Invalid points
+INVALID_ID = -1.0
diff --git a/gpudrive/env/env_puffer.py b/gpudrive/env/env_puffer.py
index 7499f878a..630b26b19 100644
--- a/gpudrive/env/env_puffer.py
+++ b/gpudrive/env/env_puffer.py
@@ -10,6 +10,7 @@
 from gpudrive.env.env_torch import GPUDriveTorchEnv
 from gpudrive.datatypes.observation import (
     LocalEgoState,
+    GlobalEgoState,
 )
 
 from gpudrive.visualize.utils import img_from_fig
@@ -18,6 +19,133 @@
 from pufferlib.environment import PufferEnv
 from gpudrive import GPU_DRIVE_DATA_DIR
 
+"""Metrics from
+    https://github.com/waymo-research/waymo-open-dataset/blob/master/src/waymo_open_dataset/wdl_limited/sim_agents_metrics/trajectory_features.py
+    implemented using numpy instead of tensorflow.
+"""
+
+
+def compute_displacement_error_np(pred_x, pred_y, ref_x, ref_y):
+    """NumPy version of compute_displacement_error function.
+
+    Computes displacement error (in x,y) w.r.t. a reference trajectory.
+
+    Args:
+        pred_x: The x-component of the predicted trajectories.
+        pred_y: The y-component of the predicted trajectories.
+        ref_x: The x-component of the reference trajectories.
+        ref_y: The y-component of the reference trajectories.
+
+    Returns:
+        A float array with the same shape as all the arguments, containing
+        the 2D distance between the predicted trajectories and the reference
+        trajectories.
+    """
+    # Stack coordinates along a new axis
+    pred_xy = np.stack([pred_x, pred_y], axis=-1)
+    ref_xy = np.stack([ref_x, ref_y], axis=-1)
+
+    # Calculate Euclidean distance
+    return np.linalg.norm(pred_xy - ref_xy, ord=2, axis=-1)
+
+
+def central_diff_np(t, pad_value):
+    """NumPy version of central_diff function.
+
+    Computes central difference along the last axis.
+    """
+    # Check if input is at least length 3 (needed for central diff)
+    if t.shape[-1] < 3:
+        result = np.full_like(t, pad_value)
+        return result
+
+    # Create proper padding tensors
+    pad_shape = t.shape[:-1] + (1,)
+    pad_array = np.full(pad_shape, pad_value)
+
+    # Compute central difference for middle elements
+    diff_t = (t[..., 2:] - t[..., :-2]) / 2
+
+    return np.concatenate([pad_array, diff_t, pad_array], axis=-1)
+
+
+def central_logical_and_np(t, pad_value):
+    """NumPy version of central_logical_and function."""
+    # Check if input is at least length 3
+    if t.shape[-1] < 3:
+        result = np.full_like(t, pad_value)
+        return result
+
+    pad_shape = t.shape[:-1] + (1,)
+    pad_array = np.full(pad_shape, pad_value)
+    diff_t = np.logical_and(t[..., :-2], t[..., 2:])
+    return np.concatenate([pad_array, diff_t, pad_array], axis=-1)
+
+
+def wrap_angle_np(angle):
+    """Wraps angles in the range [-pi, pi]."""
+    return (angle + np.pi) % (2 * np.pi) - np.pi
+
+
+def compute_kinematic_features_np(x, y, heading, seconds_per_step):
+    """NumPy version of compute_kinematic_features function, for x,y only."""
+    # Compute positions and displacement
+    batch_shape = x.shape[:-1]
+    time_steps = x.shape[-1]
+
+    # For very short trajectories, just return placeholders
+    if time_steps < 3:
+        placeholder = np.full(x.shape, np.nan)
+        return placeholder, placeholder, placeholder, placeholder
+
+    # Linear speed - compute displacement first then magnitude
+    dx = central_diff_np(x, pad_value=np.nan)
+    dy = central_diff_np(y, pad_value=np.nan)
+
+    # Calculate displacement norm directly (avoid reshaping issues)
+    displacements = np.sqrt(dx**2 + dy**2)
+    linear_speed = displacements / seconds_per_step
+
+    # Linear acceleration (scalar)
+    linear_accel = (
+        central_diff_np(linear_speed, pad_value=np.nan) / seconds_per_step
+    )
+
+    # Angular speed and acceleration
+    dh_step = wrap_angle_np(central_diff_np(heading, pad_value=np.nan))
+    angular_speed = dh_step / seconds_per_step
+    angular_accel = (
+        central_diff_np(angular_speed, pad_value=np.nan) / seconds_per_step
+    )
+
+    return linear_speed, linear_accel, angular_speed, angular_accel
+
+
+def compute_kinematic_validity_np(valid):
+    """NumPy version of compute_kinematic_validity function."""
+    speed_validity = central_logical_and_np(valid, pad_value=False)
+    acceleration_validity = central_logical_and_np(
+        speed_validity, pad_value=False
+    )
+    return speed_validity, acceleration_validity
+
+
+def get_state(env, num_worlds):
+    ego_state = GlobalEgoState.from_tensor(
+        env.sim.absolute_self_observation_tensor(),
+        backend=env.backend,
+        device=env.device,
+    )
+    glob_ego_pos_x = ego_state.pos_x
+    glob_ego_pos_y = ego_state.pos_y
+    return (
+        glob_ego_pos_x[:num_worlds, :],
+        glob_ego_pos_y[:num_worlds, :],
+        ego_state.pos_z[:num_worlds, :],
+        ego_state.rotation_angle[:num_worlds, :],
+        ego_state.id[:num_worlds, :],
+    )
+
 
 def env_creator(name="gpudrive", **kwargs):
     return lambda: PufferGPUDrive(**kwargs)
@@ -46,19 +174,28 @@ def __init__(
         norm_obs=True,
         lidar_obs=False,
         bev_obs=False,
-        add_goal_state=False,
+        add_reference_path=False,
+        add_reference_speed=False,
+        prob_reference_dropout=0.0,
         reward_type="weighted_combination",
+        waypoint_distance_scale=0.05,
+        speed_distance_scale=0.0,
+        jerk_smoothness_scale=0.0,
+        condition_mode="random",
         collision_behavior="ignore",
         goal_behavior="remove",
+        init_mode="all_non_trivial",
         collision_weight=-0.5,
         off_road_weight=-0.5,
         goal_achieved_weight=1,
         dist_to_goal_threshold=2.0,
         polyline_reduction_threshold=0.1,
-        remove_non_vehicles=True,
+        remove_non_vehicles=False,
         obs_radius=50.0,
         use_vbd=False,
         vbd_trajectory_weight=0.1,
+        track_realism_metrics=False,
+        track_n_worlds=2,
         render=False,
         render_3d=True,
         render_interval=50,
@@ -67,6 +204,7 @@ def __init__(
         render_format="mp4",
         render_fps=15,
         zoom_radius=50,
+        plot_waypoints=False,
         buf=None,
         **kwargs,
     ):
@@ -90,6 +228,8 @@ def __init__(
         self.collision_weight = collision_weight
         self.off_road_weight = off_road_weight
         self.goal_achieved_weight = goal_achieved_weight
+        self.init_mode = init_mode
+        self.reward_type = reward_type
 
         self.render = render
         self.render_interval = render_interval
@@ -98,11 +238,14 @@ def __init__(
         self.render_format = render_format
         self.render_fps = render_fps
         self.zoom_radius = zoom_radius
+        self.plot_waypoints = plot_waypoints
+        self.track_realism_metrics = track_realism_metrics
+        self.track_n_worlds = track_n_worlds
 
         # VBD
         self.vbd_trajectory_weight = vbd_trajectory_weight
         self.use_vbd = use_vbd
-        
+
         # Total number of agents across envs, including padding
         self.total_agents = self.max_cont_agents_per_env * self.num_worlds
 
@@ -116,12 +259,19 @@ def __init__(
             road_map_obs=road_map_obs,
             partner_obs=partner_obs,
             reward_type=reward_type,
+            waypoint_distance_scale=waypoint_distance_scale,
+            speed_distance_scale=speed_distance_scale,
+            jerk_smoothness_scale=jerk_smoothness_scale,
+            condition_mode=condition_mode,
             norm_obs=norm_obs,
             bev_obs=bev_obs,
-            add_goal_state=add_goal_state,
+            add_reference_path=add_reference_path,
+            add_reference_speed=add_reference_speed,
+            prob_reference_dropout=prob_reference_dropout,
             dynamics_model=dynamics_model,
             collision_behavior=collision_behavior,
             goal_behavior=goal_behavior,
+            init_mode=init_mode,
             dist_to_goal_threshold=dist_to_goal_threshold,
             polyline_reduction_threshold=polyline_reduction_threshold,
             remove_non_vehicles=remove_non_vehicles,
@@ -129,7 +279,9 @@ def __init__(
             disable_classic_obs=True if lidar_obs else False,
             obs_radius=obs_radius,
             steer_actions=torch.round(
-                torch.linspace(-torch.pi, torch.pi, action_space_steer_disc),
+                torch.linspace(
+                    -torch.pi / 3, torch.pi / 3, action_space_steer_disc
+                ),
                 decimals=3,
             ),
             accel_actions=torch.round(
@@ -180,7 +332,9 @@ def __init__(
         self.was_rendered_in_rollout = {
             env_idx: True for env_idx in range(render_k_scenarios)
         }
+        self.agent_was_rendered_in_rollout = False
         self.frames = {env_idx: [] for env_idx in range(render_k_scenarios)}
+        self.agent_frames = []
 
         self.global_step = 0
         self.iters = 0
@@ -210,6 +364,14 @@ def reset(self, seed=None):
         self.episode_returns = torch.zeros(
             self.num_agents, dtype=torch.float32
         ).to(self.device)
+        self.human_like_rewards = torch.zeros(
+            (self.num_worlds, self.max_cont_agents_per_env),
+            dtype=torch.float32,
+        ).to(self.device)
+        self.internal_rewards = torch.zeros(
+            (self.num_worlds, self.max_cont_agents_per_env),
+            dtype=torch.float32,
+        ).to(self.device)
         self.agent_episode_returns = torch.zeros(
             (self.num_worlds, self.max_cont_agents_per_env),
             dtype=torch.float32,
@@ -230,6 +392,19 @@ def reset(self, seed=None):
             dtype=torch.float32,
         ).to(self.device)
 
+        # Storage for computing realism metrics
+        if self.track_realism_metrics:
+            self.worlds_to_track = self.track_n_worlds
+            self.pos_xyz = torch.zeros(
+                (self.worlds_to_track, self.max_cont_agents_per_env, 91, 3),
+                dtype=torch.float32,
+            ).to(self.device)
+
+            self.headings = torch.zeros(
+                (self.worlds_to_track, self.max_cont_agents_per_env, 91),
+                dtype=torch.float32,
+            ).to(self.device)
+
         return self.observations, []
 
     def step(self, action):
@@ -252,11 +427,21 @@ def step(self, action):
             collision_weight=self.collision_weight,
             off_road_weight=self.off_road_weight,
             goal_achieved_weight=self.goal_achieved_weight,
-            world_time_steps=self.episode_lengths[:, 0].long(),
         )
+
         # Flatten rewards; only keep rewards for controlled agents
         reward_controlled = reward[self.controlled_agent_mask]
-        terminal = self.env.get_dones().bool()
+
+        # Store human-like and internal rewards separately
+        if self.reward_type == "follow_waypoints":
+            self.human_like_rewards[
+                self.live_agent_mask
+            ] += self.env.distance_penalty[self.live_agent_mask]
+            self.internal_rewards[
+                self.live_agent_mask
+            ] += self.env.base_rewards[self.live_agent_mask]
+
+        terminal = self.env.get_dones()
 
         self.render_env() if self.render else None
 
@@ -280,6 +465,21 @@ def step(self, action):
         self.offroad_in_episode += info.off_road
         self.collided_in_episode += info.collided
 
+        if self.track_realism_metrics:  # Log global states
+            batch_indices = torch.arange(
+                self.worlds_to_track, device=self.device
+            )
+            pos_x, pos_y, pos_z, heading, ids = get_state(
+                self.env, num_worlds=self.worlds_to_track
+            )
+            episode_time_steps = (
+                self.episode_lengths[: self.worlds_to_track, 0].long() - 1
+            )
+            self.pos_xyz[
+                batch_indices, :, episode_time_steps, :
+            ] = torch.stack([pos_x, pos_y, pos_z], dim=-1)
+            self.headings[batch_indices, :, episode_time_steps] = heading
+
         # Mask used for buffer
         self.masks = self.live_agent_mask[self.controlled_agent_mask]
 
@@ -299,13 +499,15 @@ def step(self, action):
         # Flatten
         terminal = terminal[self.controlled_agent_mask]
 
-        info_lst = []
+        self.info_lst = []
         if len(done_worlds) > 0:
 
             if self.render:
                 for render_env_idx in range(self.render_k_scenarios):
                     self.log_video_to_wandb(render_env_idx, done_worlds)
 
+                self.log_agent_obs_to_wandb()
+
             # Log episode statistics
             controlled_mask = self.controlled_agent_mask[
                 done_worlds, :
@@ -339,8 +541,13 @@ def step(self, action):
                 / num_finished_agents
             )
 
-            total_collisions = self.collided_in_episode[done_worlds, :].sum()
-            total_off_road = self.offroad_in_episode[done_worlds, :].sum()
+            # Calculate human-likeness metrics for completed episodes
+            human_like_values = self.human_like_rewards[done_worlds, :][
+                controlled_mask
+            ]
+            internal_reward_values = self.internal_rewards[done_worlds, :][
+                controlled_mask
+            ]
 
             agent_episode_returns = self.agent_episode_returns[done_worlds, :][
                 controlled_mask
@@ -352,19 +559,19 @@ def step(self, action):
 
             if num_finished_agents > 0:
                 # fmt: off
-                info_lst.append(
+                self.info_lst.append(
                     {
-                        "mean_episode_reward_per_agent": agent_episode_returns.mean().item(),
-                        "perc_goal_achieved": goal_achieved_rate.item(),
-                        "perc_off_road": off_road_rate.item(),
-                        "perc_veh_collisions": collision_rate.item(),
-                        "total_controlled_agents": self.num_agents,
-                        "control_density": self.num_agents / self.controlled_agent_mask.numel(),
-                        "episode_length": self.episode_lengths[done_worlds, :].mean().item(),
-                        "perc_truncated": num_truncated / num_finished_agents,
-                        "num_completed_episodes": len(done_worlds),
-                        "total_collisions": total_collisions.item(),
-                        "total_off_road": total_off_road.item(),
+                        "metrics/mean_episode_reward_per_agent": agent_episode_returns.mean().item(),
+                        "metrics/mean_imitation_distance": human_like_values.mean().item(),
+                        "metrics/mean_internal_reward": internal_reward_values.mean().item(),
+                        "metrics/perc_goal_achieved": goal_achieved_rate.item(),
+                        "metrics/perc_off_road": off_road_rate.item(),
+                        "metrics/perc_collisions": collision_rate.item(),
+                        "metrics/perc_truncated": num_truncated / num_finished_agents,
+                        "train/num_completed_episodes": len(done_worlds),
+                        "train/total_controlled_agents": self.num_agents,
+                        "train/control_density": self.num_agents / self.controlled_agent_mask.numel(),
+                        "train/episode_length": self.episode_lengths[done_worlds, :].mean().item(),
                     }
                 )
                 # fmt: on
@@ -373,7 +580,9 @@ def step(self, action):
             self.last_obs = self.env.get_obs(self.controlled_agent_mask)
 
             # Asynchronously reset the done worlds and empty storage
-            self.env.reset(env_idx_list=done_worlds_cpu)
+            self.env.reset(
+                env_idx_list=done_worlds_cpu, mask=self.controlled_agent_mask
+            )
             self.episode_returns[done_worlds] = 0
             self.agent_episode_returns[done_worlds, :] = 0
             self.episode_lengths[done_worlds, :] = 0
@@ -384,6 +593,17 @@ def step(self, action):
             ]
             self.offroad_in_episode[done_worlds, :] = 0
             self.collided_in_episode[done_worlds, :] = 0
+            self.human_like_rewards[done_worlds, :] = 0
+            self.internal_rewards[done_worlds, :] = 0
+
+            if self.track_realism_metrics:
+                tracked_done_worlds = done_worlds.tolist() and list(
+                    range(self.worlds_to_track)
+                )
+                if len(tracked_done_worlds):
+                    self.compute_realism_metrics(tracked_done_worlds)
+                    self.pos_xyz[tracked_done_worlds, :] = 0
+                    self.headings[tracked_done_worlds, :] = 0
 
         # Get the next observations. Note that we do this after resetting
         # the worlds so that we always return a fresh observation
@@ -399,7 +619,7 @@ def step(self, action):
             self.rewards,
             self.terminals,
             self.truncations,
-            info_lst,
+            self.info_lst,
         )
 
     def render_env(self):
@@ -428,7 +648,16 @@ def render_env(self):
                 env_indices=envs_to_render,
                 time_steps=time_steps,
                 zoom_radius=self.zoom_radius,
+                plot_waypoints=self.plot_waypoints,
+            )
+
+            agent_obs = self.env.vis.plot_agent_observation(
+                env_idx=0,
+                agent_idx=0,
+                figsize=(10, 10),
+                trajectory=self.env.reference_path[0, :, :].to("cpu"),
             )
+            self.agent_frames.append(img_from_fig(agent_obs))
 
             for idx, render_env_idx in enumerate(envs_to_render):
                 self.frames[render_env_idx].append(
@@ -457,8 +686,28 @@ def clear_render_storage(self):
         """Clear rendering storage."""
         for env_idx in range(self.render_k_scenarios):
             self.frames[env_idx] = []
+            self.agent_frames = []
             self.rendering_in_progress[env_idx] = False
             self.was_rendered_in_rollout[env_idx] = False
+            self.agent_was_rendered_in_rollout = False
+
+    def log_agent_obs_to_wandb(self):
+        """Log agent observation to wandb."""
+
+        frames_array = np.array(self.agent_frames)
+        if frames_array.shape[0] > 10:
+            self.wandb_obj.log(
+                {
+                    f"vis/agent_obs/env_0": wandb.Video(
+                        np.moveaxis(frames_array, -1, 1),
+                        fps=self.render_fps,
+                        format=self.render_format,
+                        caption=f"global step: {self.global_step:,}",
+                    )
+                }
+            )
+            self.agent_frames = []
+            self.agent_was_rendered_in_rollout = True
 
     def log_video_to_wandb(self, render_env_idx, done_worlds):
         """Log arrays as videos to wandb."""
@@ -512,3 +761,131 @@ def log_data_coverage(self):
                 },
                 step=self.global_step,
             )
+
+    def compute_realism_metrics(self, done_worlds):
+        """Compute realism metrics.
+
+        Args:
+            done_worlds: List of indices of the worlds to track.
+        """
+
+        # [worlds, max_cont_agents]
+        control_mask = (
+            self.controlled_agent_mask[done_worlds].detach().cpu().numpy()
+        )
+        # [batch, time, 1]
+        valid_mask = (
+            self.env.log_trajectory.valids[done_worlds]
+            .detach()
+            .cpu()
+            .numpy()[control_mask]
+            .squeeze(-1)
+        ).astype(bool)
+
+        # Take human logs (ground-truth)
+        # Shape: [worlds, max_cont_agents, time, 2] -> [batch, time, 2]
+        ref_pos_xy_np = (
+            self.env.log_trajectory.pos_xy[done_worlds]
+            .detach()
+            .cpu()
+            .numpy()[control_mask]
+        )
+        # Shape: [worlds, max_cont_agents, time, 1] -> [batch, time, 1]
+        ref_headings_np = (
+            self.env.log_trajectory.yaw[done_worlds]
+            .detach()
+            .cpu()
+            .numpy()[control_mask]
+            .squeeze(-1)
+        )
+
+        agent_headings_np = (
+            self.headings[done_worlds].detach().cpu().numpy()[control_mask]
+        )
+        agent_pos_xyz_np = (
+            self.pos_xyz[done_worlds].detach().cpu().numpy()[control_mask]
+        )
+
+        # Extract x, y components (z is not informative)
+        agent_x_np = agent_pos_xyz_np[..., 0]
+        agent_y_np = agent_pos_xyz_np[..., 1]
+
+        ref_x_np = ref_pos_xy_np[..., 0]
+        ref_y_np = ref_pos_xy_np[..., 1]
+
+        # Step duration in seconds
+        seconds_per_step = 0.1  # Assuming 10Hz sampling rate
+
+        # Compute the metrics for agent trajectories
+        (
+            agent_linear_speed,
+            agent_linear_accel,
+            agent_angular_speed,
+            agent_angular_accel,
+        ) = compute_kinematic_features_np(
+            agent_x_np, agent_y_np, agent_headings_np, seconds_per_step
+        )
+
+        # Compute the metrics for reference trajectories
+        (
+            ref_linear_speed,
+            ref_linear_accel,
+            ref_angular_speed,
+            ref_angular_accel,
+        ) = compute_kinematic_features_np(
+            ref_x_np, ref_y_np, ref_headings_np, seconds_per_step
+        )
+
+        # Check which time steps are valid
+        speed_valid, accel_valid = compute_kinematic_validity_np(valid_mask)
+
+        # Calculate absolute diffs between agent and reference trajectories
+        linear_speed_error = np.abs(agent_linear_speed - ref_linear_speed)
+        linear_accel_error = np.abs(agent_linear_accel - ref_linear_accel)
+        angular_speed_error = np.abs(agent_angular_speed - ref_angular_speed)
+        angular_accel_error = np.abs(agent_angular_accel - ref_angular_accel)
+
+        # Calculate displacement error
+        displacement_error = compute_displacement_error_np(
+            agent_x_np, agent_y_np, ref_x_np, ref_y_np
+        )
+
+        # Apply validity masks
+        masked_speed_error = np.ma.array(linear_speed_error, mask=~speed_valid)
+        masked_accel_error = np.ma.array(linear_accel_error, mask=~accel_valid)
+        masked_angular_speed_error = np.ma.array(
+            angular_speed_error, mask=~speed_valid
+        )
+        masked_angular_accel_error = np.ma.array(
+            angular_accel_error, mask=~accel_valid
+        )
+
+        # Compute MAEs
+        mean_linear_speed_error = masked_speed_error.mean()
+        mean_linear_accel_error = masked_accel_error.mean()
+        mean_angular_speed_error = masked_angular_speed_error.mean()
+        mean_angular_accel_error = masked_angular_accel_error.mean()
+
+        self.info_lst.append(
+            {
+                "realism/kinematic_linear_speed_mae": mean_linear_speed_error,
+                "realism/kinematic_linear_accel_mae": mean_linear_accel_error,
+                "realism/kinematic_angular_speed_mae": mean_angular_speed_error,
+                "realism/kinematic_angular_accel_mae": mean_angular_accel_error,
+                "realism/mean_displacement_error": displacement_error[
+                    valid_mask
+                ].mean(),
+                # "realism/kinematic_ref_linear_speed_dist": wandb.Histogram(
+                #     ref_linear_speed[speed_valid]
+                # ),
+                # "realism/kinematic_ref_linear_accel_dist": wandb.Histogram(
+                #     ref_linear_accel[accel_valid]
+                # ),
+                # "realism/kinematic_agent_linear_speed_dist": wandb.Histogram(
+                #     agent_linear_speed[speed_valid]
+                # ),
+                # "realism/kinematic_agent_linear_accel_dist": wandb.Histogram(
+                #     agent_linear_speed[accel_valid]
+                # ),
+            },
+        )
diff --git a/gpudrive/env/env_torch.py b/gpudrive/env/env_torch.py
index 0c48f3254..f57b378f7 100755
--- a/gpudrive/env/env_torch.py
+++ b/gpudrive/env/env_torch.py
@@ -10,7 +10,11 @@
 from gpudrive.env import constants
 from gpudrive.env.config import EnvConfig, RenderConfig
 from gpudrive.env.base_env import GPUDriveGymEnv
-from gpudrive.datatypes.trajectory import LogTrajectory, VBDTrajectory
+from gpudrive.datatypes.trajectory import (
+    LogTrajectory,
+    to_local_frame,
+    VBDTrajectory,
+)
 from gpudrive.datatypes.roadgraph import (
     LocalRoadGraphPoints,
     GlobalRoadGraphPoints,
@@ -55,22 +59,13 @@ def __init__(
         self.render_config = render_config
         self.backend = backend
         self.max_num_agents_in_scene = self.config.max_num_agents_in_scene
+
         self.world_time_steps = torch.zeros(
             self.num_worlds, dtype=torch.short, device=self.device
         )
 
-        # Initialize reward weights tensor if using reward_conditioned
+        # Initialize reward weights tensor to None initially
         self.reward_weights_tensor = None
-        if (
-            hasattr(self.config, "reward_type")
-            and self.config.reward_type == "reward_conditioned"
-        ):
-            # Use default condition_mode from config or fall back to "random"
-            condition_mode = getattr(self.config, "condition_mode", "random")
-            agent_type = getattr(self.config, "agent_type", None)
-            self._set_reward_weights(
-                condition_mode=condition_mode, agent_type=agent_type
-            )
 
         # Environment parameter setup
         params = self._setup_environment_parameters()
@@ -91,7 +86,35 @@ def __init__(
             self.cont_agent_mask.sum().item()
         )
 
+        self.log_trajectory = LogTrajectory.from_tensor(
+            self.sim.expert_trajectory_tensor(),
+            self.num_worlds,
+            self.max_agent_count,
+            backend=self.backend,
+        )
         self.episode_len = self.config.episode_len
+        self.reference_path_length = (
+            self.log_trajectory.pos_xy.shape[2] - self.config.init_steps
+        )
+        self.step_in_world = (
+            self.episode_len - self.sim.steps_remaining_tensor().to_torch()
+        )
+
+        # Now initialize reward weights tensor if using reward_conditioned reward type
+        if (
+            hasattr(self.config, "reward_type")
+            and self.config.reward_type == "reward_conditioned"
+        ):
+            # Use default condition_mode from config or fall back to "random"
+            condition_mode = getattr(self.config, "condition_mode", "random")
+            self.agent_type = getattr(self.config, "agent_type", None)
+            self._set_reward_weights(
+                condition_mode=condition_mode, agent_type=self.agent_type
+            )
+
+        self.previous_action_value_tensor = torch.zeros(
+            (self.num_worlds, self.max_cont_agents, 3), device=self.device
+        )
 
         # Initialize VBD model if used
         self._initialize_vbd()
@@ -112,7 +135,6 @@ def __init__(
 
         self._setup_action_space(action_type)
         self.single_action_space = self.action_space
-
         self.num_agents = self.cont_agent_mask.sum().item()
 
         # Rendering setup
@@ -160,7 +182,7 @@ def _generate_sample_batch(self, init_steps=10):
             self.num_worlds,
             self.max_agent_count,
             backend=self.backend,
-            device=self.device
+            device=self.device,
         )
         log_trajectory.restore_mean(
             mean_x=means_xy[:, 0], mean_y=means_xy[:, 1]
@@ -189,7 +211,7 @@ def _generate_sample_batch(self, init_steps=10):
         metadata = Metadata.from_tensor(
             metadata_tensor=self.sim.metadata_tensor(),
             backend=self.backend,
-            device=self.device
+            device=self.device,
         )
         sample_batch = process_scenario_data(
             max_controlled_agents=self.max_cont_agents,
@@ -204,14 +226,10 @@ def _generate_sample_batch(self, init_steps=10):
         )
         return sample_batch
 
-    def _set_reward_weights(
-        self, env_idx_list=None, condition_mode="random", agent_type=None
-    ):
+    def _set_reward_weights(self, condition_mode="random", agent_type=None):
         """Set agent reward weights for all or specific environments.
 
         Args:
-            env_idx_list: List of environment indices to generate new weights for.
-                        If None, all environments are updated.
             condition_mode: Determines how reward weights are sampled:
                         - "random": Random sampling within bounds (default for training)
                         - "fixed": Use predefined agent_type weights (for testing)
@@ -220,12 +238,13 @@ def _set_reward_weights(
                     If condition_mode is "preset", can be one of: "cautious", "aggressive", "balanced"
                     If condition_mode is "fixed", should be a tensor of shape [3] with weight values
         """
+        # Use weight sharing across environments for memory efficiency
         if self.reward_weights_tensor is None:
             self.reward_weights_tensor = torch.zeros(
-                self.num_worlds,
-                self.max_cont_agents,
+                self.cont_agent_mask.shape[1],  # max_agent_count from mask
                 3,  # collision, goal_achieved, off_road
-                device=self.device,
+                device="cpu",
+                dtype=torch.float16,
             )
 
         # Read bounds for the three reward components
@@ -235,7 +254,8 @@ def _set_reward_weights(
                 self.config.goal_achieved_weight_lb,
                 self.config.off_road_weight_lb,
             ],
-            device=self.device,
+            device="cpu",
+            dtype=torch.float16,
         )
 
         upper_bounds = torch.tensor(
@@ -244,7 +264,8 @@ def _set_reward_weights(
                 self.config.goal_achieved_weight_ub,
                 self.config.off_road_weight_ub,
             ],
-            device=self.device,
+            device="cpu",
+            dtype=torch.float16,
         )
         bounds_range = upper_bounds - lower_bounds
 
@@ -260,6 +281,7 @@ def _set_reward_weights(
                     * 0.9,  # Strong off-road penalty
                 ],
                 device=self.device,
+                dtype=torch.float16,
             ),
             "aggressive": torch.tensor(
                 [
@@ -271,6 +293,7 @@ def _set_reward_weights(
                     * 0.6,  # Moderate off-road penalty
                 ],
                 device=self.device,
+                dtype=torch.float16,
             ),
             "balanced": torch.tensor(
                 [
@@ -291,6 +314,7 @@ def _set_reward_weights(
                     / 2,
                 ],
                 device=self.device,
+                dtype=torch.float16,
             ),
             "risk_taker": torch.tensor(
                 [
@@ -301,20 +325,19 @@ def _set_reward_weights(
                     * 0.4,  # Low off-road penalty
                 ],
                 device=self.device,
+                dtype=torch.float16,
             ),
         }
-
-        # Determine which environments to update
-        if env_idx_list is None:
-            env_idx_list = list(range(self.num_worlds))
-
-        env_indices = torch.tensor(env_idx_list, device=self.device)
-        num_envs = len(env_indices)
+        # Just get the max agents dimension from the controlled agent mask
+        max_agents = self.cont_agent_mask.shape[1]
 
         if condition_mode == "random":
             # Traditional random sampling within bounds
             random_values = torch.rand(
-                num_envs, self.max_cont_agents, 3, device=self.device
+                max_agents,
+                3,
+                device="cpu",
+                dtype=torch.float16,
             )
             scaled_values = lower_bounds + random_values * bounds_range
 
@@ -325,13 +348,9 @@ def _set_reward_weights(
                     f"Unknown agent_type: {agent_type}. Available types: {list(agent_presets.keys())}"
                 )
 
-            # Create a tensor with the preset weights for all agents in the specified environments
+            # CHANGED: Create a tensor with the preset weights for all agents, but no environment dimension
             preset_weights = agent_presets[agent_type]
-            scaled_values = (
-                preset_weights.unsqueeze(0)
-                .unsqueeze(0)
-                .expand(num_envs, self.max_cont_agents, 3)
-            )
+            scaled_values = preset_weights.unsqueeze(0).expand(max_agents, 3)
 
         elif condition_mode == "fixed":
             # Use custom provided weights
@@ -340,23 +359,18 @@ def _set_reward_weights(
                     "For condition_mode='fixed', agent_type must be a tensor of shape [3]"
                 )
 
-            custom_weights = agent_type.to(device=self.device)
+            custom_weights = agent_type.to(device="cpu", dtype=torch.float16)
             if custom_weights.shape != (3,):
                 raise ValueError(
                     f"agent_type tensor must have shape [3], got {custom_weights.shape}"
                 )
 
-            scaled_values = (
-                custom_weights.unsqueeze(0)
-                .unsqueeze(0)
-                .expand(num_envs, self.max_cont_agents, 3)
-            )
+            scaled_values = custom_weights.unsqueeze(0).expand(max_agents, 3)
 
         else:
             raise ValueError(f"Unknown condition_mode: {condition_mode}")
 
-        # Update the weights tensor for the specified environments
-        self.reward_weights_tensor[env_indices.cpu()] = scaled_values
+        self.reward_weights_tensor = scaled_values
 
         return self.reward_weights_tensor
 
@@ -395,12 +409,27 @@ def reset(
                 if condition_mode is not None
                 else getattr(self.config, "condition_mode", "random")
             )
+            use_agent_type = (
+                agent_type if agent_type is not None else self.agent_type
+            )
             self._set_reward_weights(
-                env_idx_list, condition_mode=mode, agent_type=agent_type
+                condition_mode=mode, agent_type=use_agent_type
             )
 
         self.world_time_steps.zero_()
 
+        # Reset smoothness tracking for reset environments
+        if env_idx_list is not None:
+            reset_mask = torch.zeros(
+                self.num_worlds, dtype=torch.bool, device=self.device
+            )
+            reset_mask[torch.tensor(env_idx_list, device=self.device)] = True
+
+            # Zero out only the reset environments
+            self.previous_action_value_tensor[reset_mask] = 0.0
+        else:
+            self.previous_action_value_tensor.zero_()
+
         # Advance the simulator with log playback if warmup steps are provided
         if self.init_steps > 0:
             self.advance_sim_with_log_playback(
@@ -410,8 +439,17 @@ def reset(
 
         return self.get_obs(mask)
 
-    def get_dones(self):
-        return (
+    def get_dones(self, world_time_steps=None):
+        """
+        Returns tensor indicating which agents have terminated.
+
+        Args:
+            world_time_steps: Optional tensor [num_worlds] with current timestep per world.
+
+        Returns:
+            torch.Tensor: Boolean tensor [num_worlds, num_agents] where True indicates done.
+        """
+        terminal = (
             self.sim.done_tensor()
             .to_torch()
             .clone()
@@ -419,6 +457,26 @@ def get_dones(self):
             .to(torch.float)
         )
 
+        if (
+            world_time_steps is not None
+            and self.config.reward_type == "follow_waypoints"
+            and self.config.waypoint_distance_scale > 0.0
+        ):
+            # Find last valid timestep for each agent, this is the ground-truth episode length
+            agent_episode_length = 90 - torch.argmax(
+                self.log_trajectory.valids.squeeze(-1).flip(2), dim=2
+            )
+
+            expanded_time_steps = world_time_steps.unsqueeze(1).expand_as(
+                agent_episode_length
+            )
+            return terminal.bool() & (
+                expanded_time_steps >= agent_episode_length
+            )
+
+        else:
+            return terminal.bool()
+
     def get_infos(self):
         return Info.from_tensor(
             self.sim.info_tensor(),
@@ -429,19 +487,10 @@ def get_infos(self):
     def get_rewards(
         self,
         collision_weight=-0.5,
-        goal_achieved_weight=1.0,
+        goal_achieved_weight=0.0,
         off_road_weight=-0.5,
-        world_time_steps=None,
-        log_distance_weight=0.01,
     ):
-        """Obtain the rewards for the current step.
-        By default, the reward is a weighted combination of the following components:
-        - collision
-        - goal_achieved
-        - off_road
-
-        The importance of each component is determined by the weights.
-        """
+        """Obtain the rewards for the current step."""
 
         # Return the weighted combination of the reward components
         info_tensor = self.sim.info_tensor().to_torch().clone()
@@ -461,22 +510,33 @@ def get_rewards(
                 + goal_achieved_weight * goal_achieved
                 + off_road_weight * off_road
             )
-
             return weighted_rewards
 
         elif self.config.reward_type == "reward_conditioned":
-            # Extract individual weight components from the tensor
-            # Shape: [num_worlds, max_agents, 3]
             if self.reward_weights_tensor is None:
                 self._set_reward_weights()
 
-            # Apply the weights in a vectorized manner
-            # Each index in dimension 2 corresponds to a specific weight:
-            # 0: collision, 1: goal_achieved, 2: off_road
+            # Compute the weighted rewards
+            collision_weights = (
+                self.reward_weights_tensor[:, 0]
+                .expand(self.num_worlds, -1)
+                .to(self.device)
+            )
+            goal_weights = (
+                self.reward_weights_tensor[:, 1]
+                .expand(self.num_worlds, -1)
+                .to(self.device)
+            )
+            off_road_weights = (
+                self.reward_weights_tensor[:, 2]
+                .expand(self.num_worlds, -1)
+                .to(self.device)
+            )
+
             weighted_rewards = (
-                self.reward_weights_tensor[:, :, 0] * collided
-                + self.reward_weights_tensor[:, :, 1] * goal_achieved
-                + self.reward_weights_tensor[:, :, 2] * off_road
+                collision_weights * collided
+                + goal_weights * goal_achieved
+                + off_road_weights * off_road
             )
 
             return weighted_rewards
@@ -523,50 +583,106 @@ def get_rewards(
 
             return weighted_rewards
 
-        elif self.config.reward_type == "distance_to_logs":
-            # Reward based on distance to logs and penalty for collision
-            weighted_rewards = (
-                collision_weight * collided
-                + goal_achieved_weight * goal_achieved
+        elif self.config.reward_type == "follow_waypoints":
+            # Reward based on minimizing distance to time-aligned waypoints plus penalty for collision/off-road
+            self.base_rewards = (
+                goal_achieved_weight * goal_achieved
+                + collision_weight * collided
                 + off_road_weight * off_road
             )
 
-            log_trajectory = LogTrajectory.from_tensor(
-                self.sim.expert_trajectory_tensor(),
-                self.num_worlds,
-                self.max_agent_count,
-                backend=self.backend,
-            )
+            # Extract waypoints (ground truth) at time t
+            step_in_world = self.step_in_world[:, 0, :].squeeze(-1)
+            batch_indices = torch.arange(step_in_world.shape[0])
+            gt_agent_pos = self.log_trajectory.pos_xy[
+                batch_indices, :, step_in_world, :
+            ]
 
-            # Index log positions at current time steps
-            log_traj_pos = []
-            for i in range(self.num_worlds):
-                log_traj_pos.append(
-                    log_trajectory.pos_xy[i, :, world_time_steps[i], :]
-                )
-            log_traj_pos_tensor = torch.stack(log_traj_pos)
+            gt_agent_speed = self.log_trajectory.ref_speed[
+                batch_indices, :, step_in_world
+            ]
+            valid_mask = (
+                self.log_trajectory.valids[batch_indices, :, step_in_world]
+                .squeeze(-1)
+                .bool()
+            )
 
+            # Get actual agent positions
             agent_state = GlobalEgoState.from_tensor(
                 self.sim.absolute_self_observation_tensor(),
                 self.backend,
+                self.device,
             )
 
-            agent_pos = torch.stack(
+            actual_agent_speed = self.sim.self_observation_tensor().to_torch()[
+                :, :, 0
+            ]
+
+            actual_agent_pos = torch.stack(
                 [agent_state.pos_x, agent_state.pos_y], dim=-1
             )
 
-            # compute euclidean distance between agent and logs
-            dist_to_logs = torch.norm(log_traj_pos_tensor - agent_pos, dim=-1)
+            speed_error = (gt_agent_speed - actual_agent_speed) ** 2
 
-            # add reward based on inverse distance to logs
-            weighted_rewards += log_distance_weight * torch.exp(-dist_to_logs)
+            # Compute euclidean distance between agent and waypoints
+            dist_to_waypoints = torch.norm(
+                gt_agent_pos - actual_agent_pos, dim=-1
+            )
 
-            return weighted_rewards
+            # Penalty for jerky movements
+            if hasattr(self, "action_diff"):
+                acceleration_jerk = (
+                    self.action_diff[:, :, 0] ** 2
+                )  # First action component is acceleration
+                steering_jerk = (
+                    self.action_diff[:, :, 1] ** 2
+                )  # Second action component is steering
+
+                self.smoothness_penalty = -(
+                    self.config.jerk_smoothness_scale * acceleration_jerk
+                    + self.config.jerk_smoothness_scale * steering_jerk
+                )
+            else:
+                self.smoothness_penalty = torch.zeros_like(self.base_rewards)
+
+            self.distance_penalty = (
+                -self.config.waypoint_distance_scale
+                * torch.log(dist_to_waypoints + 1.0)
+                - self.config.speed_distance_scale
+                * torch.log(speed_error + 1.0)
+            )
+
+            # Zero-out distance penalty for invalid time steps, that is,
+            # The reference positions have not been observed at every time step
+            # if not observed, we set the distance penalty to 0
+            self.distance_penalty[~valid_mask] = 0.0
+
+            self.distance_penalty += self.smoothness_penalty
+
+            # Apply waypoint mask only if sampling interval is greater than 1
+            if self.config.waypoint_sample_interval > 1:
+                waypoint_mask = (
+                    (step_in_world % self.config.waypoint_sample_interval == 0)
+                    .float()
+                    .unsqueeze(1)
+                )
+                self.distance_penalty = self.distance_penalty * waypoint_mask
+
+            # Combine base rewards with distance penalty
+            rewards = self.base_rewards + self.distance_penalty
+
+            return rewards
 
     def step_dynamics(self, actions):
         if actions is not None:
             self._apply_actions(actions)
         self.sim.step()
+
+        # Update time in worlds
+        self.step_in_world = (
+            self.episode_len - self.sim.steps_remaining_tensor().to_torch()
+        )
+
         not_done_worlds = ~self.get_dones().any(
             dim=1
         )  # Check if any agent in world is done
@@ -585,22 +701,33 @@ def _apply_actions(self, actions):
                 actions = (
                     torch.nan_to_num(actions, nan=0).long().to(self.device)
                 )
-                action_value_tensor = self.action_keys_tensor[actions]
+                self.action_value_tensor = self.action_keys_tensor[actions]
 
             elif actions.dim() == 3:
                 if actions.shape[2] == 1:
                     actions = actions.squeeze(dim=2).to(self.device)
-                    action_value_tensor = self.action_keys_tensor[actions]
+                    self.action_value_tensor = self.action_keys_tensor[actions]
                 else:  # Assuming we are given the actual action values
-                    action_value_tensor = actions.to(self.device)
+                    self.action_value_tensor = actions.to(self.device)
             else:
                 raise ValueError(f"Invalid action shape: {actions.shape}")
 
         else:
-            action_value_tensor = actions.to(self.device)
+            self.action_value_tensor = actions.to(self.device)
+
+        if not hasattr(self, "previous_action_value_tensor"):
+            # Initialize with current actions on first call
+            self.previous_action_value_tensor = (
+                self.action_value_tensor.clone()
+            )
+
+        # Calculate action differences (jerk)
+        self.action_diff = (
+            self.action_value_tensor - self.previous_action_value_tensor
+        )
+        self.previous_action_value_tensor = self.action_value_tensor.clone()
 
-        # Feed the action values to gpudrive
-        self._copy_actions_to_simulator(action_value_tensor)
+        self._copy_actions_to_simulator(self.action_value_tensor)
 
     def _copy_actions_to_simulator(self, actions):
         """Copy the provided actions to the simulator."""
@@ -730,37 +857,248 @@ def _get_ego_state(self, mask=None) -> torch.Tensor:
             ego_state.normalize()
 
         base_fields = [
-            ego_state.speed,
-            ego_state.vehicle_length,
-            ego_state.vehicle_width,
-            ego_state.rel_goal_x,
-            ego_state.rel_goal_y,
-            ego_state.is_collided,
+            ego_state.speed.unsqueeze(-1),
+            ego_state.vehicle_length.unsqueeze(-1),
+            ego_state.vehicle_width.unsqueeze(-1),
+            ego_state.is_collided.unsqueeze(-1),
         ]
 
-        if self.config.add_goal_state:
-            base_fields.append(ego_state.is_goal_reached)
-
         if mask is None:
+
+            base_fields.append(
+                self.previous_action_value_tensor[:, :, :2]
+                / constants.MAX_ACTION_VALUE,  # Previous accel, steering
+            )
+
+            if self.config.add_reference_speed:
+
+                avg_ref_speed = (
+                    self.log_trajectory.clone().ref_speed.mean(axis=-1)
+                    / constants.MAX_SPEED
+                )
+
+                base_fields.append(avg_ref_speed.unsqueeze(-1))
+
+            if self.config.add_reference_path:
+
+                state = (
+                    self.sim.absolute_self_observation_tensor()
+                    .to_torch()
+                    .clone()
+                )
+                global_ego_pos_xy = state[:, :, :2]
+                global_ego_yaw = state[:, :, 7]
+                glob_reference_xy = self.log_trajectory.pos_xy
+                agent_indices = torch.arange(self.max_cont_agents)
+                local_reference_xy = torch.empty_like(glob_reference_xy)
+                valid_timesteps_mask = self.log_trajectory.valids.bool()
+
+                # Transform reference path to be relative to current
+                # agent positions and heading
+                for world_idx in range(self.num_worlds):
+                    for agent_idx in range(self.max_cont_agents):
+                        local_reference_xy[
+                            world_idx, agent_idx, :, :
+                        ] = to_local_frame(
+                            global_pos_xy=glob_reference_xy[
+                                world_idx, agent_idx, :, :
+                            ],
+                            ego_pos=global_ego_pos_xy[world_idx, agent_idx],
+                            ego_yaw=global_ego_yaw[world_idx, agent_idx],
+                            device=self.device,
+                        )
+
+                local_ref_xy_orig = local_reference_xy.clone()
+
+                # Normalize
+                local_reference_xy /= constants.MAX_REF_POINT
+
+                # Set invalid steps to -1.0
+                local_reference_xy[
+                    ~valid_timesteps_mask.expand_as(local_reference_xy)
+                ] = constants.INVALID_ID
+
+                # Provide agent with index to pay attention to through one-hot encoding
+                next_step_in_world = torch.clamp(
+                    self.step_in_world[:, 0, :].squeeze(-1) + 1,
+                    min=0,
+                    max=self.episode_len,
+                )
+                time_one_hot = torch.zeros(
+                    (
+                        self.num_worlds,
+                        self.max_agent_count,
+                        self.reference_path_length,
+                        1,
+                    ),
+                    device=self.device,
+                )
+                time_one_hot[:, :, next_step_in_world, :] = 1.0
+
+                # Make unnormalized reference path available for plotting
+                self.reference_path = torch.cat(
+                    (local_ref_xy_orig, time_one_hot), dim=-1
+                )
+
+                reference_path = torch.cat(
+                    (local_reference_xy, time_one_hot), dim=-1
+                )
+
+                # Flatten the dimensions for stacking
+                base_fields.append(reference_path.flatten(start_dim=2))
+
+                # batch_size = local_reference_xy.shape[0]
+                # num_points = local_reference_xy.shape[1]
+                # time_steps = local_reference_xy.shape[2]
+
+                # Create dropout mask for the time dimension
+                # Shape: [batch_size, num_points, time_steps, 1]
+                # point_dropout_mask = torch.bernoulli(
+                #     torch.ones(
+                #         batch_size,
+                #         num_points,
+                #         time_steps,
+                #         1,
+                #         device=local_reference_xy.device,
+                #     )
+                #     * (1 - self.config.prob_reference_dropout)
+                # ).bool()
+
+                # Apply dropout mask
+                # self.local_reference_xy = (
+                #     local_reference_xy * point_dropout_mask
+                # )
+
             if self.config.reward_type == "reward_conditioned":
+
+                # Create expanded weights for all environments
+                # Expand from [max_agents, 3] to [num_worlds, max_agents]
+                collision_weights = self.reward_weights_tensor[:, 0].expand(
+                    self.num_worlds, -1
+                )
+                goal_weights = self.reward_weights_tensor[:, 1].expand(
+                    self.num_worlds, -1
+                )
+                off_road_weights = self.reward_weights_tensor[:, 2].expand(
+                    self.num_worlds, -1
+                )
+
                 full_fields = base_fields + [
-                    self.reward_weights_tensor[:, :, 0],
-                    self.reward_weights_tensor[:, :, 1],
-                    self.reward_weights_tensor[:, :, 2],
+                    collision_weights,
+                    goal_weights,
+                    off_road_weights,
                 ]
                 return torch.stack(full_fields).permute(1, 2, 0)
             else:
-                return torch.stack(base_fields).permute(1, 2, 0)
+                return torch.cat(base_fields, dim=-1)
         else:
+
+            base_fields.append(
+                self.previous_action_value_tensor[mask][:, :2]
+                / constants.MAX_ACTION_VALUE,  # Previous accel, steering
+            )
+
+            if self.config.add_reference_speed:
+                avg_ref_speed = (
+                    self.log_trajectory.ref_speed[mask].clone().mean(axis=-1)
+                    / constants.MAX_SPEED
+                )
+                base_fields.append(avg_ref_speed.unsqueeze(-1))
+
+            if self.config.add_reference_path:
+
+                # State information
+                state = (
+                    self.sim.absolute_self_observation_tensor()
+                    .to_torch()
+                    .clone()[mask]
+                ).to(self.device)
+                global_ego_pos_xy = state[:, :2]  # Shape: [batch, 2]
+                global_ego_yaw = state[:, 7]  # Shape: [batch]
+                global_reference_xy = self.log_trajectory.pos_xy.clone()[mask]
+                valid_timesteps_mask = self.log_trajectory.valids.bool()[mask]
+                batch_size = global_reference_xy.shape[0]
+                batch_indices = torch.arange(batch_size)
+
+                # Translate all points to a local coordinate frame
+                translated = global_reference_xy - global_ego_pos_xy.unsqueeze(
+                    1
+                )
+
+                # Create rotation matrices for all agents at once
+                cos_yaw = torch.cos(global_ego_yaw)
+                sin_yaw = torch.sin(global_ego_yaw)
+
+                # Create batch of rotation matrices: [batch, 2, 2]
+                rotation_matrices = torch.stack(
+                    [
+                        torch.stack([cos_yaw, sin_yaw], dim=1),
+                        torch.stack([-sin_yaw, cos_yaw], dim=1),
+                    ],
+                    dim=1,
+                )  # Shape: [batch, 2, 2]
+
+                # Apply rotation to all points
+                local_reference_xy = torch.bmm(
+                    rotation_matrices, translated.transpose(1, 2)
+                ).transpose(1, 2)
+
+                local_reference_xy_orig = local_reference_xy.clone()
+
+                # Normalize to [-1, 1]
+                local_reference_xy /= constants.MAX_REF_POINT
+
+                # Set invalid timesteps to -1
+                local_reference_xy[
+                    ~valid_timesteps_mask.expand_as(local_reference_xy)
+                ] = constants.INVALID_ID
+
+                # Provide agent with index to pay attention to through one-hot encoding
+                next_step_in_world = torch.clamp(
+                    self.step_in_world[mask] + 1, min=0, max=self.episode_len
+                )
+                time_one_hot = torch.zeros(
+                    (batch_size, self.reference_path_length, 1),
+                    device=self.device,
+                )
+                time_one_hot[batch_indices, next_step_in_world] = 1.0
+
+                # Stack
+                reference_path = torch.cat(
+                    (local_reference_xy, time_one_hot), dim=2
+                )
+
+                self.reference_path = torch.cat(
+                    (local_reference_xy_orig, time_one_hot), dim=2
+                )
+
+                # Stack
+                base_fields.append(reference_path.flatten(start_dim=1))
+
             if self.config.reward_type == "reward_conditioned":
-                masked_fields = base_fields + [
-                    self.reward_weights_tensor[mask][:, 0],
-                    self.reward_weights_tensor[mask][:, 1],
-                    self.reward_weights_tensor[mask][:, 2],
-                ]
-                return torch.stack(masked_fields).permute(1, 0)
+                # For masked agents, we need to extract agent indices from the mask
+                world_indices, agent_indices = torch.where(mask)
+
+                # Get the reward weights for these specific agents
+                weights_for_masked_agents = self.reward_weights_tensor.to(
+                    self.device
+                )[agent_indices]
+
+                return torch.stack(
+                    [
+                        ego_state.speed,
+                        ego_state.vehicle_length,
+                        ego_state.vehicle_width,
+                        ego_state.rel_goal_x,
+                        ego_state.rel_goal_y,
+                        ego_state.is_collided,
+                        weights_for_masked_agents[:, 0],
+                        weights_for_masked_agents[:, 1],
+                        weights_for_masked_agents[:, 2],
+                    ]
+                ).permute(1, 0)
             else:
-                return torch.stack(base_fields).permute(1, 0)
+                return torch.cat(base_fields, dim=1)
 
     def _get_partner_obs(self, mask=None):
         """Get partner observations."""
@@ -1047,7 +1385,7 @@ def _get_vbd_obs(self, mask=None):
                 )
 
             return ego_vbd_trajectories
-    
+
     def _normalize_vbd_obs(self, trajectories_flat, traj_len):
         """
         Normalize flattened VBD trajectory values to be between -1 and 1, with clipping.
@@ -1113,10 +1451,7 @@ def get_obs(self, mask=None):
         partner_observations = self._get_partner_obs(mask)
         road_map_observations = self._get_road_map_obs(mask)
 
-        if (
-            self.use_vbd
-            and self.config.vbd_in_obs
-        ):
+        if self.use_vbd and self.config.vbd_in_obs:
             # Add ego-centric VBD trajectories
             vbd_observations = self._get_vbd_obs(mask)
 
@@ -1257,21 +1592,31 @@ def swap_data_batch(self, data_batch=None):
         # Reset static scenario data for the visualizer
         self.vis.initialize_static_scenario_data(self.cont_agent_mask)
 
+        # Obtain new log trajectory
+        self.log_trajectory = LogTrajectory.from_tensor(
+            self.sim.expert_trajectory_tensor(),
+            self.num_worlds,
+            self.max_agent_count,
+            backend=self.backend,
+        )
+
     def _load_vbd_trajectories(self):
         """Load VBD trajectories directly from the simulator."""
         if not self.use_vbd:
             return
-            
+
         # Get VBD trajectories from the simulator
         vbd_traj = VBDTrajectory.from_tensor(
             self.sim.vbd_trajectory_tensor(),
             backend=self.backend,
             device=self.device,
         )
-        
-        means_xy = self.sim.world_means_tensor().to_torch()[:, :2].to(self.device)
+
+        means_xy = (
+            self.sim.world_means_tensor().to_torch()[:, :2].to(self.device)
+        )
         vbd_traj.restore_mean(mean_x=means_xy[:, 0], mean_y=means_xy[:, 1])
-        
+
         self.vbd_trajectories = vbd_traj.trajectories
 
     def get_expert_actions(self):
@@ -1371,7 +1716,9 @@ def get_scenario_ids(self):
 if __name__ == "__main__":
 
     env_config = EnvConfig(
-        dynamics_model="delta_local",
+        dynamics_model="classic",
+        reward_type="follow_waypoints",
+        add_reference_path=True,
     )
     render_config = RenderConfig()
 
@@ -1403,42 +1750,57 @@ def get_scenario_ids(self):
     expert_actions, _, _, _ = env.get_expert_actions()
 
     env_idx = 0
+    highlight_agent = torch.where(env.cont_agent_mask[env_idx, :])[0][0].item()
+
+    print(highlight_agent)
 
-    for t in range(91):
-        print(f"Step: {t}")
+    for t in range(10):
+        print(f"Step: {t+1}")
 
         # Step the environment
         expert_actions, _, _, _ = env.get_expert_actions()
-        env.step_dynamics(expert_actions[:, :, t, :])
-
-        highlight_agent = torch.where(env.cont_agent_mask[env_idx, :])[0][
-            -1
-        ].item()
+        env.step_dynamics(expert_actions[:, :, t - 1, :])
 
         # Make video
         sim_states = env.vis.plot_simulator_state(
             env_indices=[env_idx],
             zoom_radius=80,
             time_steps=[t],
-            # center_agent_indices=[highlight_agent],
+            center_agent_indices=[highlight_agent],
+            plot_waypoints=True,
         )
 
         agent_obs = env.vis.plot_agent_observation(
             env_idx=env_idx,
             agent_idx=highlight_agent,
             figsize=(10, 10),
+            trajectory=env.reference_path[highlight_agent, :, :].to(
+                env.device
+            ),
         )
 
         sim_frames.append(img_from_fig(sim_states[0]))
         agent_obs_frames.append(img_from_fig(agent_obs))
 
-        obs = env.get_obs()
+        world_time_steps = (
+            torch.Tensor([t]).repeat((1, env.num_worlds)).long().to(env.device)
+        )
+
+        obs = env.get_obs(control_mask)
         reward = env.get_rewards()
+
+        print(f"A_t: {expert_actions[env_idx, highlight_agent, t, :]}")
+        print(f"R_t+1: {reward[env_idx, highlight_agent]}")
+
         done = env.get_dones()
         info = env.get_infos()
 
-        if done.all().bool():
-            break
+        print(done[env.cont_agent_mask])
+
+        # if done.all().bool():
+        #     # Check resetting behavior
+        #     _ = env.reset(control_mask)
+        #     env.step_dynamics(expert_actions[:, :, 0, :])
 
     env.close()
 
@@ -1446,5 +1808,8 @@ def get_scenario_ids(self):
         "sim_video.gif", np.array(sim_frames), fps=10, codec="gif"
     )
     media.write_video(
-        "obs_video.gif", np.array(agent_obs_frames), fps=10, codec="gif"
+        f"obs_video_env_{env_idx}_agent_{highlight_agent}.gif",
+        np.array(agent_obs_frames),
+        fps=10,
+        codec="gif",
     )
diff --git a/gpudrive/integrations/puffer/ppo.py b/gpudrive/integrations/puffer/ppo.py
index bdc65ed45..fa5a961fd 100644
--- a/gpudrive/integrations/puffer/ppo.py
+++ b/gpudrive/integrations/puffer/ppo.py
@@ -113,7 +113,7 @@ def evaluate(data):
         and data.resample_buffer >= data.config.resample_interval
         and data.config.resample_dataset_size > data.vecenv.num_worlds
     ):
-        print(f"Resampling scenarios at global step {data.global_step}")
+        data.msg = f"Resampling scenarios at global step {data.global_step}"
         data.vecenv.resample_scenario_batch()
         data.resample_buffer = 0
 
@@ -208,17 +208,20 @@ def evaluate(data):
 
         # Store the average across K done worlds across last N rollouts
         # ensure we are logging an unbiased estimate of the performance
-        if sum(data.infos["num_completed_episodes"]) > data.config.log_window:
+        if (
+            sum(data.infos["train/num_completed_episodes"])
+            > data.config.log_window
+        ):
             for k, v in data.infos.items():
                 try:
-                    if "num_completed_episodes" in k:
+                    if "train/num_completed_episodes" in k:
                         data.stats[k] = np.sum(v)
                     else:
                         data.stats[k] = np.mean(v)
 
                     # Log variance for goal and collision metrics
                     if "goal" in k:
-                        data.stats[f"std_{k}"] = np.std(v)
+                        data.stats[f"{k}_std"] = np.std(v)
                 except:
                     continue
 
@@ -383,6 +386,7 @@ def train(data):
             ):
 
                 data.last_log_time = time.perf_counter()
+
                 data.wandb.log(
                     {
                         "performance/controlled_agent_sps": profile.controlled_agent_sps,
@@ -393,14 +397,17 @@ def train(data):
                         "performance/epoch": data.epoch,
                         "performance/uptime": profile.uptime,
                         "train/learning_rate": data.optimizer.param_groups[0]["lr"],
-                        **{f"metrics/{k}": v for k, v in data.stats.items()},
+                        "train/advantages": data.wandb.Histogram(advantages_np),
+                        "train/advantages_var": np.var(advantages_np),
+                        "train/advantages_mean": np.mean(advantages_np),
+                        **{f"{k}": v for k, v in data.stats.items()},
                         **{f"train/{k}": v for k, v in data.losses.items()},
                     }
                 )
 
             if bool(data.stats):
                 data.wandb.log({
-                    **{f"metrics/{k}": v for k, v in data.stats.items()},
+                    **{f"{k}": v for k, v in data.stats.items()},
                 })
 
             # fmt: on
@@ -716,6 +723,7 @@ def save_checkpoint(data, save_checkpoint_to_wandb=True):
         "action_dim": data.uncompiled_policy.action_dim,
         "exp_id": config.exp_id,
         "num_params": config.network["num_parameters"],
+        "config": config,
     }
 
     torch.save(state, model_path)
diff --git a/gpudrive/integrations/vbd/viz/train.gif b/gpudrive/integrations/vbd/viz/train.gif
index 22d8fd30c..7422d8dc6 100644
Binary files a/gpudrive/integrations/vbd/viz/train.gif and b/gpudrive/integrations/vbd/viz/train.gif differ
diff --git a/gpudrive/networks/agents.py b/gpudrive/networks/agents.py
new file mode 100644
index 000000000..23f5ba88d
--- /dev/null
+++ b/gpudrive/networks/agents.py
@@ -0,0 +1,349 @@
+import torch
+import torch.nn as nn
+
+import numpy as np
+
+from torch.distributions.categorical import Categorical
+
+import madrona_gpudrive
+from gpudrive.env import constants
+
+TOP_K_ROAD_POINTS = madrona_gpudrive.kMaxAgentMapObservationsCount
+
+
+def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
+    torch.nn.init.orthogonal_(layer.weight, std)
+    torch.nn.init.constant_(layer.bias, bias_const)
+    return layer
+
+
+class Agent(nn.Module):
+    """
+    Actor-Critic agent with shared embedding networks and separate actor and critic heads.
+    Expects a single observation vector as input.
+    """
+
+    def __init__(
+        self,
+        config,
+        embed_dim,
+        action_dim,
+        act_func="tanh",
+        dropout=0.00,
+        top_k=3,  # Max pooling features to keep
+    ):
+        super().__init__()
+
+        self.config = config
+        self.act_func = nn.Tanh() if act_func == "tanh" else nn.ReLU()
+        self.dropout = dropout
+        self.action_dim = action_dim
+        self.top_k = top_k
+
+        # Indices for unpacking the observation modalities
+        self.ego_state_idx = (
+            9
+            if self.config["reward_type"] == "reward_conditioned"
+            else constants.EGO_FEAT_DIM
+        )
+        if self.config[
+            "add_reference_path"
+        ]:  # Every agent receives a reference path
+            # NOTE: Hardcoded to 91 for now
+            self.ego_state_idx += 91 * 3
+
+        if self.config["add_reference_speed"]:
+            self.ego_state_idx += 1
+        self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount
+        self.max_observable_agents = self.max_controlled_agents - 1
+        self.partner_obs_idx = self.ego_state_idx + (
+            constants.PARTNER_FEAT_DIM * self.max_observable_agents
+        )
+
+        # Shared embedding networks for both actor and critic
+        self.ego_embed = nn.Sequential(
+            layer_init(nn.Linear(self.ego_state_idx, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        self.partner_embed = nn.Sequential(
+            layer_init(nn.Linear(constants.PARTNER_FEAT_DIM, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        self.road_map_embed = nn.Sequential(
+            layer_init(nn.Linear(constants.ROAD_GRAPH_FEAT_DIM, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        # Critic network
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear((2 * top_k + 1) * embed_dim, 32)),
+            nn.LayerNorm(32),
+            self.act_func,
+            layer_init(nn.Linear(32, 1), std=1.0),
+        )
+
+        # Actor network
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear((2 * top_k + 1) * embed_dim, 64)),
+            nn.LayerNorm(64),
+            self.act_func,
+            layer_init(nn.Linear(64, action_dim), std=0.01),
+        )
+
+    def forward(self, x, action=None):
+        """Forward pass through the network.
+        Args:
+            x: Flattened observation vector of size [B, F].
+            action (Optional): Actions to take of size [B, 1].
+                If None, a new actions are sampled.
+        """
+        # Unpack into modalities
+        ego_state, partner_obs, road_graph = self.unpack_obs(x)
+
+        # Use shared embedding networks for both actor and critic
+        ego_embed = self.ego_embed(ego_state)
+        partner_embed = self.partner_embed(partner_obs)
+        road_embed = self.road_map_embed(road_graph)
+
+        # Take top k features from partner and road embeddings
+        partner_max_pool = torch.topk(partner_embed, k=self.top_k, dim=1)[
+            0
+        ].flatten(
+            start_dim=1
+        )  # partner_embed.max(dim=1)
+        road_max_pool = torch.topk(road_embed, k=self.top_k, dim=1)[0].flatten(
+            start_dim=1
+        )
+
+        # Concatenate the embeddings
+        z = torch.cat([ego_embed, partner_max_pool, road_max_pool], dim=-1)
+
+        # Pass to the actor and critic networks
+        logits = self.actor(z)
+        probs = Categorical(logits=logits)
+
+        if action is None:
+            action = probs.sample()
+        else:
+            # Reshape action from [B, 1] to [B] to match what Categorical expects
+            action = action.squeeze(-1)
+
+        return (
+            action,
+            probs.log_prob(action),
+            probs.entropy(),
+            self.critic(z),
+        )
+
+    def unpack_obs(self, obs_flat):
+        """Unpack the flattened observation into the ego state, visible simulator state."""
+
+        ego_state = obs_flat[:, : self.ego_state_idx]
+        partner_obs = obs_flat[:, self.ego_state_idx : self.partner_obs_idx]
+        roadgraph_obs = obs_flat[:, self.partner_obs_idx :]
+
+        road_objects = partner_obs.view(
+            -1, self.max_observable_agents, constants.PARTNER_FEAT_DIM
+        )
+        road_graph = roadgraph_obs.view(
+            -1, TOP_K_ROAD_POINTS, constants.ROAD_GRAPH_FEAT_DIM
+        )
+
+        return ego_state, road_objects, road_graph
+
+
+class SeparateActorCriticAgent(nn.Module):
+    """ "
+    Actor-Critic agent with separate actor and critic networks.
+    Expects a single observation vector as input.
+    """
+
+    def __init__(
+        self,
+        config,
+        embed_dim,
+        action_dim,
+        act_func="tanh",
+        dropout=0.00,
+    ):
+        super().__init__()
+
+        self.config = config
+        self.act_func = nn.Tanh() if act_func == "tanh" else nn.ReLU()
+        self.dropout = dropout
+        self.action_dim = action_dim
+
+        # Indices for unpacking the observation modalities
+        self.ego_state_idx = (
+            9
+            if self.config["reward_type"] == "reward_conditioned"
+            else constants.EGO_FEAT_DIM
+        )
+        if self.config[
+            "add_reference_path"
+        ]:  # Every agent receives a reference path
+            self.ego_state_idx += 91 * 2
+
+        self.max_controlled_agents = madrona_gpudrive.kMaxAgentCount
+        self.max_observable_agents = self.max_controlled_agents - 1
+        self.partner_obs_idx = self.ego_state_idx + (
+            constants.PARTNER_FEAT_DIM * self.max_observable_agents
+        )
+
+        # Actor's embedding networks
+        self.actor_ego_embed = nn.Sequential(
+            layer_init(nn.Linear(self.ego_state_idx, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        self.actor_partner_embed = nn.Sequential(
+            layer_init(nn.Linear(constants.PARTNER_FEAT_DIM, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        self.actor_road_map_embed = nn.Sequential(
+            layer_init(nn.Linear(constants.ROAD_GRAPH_FEAT_DIM, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        # Critic's embedding networks
+        self.critic_ego_embed = nn.Sequential(
+            layer_init(nn.Linear(self.ego_state_idx, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        self.critic_partner_embed = nn.Sequential(
+            layer_init(nn.Linear(constants.PARTNER_FEAT_DIM, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        self.critic_road_map_embed = nn.Sequential(
+            layer_init(nn.Linear(constants.ROAD_GRAPH_FEAT_DIM, embed_dim)),
+            nn.LayerNorm(embed_dim),
+            self.act_func,
+            nn.Dropout(self.dropout),
+            layer_init(nn.Linear(embed_dim, embed_dim)),
+        )
+
+        # Critic network
+        self.critic = nn.Sequential(
+            layer_init(nn.Linear(3 * embed_dim, 32)),
+            nn.LayerNorm(32),
+            self.act_func,
+            layer_init(
+                nn.Linear(32, 1), std=1.0
+            ),  # Fixed the dimension (was 32)
+        )
+
+        # Actor network
+        self.actor = nn.Sequential(
+            layer_init(nn.Linear(3 * embed_dim, 64)),
+            nn.LayerNorm(64),
+            self.act_func,
+            layer_init(nn.Linear(64, action_dim), std=0.01),
+        )
+
+    def get_value(self, x):
+        # Unpack into modalities
+        ego_state, partner_obs, road_graph = self.unpack_obs(x)
+
+        # Embed each modality using critic's embedding networks
+        critic_ego_embed = self.critic_ego_embed(ego_state)
+        critic_partner_embed = self.critic_partner_embed(partner_obs)
+        critic_road_embed = self.critic_road_map_embed(road_graph)
+
+        # Concatenate the embeddings
+        critic_x = torch.cat(
+            [critic_ego_embed, critic_partner_embed, critic_road_embed], dim=-1
+        )
+
+        return self.critic(critic_x)
+
+    def forward(self, x, action=None):
+        """Forward pass through the network.
+        Args:
+            x: Flattened observation vector of size [B, F].
+            action (Optional): Actions to take of size [B, 1].
+                If None, a new actions are sampled.
+        """
+        # Unpack into modalities
+        ego_state, partner_obs, road_graph = self.unpack_obs(x)
+
+        actor_ego_embed = self.actor_ego_embed(ego_state)
+        actor_partner_embed, _ = self.actor_partner_embed(partner_obs).max(
+            dim=1
+        )
+        actor_road_embed, _ = self.actor_road_map_embed(road_graph).max(dim=1)
+        actor_z = torch.cat(
+            [actor_ego_embed, actor_partner_embed, actor_road_embed], dim=-1
+        )
+
+        critic_ego_embed = self.critic_ego_embed(ego_state)
+        critic_partner_embed, _ = self.critic_partner_embed(partner_obs).max(
+            dim=1
+        )
+        critic_road_embed, _ = self.critic_road_map_embed(road_graph).max(
+            dim=1
+        )
+        critic_z = torch.cat(
+            [critic_ego_embed, critic_partner_embed, critic_road_embed], dim=-1
+        )
+
+        # Pass to the actor and critic networks
+        logits = self.actor(actor_z)
+        probs = Categorical(logits=logits)
+
+        if action is None:
+            action = probs.sample()
+        else:
+            # Reshape action from [B, 1] to [B] to match what Categorical expects
+            action = action.squeeze(-1)
+
+        return (
+            action,
+            probs.log_prob(action),
+            probs.entropy(),
+            self.critic(critic_z),
+        )
+
+    def unpack_obs(self, obs_flat):
+        """Unpack the flattened observation into the ego state, visible simulator state."""
+
+        ego_state = obs_flat[:, : self.ego_state_idx]
+        partner_obs = obs_flat[:, self.ego_state_idx : self.partner_obs_idx]
+        roadgraph_obs = obs_flat[:, self.partner_obs_idx :]
+
+        road_objects = partner_obs.view(
+            -1, self.max_observable_agents, constants.PARTNER_FEAT_DIM
+        )
+        road_graph = roadgraph_obs.view(
+            -1, TOP_K_ROAD_POINTS, constants.ROAD_GRAPH_FEAT_DIM
+        )
+
+        return ego_state, road_objects, road_graph
diff --git a/gpudrive/networks/late_fusion.py b/gpudrive/networks/late_fusion.py
index 4da5ad6eb..504c78187 100644
--- a/gpudrive/networks/late_fusion.py
+++ b/gpudrive/networks/late_fusion.py
@@ -94,10 +94,11 @@ def __init__(
         self.num_modes = 3  # Ego, partner, road graph
         self.dropout = dropout
         self.act_func = nn.Tanh() if act_func == "tanh" else nn.GELU()
+        self.vbd_in_obs = False
 
         # Ego state base fields
         self.ego_state_idx = constants.EGO_FEAT_DIM
-        
+
         if config is not None:
             self.config = Box(config)
             if "reward_type" in self.config:
@@ -105,12 +106,11 @@ def __init__(
                     # Agents know their "type", consisting of three weights
                     # that determine the reward (collision, goal, off-road)
                     self.ego_state_idx += 3
-            if "add_goal_state" in self.config:
-                self.ego_state_idx += 1
+            if "add_reference_path" in self.config:
+                self.ego_state_idx += 2 * 91
 
             self.vbd_in_obs = self.config.vbd_in_obs
-            
-        # Indices for unpacking the observation
+
         self.partner_obs_idx = self.ego_state_idx + (
             constants.PARTNER_FEAT_DIM * self.max_observable_agents
         )
diff --git a/gpudrive/utils/checkpoint.py b/gpudrive/utils/checkpoint.py
new file mode 100644
index 000000000..43c2215e3
--- /dev/null
+++ b/gpudrive/utils/checkpoint.py
@@ -0,0 +1,29 @@
+import torch
+
+from gpudrive.networks.late_fusion import NeuralNet
+
+
+def load_policy(path_to_cpt, model_name, device, env_config=None):
+    """Load a policy from a given path."""
+
+    # Load a trained model
+    saved_cpt = torch.load(
+        f=f"{path_to_cpt}/{model_name}.pt",
+        map_location=device,
+        weights_only=False,
+    )
+
+    print(f"Load model from {path_to_cpt}/{model_name}.pt")
+
+    # Create policy architecture from saved checkpoint
+    policy = NeuralNet(
+        input_dim=saved_cpt["model_arch"]["input_dim"],
+        action_dim=saved_cpt["action_dim"],
+        hidden_dim=saved_cpt["model_arch"]["hidden_dim"],
+        config=env_config,
+    ).to(device)
+
+    # Load the model parameters
+    policy.load_state_dict(saved_cpt["parameters"])
+
+    return policy.eval()
diff --git a/gpudrive/utils/compatible.py b/gpudrive/utils/compatible.py
new file mode 100644
index 000000000..e916536c7
--- /dev/null
+++ b/gpudrive/utils/compatible.py
@@ -0,0 +1,203 @@
+from tqdm import tqdm
+import torch
+import pandas as pd
+import numpy as np
+from pathlib import Path
+import mediapy
+
+from gpudrive.utils.config import load_config
+from gpudrive.utils.rollout import rollout
+from gpudrive.utils.env import make_env
+from gpudrive.utils.checkpoint import load_policy
+
+from gpudrive.env.dataset import SceneDataLoader
+
+RESULTS_DIR = "examples/experimental/dataframes"
+
+
+def get_compatibility_scores(
+    env,
+    agent,
+    num_rollouts,
+    device,
+    identifier,
+    deterministic=False,
+    render_sim_state=False,
+    render_every_t=10,
+):
+    """Evaluate policy in the environment."""
+
+    if env.config.reward_type == "reward_conditioned":
+        agent_weights = env.agent_type
+        set_agent_type = True
+
+    print(f"Controlling {env.max_cont_agents} agents per scenario")
+
+    res_dict = {
+        "scene": [],
+        "goal_achieved_count": [],
+        "goal_achieved_frac": [],
+        "collided_count": [],
+        "collided_frac": [],
+        "off_road_count": [],
+        "off_road_frac": [],
+        "other_count": [],
+        "other_frac": [],
+        "num_controlled": [],
+        "episode_lengths": [],
+    }
+
+    pbar = tqdm(
+        range(num_rollouts),
+        desc="Rollout",
+        total=num_rollouts,
+        colour="green",
+    )
+
+    for rollout_idx in pbar:
+        pbar.set_description(
+            f"Rollout {rollout_idx + 1}/{num_rollouts}, Batch size: {env.num_worlds}"
+        )
+
+        # Update simulator with the new batch of data
+        env.swap_data_batch()
+
+        # Rollout policy in the environments
+        (
+            goal_achieved_count,
+            goal_achieved_frac,
+            collided_count,
+            collided_frac,
+            off_road_count,
+            off_road_frac,
+            other_count,
+            other_frac,
+            controlled_agents_in_scene,
+            sim_state_frames,
+            agent_positions,
+            episode_lengths,
+        ) = rollout(
+            env=env,
+            policy=agent,
+            device=device,
+            deterministic=deterministic,
+            render_sim_state=render_sim_state,
+            set_agent_type=set_agent_type,
+            agent_weights=agent_weights,
+            render_every_n_steps=render_every_t,
+        )
+
+        # Get names from env
+        scenario_to_worlds_dict = env.get_env_filenames()
+
+        res_dict["scene"].extend(scenario_to_worlds_dict.values())
+        res_dict["goal_achieved_count"].extend(
+            goal_achieved_count.cpu().numpy()
+        )
+        res_dict["goal_achieved_frac"].extend(goal_achieved_frac.cpu().numpy())
+
+        res_dict["collided_count"].extend(collided_count.cpu().numpy())
+        res_dict["collided_frac"].extend(collided_frac.cpu().numpy())
+
+        res_dict["off_road_count"].extend(off_road_count.cpu().numpy())
+        res_dict["off_road_frac"].extend(off_road_frac.cpu().numpy())
+
+        res_dict["other_count"].extend(other_count.cpu().numpy())
+        res_dict["other_frac"].extend(other_frac.cpu().numpy())
+        res_dict["num_controlled"].extend(
+            controlled_agents_in_scene.cpu().numpy()
+        )
+        res_dict["episode_lengths"].extend(episode_lengths.cpu().numpy())
+
+    # Convert to pandas dataframe
+    df_res = pd.DataFrame(res_dict)
+    df_res["Class"] = identifier
+
+    print(f"\n Evaluated in {df_res.scene.nunique()} unique scenes.")
+
+    return df_res, sim_state_frames, scenario_to_worlds_dict
+
+
+if __name__ == "__main__":
+
+    config = load_config(
+        "/home/emerge/gpudrive/baselines/ppo/config/ppo_population"
+    )
+    EXP_ID = "rew_cond"
+
+    # Set maximum number of agents that policy controls
+
+    # Analysis settings
+    config.data_dir = "data/processed/training"
+    config.environment.num_worlds = 20
+    config.dataset_size = 5000
+    config.sample_with_replacement = True
+    config.num_rollouts = 1
+    config.environment.max_controlled_agents = 64  # 1
+    config.device = "cuda"
+    config.environment.reward_type = "reward_conditioned"
+    config.environment.condition_mode = "fixed"
+    config.environment.agent_type = torch.Tensor([-0.75, 1.0, -0.75])
+    config.render = True
+
+    agent = load_policy(
+        model_name="model_pop_play____R_10000__04_04_18_27_28_702_002500",
+        path_to_cpt="/home/emerge/gpudrive/examples/experimental/models",
+        env_config=config.environment,
+        device=config.device,
+    )
+
+    # Create data loader
+    train_loader = SceneDataLoader(
+        root=config.data_dir,
+        batch_size=config.environment.num_worlds,
+        dataset_size=config.dataset_size,
+        sample_with_replacement=True,
+    )
+
+    env = make_env(config.environment, train_loader, device=config.device)
+
+    # Load sim agent trained through naive self-play
+    # agent = NeuralNet.from_pretrained(
+    #     "daphne-cornelisse/policy_S10_000_02_27"
+    # ).to(config.device)
+
+    df, frames, filenames = get_compatibility_scores(
+        env=env,
+        agent=agent,
+        num_rollouts=config.num_rollouts,
+        device=config.device,
+        identifier=f"{EXP_ID}_{config.environment.max_controlled_agents}",
+        render_sim_state=config.render,
+        render_every_t=2,
+    )
+    df = df.dropna()
+
+    df.to_csv(
+        f"{RESULTS_DIR}/compatibility_scores_{config.environment.max_controlled_agents}.csv",
+        index=False,
+    )
+
+    print(f"goal_achieved: {df['goal_achieved_frac'].mean()*100:.2f}")
+    print(f"collided: {df['collided_frac'].mean()*100:.2f}")
+    print(f"off_road: {df['off_road_frac'].mean()*100:.2f}")
+
+    # Save videos
+    if config.render:
+        sim_state_arrays = {k: np.array(v) for k, v in frames.items()}
+        videos_dir = Path(f"videos/reward_conditioned")
+        videos_dir.mkdir(parents=True, exist_ok=True)
+
+        for env_id, frames in sim_state_arrays.items():
+
+            filename = filenames[env_id]
+            video_path = videos_dir / f"{filename}.gif"
+
+            mediapy.write_video(
+                str(video_path),
+                frames,
+                fps=5,
+                codec="gif",
+            )
+
+            print(f"Saved video to {video_path}")
diff --git a/gpudrive/utils/diversity.py b/gpudrive/utils/diversity.py
new file mode 100644
index 000000000..ea27c287b
--- /dev/null
+++ b/gpudrive/utils/diversity.py
@@ -0,0 +1,476 @@
+import torch
+import dataclasses
+import mediapy
+from huggingface_hub import PyTorchModelHubMixin
+from huggingface_hub import ModelCard
+from gpudrive.networks.late_fusion import NeuralNet
+import matplotlib.pyplot as plt
+from collections import defaultdict
+import random
+import torch
+import random
+import numpy as np
+import pandas as pd
+from tqdm import tqdm
+
+
+from gpudrive.env.config import EnvConfig
+from gpudrive.env.env_torch import GPUDriveTorchEnv
+from gpudrive.visualize.utils import img_from_fig
+from gpudrive.env.dataset import SceneDataLoader
+from gpudrive.utils.config import load_config
+from gpudrive.utils.checkpoint import load_policy
+from gpudrive.utils.rollout import rollout
+
+from PIL import Image
+
+
+def collect_rollout_for_agent_type(
+    env, agent, agent_type_name, agent_weights, device, num_rollouts=5
+):
+    """
+    Collect rollout data for a specific agent type.
+
+    Args:
+        env: The simulation environment
+        agent: The policy to be rolled out
+        agent_type_name: Name identifier for this agent type
+        agent_weights: Tensor of agent weights
+        device: The device to run on
+        num_rollouts: Number of rollouts to perform for this agent type
+
+    Returns:
+        list: List of dictionaries containing rollout data for this agent type
+    """
+    all_data = []
+
+    # Run multiple rollouts for this agent type
+    for i in tqdm(
+        range(num_rollouts), desc=f"Agent: {agent_type_name}", unit="rollout"
+    ):
+        # Run the rollout with the specified agent weights
+        rollout_results = rollout(
+            env=env,
+            policy=agent,
+            device=device,
+            deterministic=False,
+            render_sim_state=False,
+            return_agent_positions=False,
+            return_behavior_metrics=True,
+            set_agent_type=True,
+            agent_weights=agent_weights,
+        )
+
+        # Extract behavioral metrics from rollout (last element of returned tuple)
+        behavior_metrics = rollout_results[-1]
+
+        # Extract goal and collision rates (these are earlier in the returned tuple)
+        goal_achieved_count = rollout_results[0]
+        frac_goal_achieved = rollout_results[1]
+        collided_count = rollout_results[2]
+        frac_collided = rollout_results[3]
+
+        # Store data for this rollout
+        all_data.append(
+            {
+                "agent_type": agent_type_name,
+                "rollout_idx": i,
+                "weights": agent_weights.cpu().tolist(),
+                "entropy": behavior_metrics["entropy"],
+                "logprob": behavior_metrics["logprob"],
+                "actions": behavior_metrics["actions"],
+                "goal_achieved_count": goal_achieved_count,
+                "frac_goal_achieved": frac_goal_achieved,
+                "collided_count": collided_count,
+                "frac_collided": frac_collided,
+            }
+        )
+
+    return all_data
+
+
+def collect_data_for_agent_types(
+    env, agent, agent_configs, device, num_rollouts_per_agent=5
+):
+    """
+    Collect rollout data for all agent types in agent_configs.
+
+    Args:
+        env: The simulation environment
+        agent: The policy to be rolled out
+        agent_configs: Dictionary mapping agent type names to their weight tensors
+        device: The device to run on
+        num_rollouts_per_agent: Number of rollouts to perform for each agent type
+
+    Returns:
+        list: Combined list of dictionaries containing rollout data for all agent types
+    """
+    all_agent_data = []
+
+    # Display overall progress information
+    print(
+        f"Collecting data for {len(agent_configs)} agent types, {num_rollouts_per_agent} rollouts each"
+    )
+
+    # Process each agent type
+    for agent_type_name, agent_weights in agent_configs.items():
+        print(
+            f"\nAgent type: {agent_type_name}, weights: {agent_weights.cpu().tolist()}"
+        )
+
+        # Collect data for this agent type
+        agent_data = collect_rollout_for_agent_type(
+            env=env,
+            agent=agent,
+            agent_type_name=agent_type_name,
+            agent_weights=agent_weights,
+            device=device,
+            num_rollouts=num_rollouts_per_agent,
+        )
+
+        # Add to combined data
+        all_agent_data.extend(agent_data)
+
+    print(f"Completed rollouts for all {len(agent_configs)} agent types")
+    return all_agent_data
+
+
+def create_dataframe_from_rollouts(rollout_data):
+    """
+    Convert rollout data to a pandas DataFrame with the specified columns.
+
+    Args:
+        rollout_data: List of dictionaries containing rollout results
+
+    Returns:
+        pd.DataFrame: DataFrame with agent behavior data
+    """
+    rows = []
+
+    # Create a separate dataframe to store aggregated metrics per rollout
+    rollout_metrics = []
+
+    # Process each rollout
+    for data in rollout_data:
+        agent_type = data["agent_type"]
+        rollout_idx = data["rollout_idx"]
+        weights = data["weights"]
+
+        # Get tensor data
+        entropy = data["entropy"]  # Shape: [num_envs, max_agents, episode_len]
+        logprob = data["logprob"]  # Shape: [num_envs, max_agents, episode_len]
+        actions = data[
+            "actions"
+        ]  # Shape: [num_envs, max_agents, episode_len, action_dim]
+
+        # Get goal and collision metrics
+        goal_achieved_count = data["goal_achieved_count"]
+        frac_goal_achieved = data["frac_goal_achieved"]
+        collided_count = data["collided_count"]
+        frac_collided = data["frac_collided"]
+
+        # Get dimensions
+        num_envs = actions.shape[0]
+        max_agents = actions.shape[1]
+        episode_len = actions.shape[2]
+
+        # Store aggregated metrics for this rollout
+        for env_idx in range(num_envs):
+            rollout_metrics.append(
+                {
+                    "agent_type": agent_type,
+                    "rollout_idx": rollout_idx,
+                    "scenario": env_idx,
+                    "goal_achieved_count": goal_achieved_count[env_idx].item(),
+                    "frac_goal_achieved": frac_goal_achieved[env_idx].item(),
+                    "collided_count": collided_count[env_idx].item(),
+                    "frac_collided": frac_collided[env_idx].item(),
+                    "collision_weight": weights[0],
+                    "goal_weight": weights[1],
+                    "off_road_weight": weights[2],
+                }
+            )
+
+        # Create rows for all non-zero entries
+        for env_idx in range(num_envs):
+            for agent_idx in range(max_agents):
+                for time_step in range(episode_len):
+                    # Skip if no action was taken (all zeros)
+                    action_vec = actions[env_idx, agent_idx, time_step]
+                    if (
+                        torch.all(action_vec == 0)
+                        and entropy[env_idx, agent_idx, time_step] == 0
+                    ):
+                        continue
+
+                    # Add row with specified columns
+                    row = {
+                        "agent_type": agent_type,
+                        "scenario": env_idx,
+                        "agent_idx": agent_idx,  # Keep this in case you need it later
+                        "timestep": time_step,
+                        "entropy": entropy[
+                            env_idx, agent_idx, time_step
+                        ].item(),
+                        "acceleration": action_vec[0].item(),
+                        "steering": action_vec[1].item(),
+                        "logprob": logprob[
+                            env_idx, agent_idx, time_step
+                        ].item(),
+                        "rollout_idx": rollout_idx,
+                        "collision_weight": weights[0],
+                        "goal_weight": weights[1],
+                        "off_road_weight": weights[2],
+                    }
+                    rows.append(row)
+
+    # Create main DataFrame and metrics DataFrame
+    df = pd.DataFrame(rows)
+    metrics_df = pd.DataFrame(rollout_metrics)
+
+    # Print summary
+    print(f"Created DataFrame with {len(df)} rows")
+    print(f"Number of unique agent types: {df['agent_type'].nunique()}")
+    print(f"Number of unique scenarios: {df['scenario'].nunique()}")
+    print(f"Maximum timestep: {df['timestep'].max()}")
+
+    # Print more detailed statistics
+    print("\nRows per agent type:")
+    print(df.groupby("agent_type").size())
+
+    # Print goal and collision statistics
+    print("\nGoal Achievement Rate by Agent Type:")
+    print(metrics_df.groupby("agent_type")["frac_goal_achieved"].mean())
+
+    print("\nCollision Rate by Agent Type:")
+    print(metrics_df.groupby("agent_type")["frac_collided"].mean())
+
+    print("\nSample of DataFrame:")
+    print(df.head())
+
+    # Add the metrics to the main dataframe as a separate attribute
+    df.metrics = metrics_df
+
+    return df
+
+
+def compare_agent_types(df):
+    """
+    Compare different agent types based on their behavior using the updated DataFrame structure.
+
+    Args:
+        df: DataFrame containing agent behavior data with the columns:
+            agent_type, scenario, agent_idx, timestep, entropy, acceleration, steering, etc.
+
+    Returns:
+        dict: Dictionary of analysis results
+    """
+    results = {}
+
+    # 1. Compare acceleration and steering distributions by agent type
+    accel_dist_by_agent = (
+        df.groupby("agent_type")["acceleration"]
+        .value_counts(normalize=True)
+        .unstack()
+        .fillna(0)
+    )
+    results["acceleration_distribution"] = accel_dist_by_agent
+
+    steer_dist_by_agent = (
+        df.groupby("agent_type")["steering"]
+        .value_counts(normalize=True)
+        .unstack()
+        .fillna(0)
+    )
+    results["steering_distribution"] = steer_dist_by_agent
+
+    # 2. Compare entropy (uncertainty) by agent type
+    entropy_by_agent = df.groupby("agent_type")["entropy"].agg(
+        ["mean", "std", "min", "max"]
+    )
+    results["entropy_stats"] = entropy_by_agent
+
+    # 3. Calculate action diversity based on unique combinations of acceleration and steering
+    df["action_combo"] = (
+        df["acceleration"].astype(str) + "_" + df["steering"].astype(str)
+    )
+    df_grouped = (
+        df.groupby(["agent_type", "scenario", "timestep"])["action_combo"]
+        .nunique()
+        .reset_index()
+    )
+    action_diversity = df_grouped.groupby("agent_type")["action_combo"].mean()
+    results["action_diversity"] = action_diversity
+
+    # 4. Calculate additional metrics
+    # Average logprob by agent type (measure of confidence)
+    logprob_by_agent = df.groupby("agent_type")["logprob"].mean()
+    results["avg_logprob"] = logprob_by_agent
+
+    # Distribution of steering and acceleration over time
+    time_series = df.groupby(["agent_type", "timestep"])[
+        ["steering", "acceleration"]
+    ].mean()
+    results["time_series"] = time_series
+
+    # 5. Goal and collision rate analysis
+    try:
+        # Try to load separate metrics file
+        metrics_df = pd.read_csv(
+            "/home/emerge/gpudrive/agent_type_metrics.csv"
+        )
+        goal_rate = metrics_df.groupby("agent_type")[
+            "frac_goal_achieved"
+        ].mean()
+        collision_rate = metrics_df.groupby("agent_type")[
+            "frac_collided"
+        ].mean()
+
+        results["goal_rate"] = goal_rate
+        results["collision_rate"] = collision_rate
+    except Exception as e:
+        print(f"Error loading metrics data: {e}")
+        print("Goal and collision rates won't be included in the results.")
+
+    # Print summary of comparison
+    print("\n=== Agent Type Comparison ===")
+    print("\nPolicy Entropy by Agent Type (higher = more uncertain):")
+    print(entropy_by_agent["mean"].sort_values(ascending=False))
+
+    print("\nAverage Log Probability (higher = more confident):")
+    print(logprob_by_agent)
+
+    # Acceleration and steering tendencies
+    print("\nAverage Acceleration by Agent Type:")
+    print(
+        df.groupby("agent_type")["acceleration"]
+        .mean()
+        .sort_values(ascending=False)
+    )
+
+    print(
+        "\nAverage Steering by Agent Type (absolute value - measures turning intensity):"
+    )
+    print(
+        df.groupby("agent_type")
+        .apply(lambda x: abs(x["steering"]).mean())
+        .sort_values(ascending=False)
+    )
+
+    # Goal and collision rates
+    if "goal_rate" in results:
+        print("\nAverage Goal Achievement Rate by Agent Type:")
+        print(results["goal_rate"].sort_values(ascending=False))
+
+        print("\nAverage Collision Rate by Agent Type:")
+        print(results["collision_rate"].sort_values(ascending=False))
+
+    # Analyze variation across scenarios
+    scenario_variation = (
+        df.groupby(["agent_type", "scenario"])[["acceleration", "steering"]]
+        .mean()
+        .groupby("agent_type")
+        .std()
+    )
+    print("\nVariation Across Scenarios (higher = less consistent behavior):")
+    print(scenario_variation)
+
+    return results
+
+
+if __name__ == "__main__":
+
+    config = load_config(
+        "/home/emerge/gpudrive/baselines/ppo/config/ppo_base_puffer"
+    )
+
+    num_envs = 50
+    device = "cpu"
+    max_agents = 64
+
+    config.environment.reward_type = "reward_conditioned"
+    config.environment.condition_mode = "fixed"
+    config.environment.agent_type = torch.Tensor([-0.2, 1.0, -0.2])
+
+    agent = load_policy(
+        model_name="model_pop_play____R_10000__04_04_18_27_28_702_002500",
+        path_to_cpt="/home/emerge/gpudrive/examples/experimental/models",
+        env_config=config.environment,
+        device=device,
+    )
+
+    # Create data loader
+    train_loader = SceneDataLoader(
+        root="/home/emerge/gpudrive/data/processed/training/",
+        batch_size=num_envs,
+        dataset_size=100,
+        sample_with_replacement=False,
+    )
+
+    # Set params
+    config = config.environment
+    env_config = dataclasses.replace(
+        EnvConfig(),
+        norm_obs=config.norm_obs,
+        dynamics_model=config.dynamics_model,
+        collision_behavior=config.collision_behavior,
+        dist_to_goal_threshold=config.dist_to_goal_threshold,
+        polyline_reduction_threshold=config.polyline_reduction_threshold,
+        remove_non_vehicles=config.remove_non_vehicles,
+        lidar_obs=config.lidar_obs,
+        disable_classic_obs=config.lidar_obs,
+        obs_radius=config.obs_radius,
+        steer_actions=torch.round(
+            torch.linspace(
+                -torch.pi, torch.pi, config.action_space_steer_disc
+            ),
+            decimals=3,
+        ),
+        accel_actions=torch.round(
+            torch.linspace(-4.0, 4.0, config.action_space_accel_disc),
+            decimals=3,
+        ),
+        reward_type=config.reward_type,
+        condition_mode=config.condition_mode,
+        agent_type=config.agent_type,
+    )
+
+    # Make env
+    env = GPUDriveTorchEnv(
+        config=env_config,
+        data_loader=train_loader,
+        max_cont_agents=max_agents,
+        device=device,
+    )
+
+    # Define different agent types to compare
+    agent_configs = {  # Collision, Goal, Off-road
+        "Nominal": torch.tensor([-0.75, 1.0, -0.75], device=device),
+        "Aggressive": torch.tensor([0.0, 2.0, 0.0], device=device),
+        "Risk-averse": torch.tensor([-2.0, 0.5, -2.0], device=device),
+    }
+
+    print(
+        f"Collecting rollout data for all agent types... N = {env.max_cont_agents}"
+    )
+
+    # Collect data for all agent types
+    all_rollout_data = collect_data_for_agent_types(
+        env=env,
+        agent=agent,
+        agent_configs=agent_configs,
+        device=device,
+        num_rollouts_per_agent=3,  # Number of times we rollout in the same scenes
+    )
+
+    # Convert to DataFrame for analysis
+    df = create_dataframe_from_rollouts(all_rollout_data)
+
+    # Analyze agent types
+    comparison_results = compare_agent_types(df)
+
+    # Save the data
+    df.to_csv("agent_type_comparison_data.csv", index=False)
+    df.metrics.to_csv("agent_type_metrics.csv", index=False)
+
+    print("\n Analysis done! Data saved to csv file.")
diff --git a/gpudrive/utils/env.py b/gpudrive/utils/env.py
new file mode 100644
index 000000000..79d656909
--- /dev/null
+++ b/gpudrive/utils/env.py
@@ -0,0 +1,52 @@
+import dataclasses
+import torch
+
+from gpudrive.env.env_torch import GPUDriveTorchEnv
+from gpudrive.env.config import EnvConfig, RenderConfig
+
+
+def make_env(config, train_loader, device="cuda"):
+    """Make the environment with the given config."""
+
+    # Override any default environment settings
+    env_config = dataclasses.replace(
+        EnvConfig(),
+        ego_state=config.ego_state,
+        road_map_obs=config.road_map_obs,
+        partner_obs=config.partner_obs,
+        reward_type=config.reward_type,
+        norm_obs=config.norm_obs,
+        dynamics_model=config.dynamics_model,
+        collision_behavior=config.collision_behavior,
+        dist_to_goal_threshold=config.dist_to_goal_threshold,
+        polyline_reduction_threshold=config.polyline_reduction_threshold,
+        remove_non_vehicles=config.remove_non_vehicles,
+        lidar_obs=config.lidar_obs,
+        disable_classic_obs=True if config.lidar_obs else False,
+        obs_radius=config.obs_radius,
+        steer_actions=torch.round(
+            torch.linspace(
+                -torch.pi, torch.pi, config.action_space_steer_disc
+            ),
+            decimals=3,
+        ),
+        accel_actions=torch.round(
+            torch.linspace(-4.0, 4.0, config.action_space_accel_disc),
+            decimals=3,
+        ),
+        condition_mode=config.condition_mode,
+        agent_type=config.agent_type,
+        init_mode=config.init_mode,
+    )
+
+    render_config = RenderConfig()
+
+    env = GPUDriveTorchEnv(
+        config=env_config,
+        data_loader=train_loader,
+        max_cont_agents=config.max_controlled_agents,
+        device=device,
+        render_config=render_config,
+    )
+
+    return env
diff --git a/gpudrive/utils/generate_sbatch.py b/gpudrive/utils/generate_sbatch.py
index 95850cca3..d4c61e975 100644
--- a/gpudrive/utils/generate_sbatch.py
+++ b/gpudrive/utils/generate_sbatch.py
@@ -62,7 +62,7 @@
 #SBATCH --account={account}
 
 SINGULARITY_IMAGE={singularity_image}
-OVERLAY_FILE=/scratch/{username}/{overlay_file}
+OVERLAY_FILE={overlay_file}
 
 singularity exec --nv --overlay "${{OVERLAY_FILE}}:ro" \
     "${{SINGULARITY_IMAGE}}" \
@@ -243,30 +243,31 @@ def save_script(filename, file_path, fields, params, param_order=None):
 
 if __name__ == "__main__":
 
-    group = "02_24_S10_000"
+    group = "minimal_tiny"
 
     fields = {
-        "time_h": 47,  # Max time per job (job will finish if run is done before)
+        "time_h": 6,  # Max time per job (job will finish if run is done before)
         "num_gpus": 1,  # GPUs per job
         "max_sim_jobs": 30,  # Max jobs at the same time
         "memory": 70,
         "job_name": group,
+        "run_file": "baselines/ppo/ppo_waypoint.py",
     }
     
     hyperparams = {
         "group": [group], # Group name
-        "num_worlds": [800],
-        "resample_scenes": [1], # Yes
-        "k_unique_scenes": [800],
-        "resample_interval": [5_000_000],
-        "total_timesteps": [4_000_000_000],
-        "resample_dataset_size": [10_000],
-        "batch_size": [524288],
-        "minibatch_size": [16384],
-        "update_epochs": [4],
-        "ent_coef": [0.001, 0.003, 0.0001],
+        "num_worlds": [500],
+        "resample_scenes": [0], 
+        "k_unique_scenes": [4],
+        #"resample_interval": [5_000_000],
+        #"resample_dataset_size": [10_000],
+        #"total_timesteps": [3_000_000_000],
+        "batch_size": [262_144],
+        "minibatch_size": [16_384],
+        "waypoint_distance_scale": [0.0, 0.05, 0.1],
+        "ent_coef": [0.001],
+        "vf_coef": [0.5],
         "render": [0],
-        #"seed": [42, 3],
     }
 
     save_script(
@@ -275,30 +276,3 @@ def save_script(filename, file_path, fields, params, param_order=None):
         fields=fields,
         params=hyperparams,
     )
-
-    # hyperparams = {
-    #     "group": [group], # Group name
-    #     "num_worlds": [800],
-    #     "resample_scenes": [1], # Yes
-    #     "k_unique_scenes": [1000], # Sample in batches of 500
-    #     "resample_interval": [2_000_000],
-    #     "total_timesteps": [3_000_000_000],
-    #     "resample_dataset_size": [1000],
-    #     "batch_size": [262_144, 524_288],
-    #     "minibatch_size": [16_384],
-    #     "update_epochs": [2, 4, 5],
-    #     "ent_coef": [0.0001, 0.001, 0.003],
-    #     "learning_rate": [1e-4, 3e-4],
-    #     "gamma": [0.99],
-    #     "render": [0],
-    # }
-
-    # save_script(
-    #     file_path="examples/experimental/sbatch_scripts/",
-    #     filename=f"sbatch_{group}.sh",
-    #     fields=fields,
-    #     params=hyperparams,
-    # )
-
-
-
diff --git a/gpudrive/utils/multi_policy_rollout.py b/gpudrive/utils/multi_policy_rollout.py
deleted file mode 100644
index 20985eaad..000000000
--- a/gpudrive/utils/multi_policy_rollout.py
+++ /dev/null
@@ -1,195 +0,0 @@
-import torch
-import pandas as pd
-from gpudrive.visualize.utils import img_from_fig
-from gpudrive.datatypes.observation import GlobalEgoState
-
-def multi_policy_rollout(
-    env,
-    policies, 
-    device,
-    deterministic: bool = False,
-    render_sim_state: bool = False,
-    render_every_n_steps: int = 1,
-    zoom_radius: int = 100,
-    return_agent_positions: bool = False,
-    center_on_ego: bool = False,
-):
-    """
-    Perform a rollout of multiple policies in the environment.
-
-    Args:
-        env: The simulation environment.
-        policies (dict): Dictionary of policies {policy_name: (policy_function,mask)}.
-        device: The device to execute computations on (CPU/GPU).
-        policy_masks (dict): Dictionary of policy masks {policy_name: mask_tensor}.
-        deterministic (bool): Whether to use deterministic policy actions.
-        return_agent_positions (bool): Whether to return agent positions.
-
-    Returns:
-        policy_metrics: Dictionary of metrics corresponding to policies {policy_name: metrics(dict)}
-            metrics: {
-                'goal_achieved', 'collided', 'off_road', 'off_road_count', 'collided_count', 'goal_achieved_count', 'frac_off_road', 'frac_collided', 'frac_goal_achieved'
-                }
-
-    """
-    
-    # Initialize storage
-    num_worlds = env.num_worlds
-    max_agent_count = env.max_agent_count
-    episode_len = env.config.episode_len
-    sim_state_frames = {env_id: [] for env_id in range(num_worlds)}
-    agent_positions = torch.zeros((num_worlds, max_agent_count, episode_len, 2))
-
-    # Reset environment
-    next_obs = env.reset()
-    policy_metrics = {
-        policy_name: {
-            "goal_achieved": torch.zeros((num_worlds, max_agent_count), device=device),
-            "collided": torch.zeros((num_worlds, max_agent_count), device=device),
-            "off_road": torch.zeros((num_worlds, max_agent_count), device=device),
-        }
-        for policy_name in policies
-    }
-    episode_lengths = torch.zeros(num_worlds)
-    
-    active_worlds = list(range(num_worlds))
-    control_mask = env.cont_agent_mask
-    live_agent_mask = control_mask.clone()
-
-    for time_step in range(episode_len):
-        print(f't: {time_step}')
-
-        policy_live_masks = {name: mask & live_agent_mask for name, (policy_fn,mask) in policies.items()}
-
-
-        actions = {}
-        for policy_name, (policy_fn,policy_mask) in policies.items():
-            live_mask = policy_live_masks[policy_name]
-            if live_mask.any():
-                actions[policy_name], _, _, _ = policy_fn(
-                    next_obs[live_mask], deterministic=deterministic
-                )
-
-        
-        combined_mask = torch.zeros_like(live_agent_mask, dtype=torch.bool)
-        for live_mask in policy_live_masks.values():
-            combined_mask |= live_mask
-        assert torch.all(live_agent_mask == combined_mask), "Live agent mask mismatch!"
-
-        action_template = torch.zeros((num_worlds, max_agent_count), dtype=torch.int64, device=device)
-
-        # Assign actions based on policy masks
-        for policy_name, action in actions.items():
-            live_mask = policy_live_masks[policy_name]
-            if action.numel() > 0:
-                action_template[live_mask] = action.to(dtype=action_template.dtype, device=device)
-
-        # Step environment
-        env.step_dynamics(action_template)
-
-        if render_sim_state and len(active_worlds) > 0:
-                
-                has_live_agent = torch.where(
-                    live_agent_mask[active_worlds, :].sum(axis=1) > 0
-                )[0].tolist()
-
-                if time_step % render_every_n_steps == 0:
-                    if center_on_ego:
-                        agent_indices = torch.argmax(control_mask.to(torch.uint8), dim=1).tolist()
-                    else:
-                        agent_indices = None
-
-                    sim_state_figures = env.vis.plot_simulator_state(
-                        env_indices=has_live_agent,
-                        time_steps=[time_step] * len(has_live_agent),
-                        zoom_radius=zoom_radius,
-                        center_agent_indices=agent_indices,
-                        policy_masks=policies 
-                    )
-                    for idx, env_id in enumerate(has_live_agent):
-                        sim_state_frames[env_id].append(
-                            img_from_fig(sim_state_figures[idx])
-                        )
-
-
-        # Update observations and agent statuses
-        next_obs = env.get_obs()
-        dones = env.get_dones().bool()
-        infos = env.get_infos()
-
-        for policy_name, live_mask in policy_live_masks.items():
-            policy_metrics[policy_name]["off_road"][live_mask] += infos.off_road[live_mask]
-            policy_metrics[policy_name]["collided"][live_mask] += infos.collided[live_mask]
-            policy_metrics[policy_name]["goal_achieved"][live_mask] += infos.goal_achieved[live_mask]
-
-        live_agent_mask[dones] = False
-
-        # Process completed worlds
-        num_dones_per_world = (dones & control_mask).sum(dim=1)
-        total_controlled_agents = control_mask.sum(dim=1)
-        done_worlds = (num_dones_per_world == total_controlled_agents).nonzero(as_tuple=True)[0]
-
-        for world in done_worlds:
-            if world in active_worlds:
-                active_worlds.remove(world)
-                episode_lengths[world] = time_step
-
-        if return_agent_positions:
-            global_agent_states = GlobalEgoState.from_tensor(env.sim.absolute_self_observation_tensor())
-            agent_positions[:, :, time_step, 0] = global_agent_states.pos_x
-            agent_positions[:, :, time_step, 1] = global_agent_states.pos_y
-
-        if not active_worlds:  
-            break
-    
-    controlled_per_scene = sum(mask.sum(dim=1).float() for policy_name,(policy_fn,mask) in policies.items())
-
-
-    
-    metrics =compute_metrics(policy_metrics,policy_live_masks,controlled_per_scene)
-
-    if render_sim_state:
-        return metrics, sim_state_frames
-    
-    return metrics
-
-def compute_metrics(policy_metrics,policy_live_masks,controlled_per_scene):
-
-    for policy_name, live_mask in policy_live_masks.items():
-            
-            policy_metrics[policy_name]['off_road_count'] = ( policy_metrics[policy_name]["off_road"] > 0).float().sum(axis=1)
-            policy_metrics[policy_name]['collided_count'] = (policy_metrics[policy_name]["collided"]   > 0).float().sum(axis=1)
-            policy_metrics[policy_name]['goal_achieved_count'] = (policy_metrics[policy_name]['goal_achieved']   > 0).float().sum(axis=1)
-            
-            policy_metrics[policy_name]['frac_off_road'] = policy_metrics[policy_name]['off_road_count'] / controlled_per_scene
-            policy_metrics[policy_name]['frac_collided'] = policy_metrics[policy_name]['collided_count'] / controlled_per_scene
-            policy_metrics[policy_name]['frac_goal_achieved'] = policy_metrics[policy_name]['goal_achieved_count'] / controlled_per_scene
-          
-
-    return policy_metrics
-
-
-def create_data_table(data):
-    # Extract unique policies
-    policies = sorted(set(policy for pair in data.keys() for policy in pair))
-
-    # Create empty DataFrames
-    collisions_table = pd.DataFrame(index=policies, columns=policies)
-    off_roads_table = pd.DataFrame(index=policies, columns=policies)
-    goal_achieved_table = pd.DataFrame(index=policies, columns=policies)
-
-    # Populate DataFrames
-    for (p1, p2), metrics in data.items():
-        collisions_table.loc[p1, p2] = metrics['frac_collided'].item()
-        off_roads_table.loc[p1, p2] = metrics['frac_off_road'].item()
-        goal_achieved_table.loc[p1, p2] = metrics['frac_goal_achieved'].item()
-
-    # Print Tables
-    print("Average Collisions Table:")
-    print(collisions_table, "\n")
-
-    print("Average Off Roads Table:")
-    print(off_roads_table, "\n")
-
-    print("Average Goal Achieved Table:")
-    print(goal_achieved_table, "\n")
diff --git a/gpudrive/utils/rollout.py b/gpudrive/utils/rollout.py
new file mode 100644
index 000000000..03b562660
--- /dev/null
+++ b/gpudrive/utils/rollout.py
@@ -0,0 +1,472 @@
+import torch
+import pandas as pd
+import numpy as np
+
+from gpudrive.visualize.utils import img_from_fig
+from gpudrive.datatypes.observation import GlobalEgoState
+
+import torch
+import pandas as pd
+import numpy as np
+
+from gpudrive.visualize.utils import img_from_fig
+from gpudrive.datatypes.observation import GlobalEgoState
+
+
+def rollout(
+    env,
+    policy,
+    device,
+    deterministic: bool = False,
+    render_sim_state: bool = False,
+    render_every_n_steps: int = 1,
+    return_agent_positions: bool = False,
+    return_behavior_metrics: bool = False,
+    set_agent_type: bool = False,
+    agent_weights: torch.Tensor = None,
+    center_on_ego: bool = False,
+    zoom_radius: int = 100,
+):
+    """
+    Perform a rollout of a policy in the environment.
+
+    Args:
+        env: The simulation environment.
+        policy: The policy to be rolled out.
+        device: The device to execute computations on (CPU/GPU).
+        deterministic (bool): Whether to use deterministic policy actions.
+        render_sim_state (bool): Whether to render the simulation state.
+        render_every_n_steps (int): Render every N steps.
+        zoom_radius (int): Radius for zoom in visualization.
+        return_agent_positions (bool): Whether to return agent positions.
+        return_behavior_metrics (bool): Whether to collect behavioral metrics.
+        center_on_ego (bool): Whether to center visualization on ego vehicle.
+        set_agent_type (bool): Whether to set agent type during reset.
+        agent_weights (torch.Tensor): Agent weights tensor for condition_mode="fixed".
+
+    Returns:
+        tuple: Averages for goal achieved, collisions, off-road occurrences,
+               controlled agents count, simulation state frames, and (if requested) behavioral metrics.
+    """
+    # Initialize storage
+    sim_state_frames = {env_id: [] for env_id in range(env.num_worlds)}
+    num_worlds = env.num_worlds
+    max_agent_count = env.max_agent_count
+    episode_len = env.config.episode_len
+    agent_positions = torch.zeros(
+        (env.num_worlds, env.max_agent_count, episode_len, 2)
+    )
+
+    if return_behavior_metrics:
+        entropy_values = torch.zeros(
+            (num_worlds, max_agent_count, episode_len), device=device
+        )
+        logprob_values = torch.zeros(
+            (num_worlds, max_agent_count, episode_len), device=device
+        )
+        # Assumes the action space is 3-dimensional (dynamics_model = "classic")
+        action_history = torch.zeros(
+            (num_worlds, max_agent_count, episode_len, 3), device=device
+        )
+    else:
+        entropy_values, logprob_values, action_history = None, None, None
+
+    # Reset episode
+    if set_agent_type and agent_weights is not None:
+        # Pass agent_weights to reset when set_agent_type is True
+        next_obs = env.reset(condition_mode="fixed", agent_type=agent_weights)
+    else:
+        next_obs = env.reset()
+
+    # Storage
+    goal_achieved = torch.zeros((num_worlds, max_agent_count), device=device)
+    collided = torch.zeros((num_worlds, max_agent_count), device=device)
+    off_road = torch.zeros((num_worlds, max_agent_count), device=device)
+    active_worlds = np.arange(num_worlds).tolist()
+    episode_lengths = torch.zeros(num_worlds)
+
+    control_mask = env.cont_agent_mask
+    live_agent_mask = control_mask.clone()
+
+    for time_step in range(episode_len):
+
+        time_mask = torch.zeros(episode_len, dtype=torch.bool, device=device)
+        time_mask[time_step] = True
+
+        # Get actions for active agents
+        if live_agent_mask.any():
+            action, logprob, entropy, value = policy(
+                next_obs[live_agent_mask], deterministic=deterministic
+            )
+
+            # Insert actions into a template
+            action_template = torch.zeros(
+                (num_worlds, max_agent_count), dtype=torch.int64, device=device
+            )
+            action_template[live_agent_mask] = action.to(device)
+
+            if return_behavior_metrics:
+                mask = live_agent_mask.unsqueeze(2) & time_mask.unsqueeze(
+                    0
+                ).unsqueeze(0)
+                entropy_values[mask] = entropy
+                logprob_values[mask] = logprob
+
+                action_values = env.action_keys_tensor[action]
+                action_history[mask] = action_values
+
+            # Step the environment
+            env.step_dynamics(action_template)
+
+            # Render
+            if render_sim_state and len(active_worlds) > 0:
+                has_live_agent = torch.where(
+                    live_agent_mask[active_worlds, :].sum(axis=1) > 0
+                )[0].tolist()
+
+                if time_step % render_every_n_steps == 0:
+                    if center_on_ego:
+                        agent_indices = torch.argmax(
+                            control_mask.to(torch.uint8), dim=1
+                        ).tolist()
+                    else:
+                        agent_indices = None
+
+                    sim_state_figures = env.vis.plot_simulator_state(
+                        env_indices=has_live_agent,
+                        time_steps=[time_step] * len(has_live_agent),
+                        zoom_radius=zoom_radius,
+                        center_agent_indices=agent_indices,
+                    )
+                    for idx, env_id in enumerate(has_live_agent):
+                        sim_state_frames[env_id].append(
+                            img_from_fig(sim_state_figures[idx])
+                        )
+
+        # Update observations, dones, and infos
+        next_obs = env.get_obs()
+        dones = env.get_dones().bool()
+        infos = env.get_infos()
+
+        off_road[live_agent_mask] += infos.off_road[live_agent_mask]
+        collided[live_agent_mask] += infos.collided[live_agent_mask]
+        goal_achieved[live_agent_mask] += infos.goal_achieved[live_agent_mask]
+
+        # Update live agent mask
+        live_agent_mask[dones] = False
+
+        # Process completed worlds
+        num_dones_per_world = (dones & control_mask).sum(dim=1)
+        total_controlled_agents = control_mask.sum(dim=1)
+        done_worlds = (num_dones_per_world == total_controlled_agents).nonzero(
+            as_tuple=True
+        )[0]
+
+        for world in done_worlds:
+            if world in active_worlds:
+                active_worlds.remove(world)
+                episode_lengths[world] = time_step
+
+        if return_agent_positions:
+            global_agent_states = GlobalEgoState.from_tensor(
+                env.sim.absolute_self_observation_tensor()
+            )
+            agent_positions[:, :, time_step, 0] = global_agent_states.pos_x
+            agent_positions[:, :, time_step, 1] = global_agent_states.pos_y
+
+        if not active_worlds:  # Exit early if all worlds are done
+            break
+
+    # Aggregate metrics to obtain averages across scenes
+    controlled_per_scene = control_mask.sum(dim=1).float()
+
+    # Counts
+    goal_achieved_count = (goal_achieved > 0).float().sum(axis=1)
+    collided_count = (collided > 0).float().sum(axis=1)
+    off_road_count = (off_road > 0).float().sum(axis=1)
+    not_goal_nor_crash_count = (
+        torch.logical_and(
+            goal_achieved == 0,  # Didn't reach the goal
+            torch.logical_and(
+                collided == 0,  # Didn't collide
+                torch.logical_and(
+                    off_road == 0,  # Didn't go off-road
+                    control_mask,  # Only count controlled agents
+                ),
+            ),
+        )
+        .float()
+        .sum(dim=1)
+    )
+
+    # Fractions per scene
+    frac_goal_achieved = goal_achieved_count / controlled_per_scene
+    frac_collided = collided_count / controlled_per_scene
+    frac_off_road = off_road_count / controlled_per_scene
+    frac_not_goal_nor_crash_per_scene = (
+        not_goal_nor_crash_count / controlled_per_scene
+    )
+
+    # Prepare return values
+    base_metrics = (
+        goal_achieved_count,
+        frac_goal_achieved,
+        collided_count,
+        frac_collided,
+        off_road_count,
+        frac_off_road,
+        not_goal_nor_crash_count,
+        frac_not_goal_nor_crash_per_scene,
+        controlled_per_scene,
+        sim_state_frames,
+        agent_positions,
+        episode_lengths,
+    )
+
+    # Return behavioral metrics if requested
+    if return_behavior_metrics:
+        behavior_metrics = {
+            "entropy": entropy_values,
+            "logprob": logprob_values,
+            "actions": action_history,
+        }
+        return base_metrics + (behavior_metrics,)
+
+    return base_metrics
+
+
+def multi_policy_rollout(
+    env,
+    policies,
+    device,
+    deterministic: bool = False,
+    render_sim_state: bool = False,
+    render_every_n_steps: int = 1,
+    zoom_radius: int = 100,
+    return_agent_positions: bool = False,
+    center_on_ego: bool = False,
+):
+    """
+    Perform a rollout of multiple policies in the environment.
+
+    Args:
+        env: The simulation environment.
+        policies (dict): Dictionary of policies {policy_name: (policy_function,mask)}.
+        device: The device to execute computations on (CPU/GPU).
+        policy_masks (dict): Dictionary of policy masks {policy_name: mask_tensor}.
+        deterministic (bool): Whether to use deterministic policy actions.
+        return_agent_positions (bool): Whether to return agent positions.
+
+    Returns:
+        policy_metrics: Dictionary of metrics corresponding to policies {policy_name: metrics(dict)}
+            metrics: {
+                'goal_achieved', 'collided', 'off_road', 'off_road_count', 'collided_count', 'goal_achieved_count', 'frac_off_road', 'frac_collided', 'frac_goal_achieved'
+                }
+
+    """
+
+    # Initialize storage
+    num_worlds = env.num_worlds
+    max_agent_count = env.max_agent_count
+    episode_len = env.config.episode_len
+    sim_state_frames = {env_id: [] for env_id in range(num_worlds)}
+    agent_positions = torch.zeros(
+        (num_worlds, max_agent_count, episode_len, 2)
+    )
+
+    # Reset environment
+    next_obs = env.reset()
+    policy_metrics = {
+        policy_name: {
+            "goal_achieved": torch.zeros(
+                (num_worlds, max_agent_count), device=device
+            ),
+            "collided": torch.zeros(
+                (num_worlds, max_agent_count), device=device
+            ),
+            "off_road": torch.zeros(
+                (num_worlds, max_agent_count), device=device
+            ),
+        }
+        for policy_name in policies
+    }
+    episode_lengths = torch.zeros(num_worlds)
+
+    active_worlds = list(range(num_worlds))
+    control_mask = env.cont_agent_mask
+    live_agent_mask = control_mask.clone()
+
+    for time_step in range(episode_len):
+
+        policy_live_masks = {
+            name: mask & live_agent_mask
+            for name, (policy_fn, mask) in policies.items()
+        }
+
+        actions = {}
+        for policy_name, (policy_fn, policy_mask) in policies.items():
+            live_mask = policy_live_masks[policy_name]
+            if live_mask.any():
+                actions[policy_name], _, _, _ = policy_fn(
+                    next_obs[live_mask], deterministic=deterministic
+                )
+
+        combined_mask = torch.zeros_like(live_agent_mask, dtype=torch.bool)
+        for live_mask in policy_live_masks.values():
+            combined_mask |= live_mask
+        assert torch.all(
+            live_agent_mask == combined_mask
+        ), "Live agent mask mismatch!"
+
+        action_template = torch.zeros(
+            (num_worlds, max_agent_count), dtype=torch.int64, device=device
+        )
+
+        # Assign actions based on policy masks
+        for policy_name, action in actions.items():
+            live_mask = policy_live_masks[policy_name]
+            if action.numel() > 0:
+                action_template[live_mask] = action.to(
+                    dtype=action_template.dtype, device=device
+                )
+
+        # Step environment
+        env.step_dynamics(action_template)
+
+        if render_sim_state and len(active_worlds) > 0:
+
+            has_live_agent = torch.where(
+                live_agent_mask[active_worlds, :].sum(axis=1) > 0
+            )[0].tolist()
+
+            if time_step % render_every_n_steps == 0:
+                if center_on_ego:
+                    agent_indices = torch.argmax(
+                        control_mask.to(torch.uint8), dim=1
+                    ).tolist()
+                else:
+                    agent_indices = None
+
+                sim_state_figures = env.vis.plot_simulator_state(
+                    env_indices=has_live_agent,
+                    time_steps=[time_step] * len(has_live_agent),
+                    zoom_radius=zoom_radius,
+                    center_agent_indices=agent_indices,
+                    policy_masks=policies,
+                )
+                for idx, env_id in enumerate(has_live_agent):
+                    sim_state_frames[env_id].append(
+                        img_from_fig(sim_state_figures[idx])
+                    )
+
+        # Update observations and agent statuses
+        next_obs = env.get_obs()
+        dones = env.get_dones().bool()
+        infos = env.get_infos()
+
+        for policy_name, live_mask in policy_live_masks.items():
+            policy_metrics[policy_name]["off_road"][
+                live_mask
+            ] += infos.off_road[live_mask]
+            policy_metrics[policy_name]["collided"][
+                live_mask
+            ] += infos.collided[live_mask]
+            policy_metrics[policy_name]["goal_achieved"][
+                live_mask
+            ] += infos.goal_achieved[live_mask]
+
+        live_agent_mask[dones] = False
+
+        # Process completed worlds
+        num_dones_per_world = (dones & control_mask).sum(dim=1)
+        total_controlled_agents = control_mask.sum(dim=1)
+        done_worlds = (num_dones_per_world == total_controlled_agents).nonzero(
+            as_tuple=True
+        )[0]
+
+        for world in done_worlds:
+            if world in active_worlds:
+                active_worlds.remove(world)
+                episode_lengths[world] = time_step
+
+        if return_agent_positions:
+            global_agent_states = GlobalEgoState.from_tensor(
+                env.sim.absolute_self_observation_tensor()
+            )
+            agent_positions[:, :, time_step, 0] = global_agent_states.pos_x
+            agent_positions[:, :, time_step, 1] = global_agent_states.pos_y
+
+        if not active_worlds:
+            break
+
+    controlled_per_scene = sum(
+        mask.sum(dim=1).float()
+        for policy_name, (policy_fn, mask) in policies.items()
+    )
+
+    metrics = compute_metrics(
+        policy_metrics, policy_live_masks, controlled_per_scene
+    )
+
+    if render_sim_state:
+        return metrics, sim_state_frames
+
+    return metrics
+
+
+def compute_metrics(policy_metrics, policy_live_masks, controlled_per_scene):
+
+    for policy_name, live_mask in policy_live_masks.items():
+
+        policy_metrics[policy_name]["off_road_count"] = (
+            (policy_metrics[policy_name]["off_road"] > 0).float().sum(axis=1)
+        )
+        policy_metrics[policy_name]["collided_count"] = (
+            (policy_metrics[policy_name]["collided"] > 0).float().sum(axis=1)
+        )
+        policy_metrics[policy_name]["goal_achieved_count"] = (
+            (policy_metrics[policy_name]["goal_achieved"] > 0)
+            .float()
+            .sum(axis=1)
+        )
+
+        policy_metrics[policy_name]["frac_off_road"] = (
+            policy_metrics[policy_name]["off_road_count"]
+            / controlled_per_scene
+        )
+        policy_metrics[policy_name]["frac_collided"] = (
+            policy_metrics[policy_name]["collided_count"]
+            / controlled_per_scene
+        )
+        policy_metrics[policy_name]["frac_goal_achieved"] = (
+            policy_metrics[policy_name]["goal_achieved_count"]
+            / controlled_per_scene
+        )
+
+    return policy_metrics
+
+
+def create_data_table(data):
+    # Extract unique policies
+    policies = sorted(set(policy for pair in data.keys() for policy in pair))
+
+    # Create empty DataFrames
+    collisions_table = pd.DataFrame(index=policies, columns=policies)
+    off_roads_table = pd.DataFrame(index=policies, columns=policies)
+    goal_achieved_table = pd.DataFrame(index=policies, columns=policies)
+
+    # Populate DataFrames
+    for (p1, p2), metrics in data.items():
+        collisions_table.loc[p1, p2] = metrics["frac_collided"].item()
+        off_roads_table.loc[p1, p2] = metrics["frac_off_road"].item()
+        goal_achieved_table.loc[p1, p2] = metrics["frac_goal_achieved"].item()
+
+    # Print Tables
+    print("Average Collisions Table:")
+    print(collisions_table, "\n")
+
+    print("Average Off Roads Table:")
+    print(off_roads_table, "\n")
+
+    print("Average Goal Achieved Table:")
+    print(goal_achieved_table, "\n")
diff --git a/gpudrive/utils/wosac.py b/gpudrive/utils/wosac.py
new file mode 100644
index 000000000..02373bd3b
--- /dev/null
+++ b/gpudrive/utils/wosac.py
@@ -0,0 +1,218 @@
+import wandb
+import tensorflow as tf
+import numpy as np
+from waymo_open_dataset.wdl_limited.sim_agents_metrics.trajectory_features import (
+    compute_displacement_error,
+    compute_kinematic_features,
+    compute_kinematic_validity,
+)
+
+
+def compute_realism_metrics(self, done_worlds):
+    """Compute realism metrics.
+
+    Args:
+        done_worlds: List of indices of the worlds to track.
+    """
+
+    # [worlds, max_cont_agents]
+    control_mask = (
+        self.controlled_agent_mask[done_worlds].detach().cpu().numpy()
+    )
+    # [batch, time, 1]
+    valid_mask = (
+        self.env.log_trajectory.valids[done_worlds]
+        .detach()
+        .cpu()
+        .numpy()[control_mask]
+        .squeeze(-1)
+    )
+
+    # Take human logs (ground-truth)
+    # Shape: [worlds, max_cont_agents, time, 2] -> [batch, time, 2]
+    ref_pos_xy_np = (
+        self.env.log_trajectory.pos_xy[done_worlds]
+        .detach()
+        .cpu()
+        .numpy()[control_mask]
+    )
+    ref_pos_z_np = np.zeros_like(ref_pos_xy_np[:, :, 0])
+    # Shape: [worlds, max_cont_agents, time, 1] -> [batch, time, 1]
+    ref_headings_np = (
+        self.env.log_trajectory.yaw[done_worlds]
+        .detach()
+        .cpu()
+        .numpy()[control_mask]
+        .squeeze(-1)
+    )
+
+    # Get agent information and convert to numpy
+    agent_headings_np = (
+        self.headings[done_worlds].detach().cpu().numpy()[control_mask]
+    )
+    agent_pos_xyz_np = (
+        self.pos_xyz[done_worlds].detach().cpu().numpy()[control_mask]
+    )
+
+    # Extract x, y, z components
+    agent_x_np = agent_pos_xyz_np[..., 0]
+    agent_y_np = agent_pos_xyz_np[..., 1]
+    agent_z_np = agent_pos_xyz_np[..., 2]
+
+    ref_x_np = ref_pos_xy_np[..., 0]
+    ref_y_np = ref_pos_xy_np[..., 1]
+
+    # Convert to TensorFlow tensors
+    ref_x = tf.convert_to_tensor(ref_x_np, dtype=tf.float32)
+    ref_y = tf.convert_to_tensor(ref_y_np, dtype=tf.float32)
+    ref_z = tf.convert_to_tensor(ref_pos_z_np, dtype=tf.float32)
+    ref_heading = tf.convert_to_tensor(ref_headings_np, dtype=tf.float32)
+
+    agent_x = tf.convert_to_tensor(agent_x_np, dtype=tf.float32)
+    agent_y = tf.convert_to_tensor(agent_y_np, dtype=tf.float32)
+    agent_z = tf.convert_to_tensor(agent_z_np, dtype=tf.float32)
+    agent_heading = tf.convert_to_tensor(agent_headings_np, dtype=tf.float32)
+
+    valid_mask = tf.convert_to_tensor(valid_mask, dtype=tf.bool)
+
+    # Step duration in seconds
+    seconds_per_step = 0.1  # Assuming 10Hz sampling rate
+
+    speed_validity, accel_validity = compute_kinematic_validity(valid_mask)
+
+    # Compute kinematic features for agents
+    (
+        agent_speed,
+        agent_accel,
+        agent_angular_speed,
+        agent_angular_accel,
+    ) = compute_kinematic_features(
+        agent_x, agent_y, agent_z, agent_heading, seconds_per_step
+    )
+
+    # Compute kinematic features for reference trajectories
+    (
+        ref_speed,
+        ref_accel,
+        ref_angular_speed,
+        ref_angular_accel,
+    ) = compute_kinematic_features(
+        ref_x, ref_y, ref_z, ref_heading, seconds_per_step
+    )
+
+    # Compute displacement error
+    displacement_error = compute_displacement_error(
+        agent_x, agent_y, agent_z, ref_x, ref_y, ref_z
+    )
+
+    # Compute additional metrics
+    speed_error = tf.abs(agent_speed - ref_speed)
+    accel_error = tf.abs(agent_accel - ref_accel)
+    angular_speed_error = tf.abs(agent_angular_speed - ref_angular_speed)
+    angular_accel_error = tf.abs(agent_angular_accel - ref_angular_accel)
+
+    def masked_mean_no_nan_inf(tensor):
+        """Compute mean excluding NaN and Inf values."""
+        # Create masks for non-NaN and non-Inf values
+        non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor))
+        non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor))
+        valid_values_mask = tf.logical_and(non_nan_mask, non_inf_mask)
+
+        # Apply mask to tensor
+        masked_tensor = tf.boolean_mask(tensor, valid_values_mask)
+
+        # If all values are filtered out, return 0.0
+        if tf.size(masked_tensor) == 0:
+            return tf.constant(0.0, dtype=tf.float32)
+
+        # Compute mean of valid values
+        return tf.reduce_mean(masked_tensor)
+
+    def masked_mean_with_validity_no_inf(tensor, validity_mask):
+        """Compute mean excluding NaN and Inf values and applying validity mask."""
+        # Create masks for non-NaN and non-Inf values
+        non_nan_mask = tf.math.logical_not(tf.math.is_nan(tensor))
+        non_inf_mask = tf.math.logical_not(tf.math.is_inf(tensor))
+        data_valid_mask = tf.logical_and(non_nan_mask, non_inf_mask)
+
+        # Combine with validity mask
+        combined_mask = tf.logical_and(data_valid_mask, validity_mask)
+
+        # Apply combined mask to tensor
+        masked_tensor = tf.boolean_mask(tensor, combined_mask)
+
+        # If all values are filtered out, return 0.0
+        if tf.size(masked_tensor) == 0:
+            return tf.constant(0.0, dtype=tf.float32)
+
+        # Compute mean of valid values
+        return tf.reduce_mean(masked_tensor)
+
+    metrics = {
+        "displacement_error": float(
+            masked_mean_no_nan_inf(displacement_error).numpy()
+        ),
+        "speed_error": float(
+            masked_mean_with_validity_no_inf(
+                speed_error, speed_validity
+            ).numpy()
+        ),
+        "accel_error": float(
+            masked_mean_with_validity_no_inf(
+                accel_error, accel_validity
+            ).numpy()
+        ),
+        "angular_speed_error": float(
+            masked_mean_with_validity_no_inf(
+                angular_speed_error, speed_validity
+            ).numpy()
+        ),
+        "angular_accel_error": float(
+            masked_mean_with_validity_no_inf(
+                angular_accel_error, accel_validity
+            ).numpy()
+        ),
+        "agent_speed": float(
+            masked_mean_with_validity_no_inf(
+                agent_speed, speed_validity
+            ).numpy()
+        ),
+        "agent_accel": float(
+            masked_mean_with_validity_no_inf(
+                agent_accel, accel_validity
+            ).numpy()
+        ),
+        "agent_angular_speed": float(
+            masked_mean_with_validity_no_inf(
+                agent_angular_speed, speed_validity
+            ).numpy()
+        ),
+        "agent_angular_accel": float(
+            masked_mean_with_validity_no_inf(
+                agent_angular_accel, accel_validity
+            ).numpy()
+        ),
+        "ref_speed": float(
+            masked_mean_with_validity_no_inf(ref_speed, speed_validity).numpy()
+        ),
+        "ref_accel": float(
+            masked_mean_with_validity_no_inf(ref_accel, accel_validity).numpy()
+        ),
+        "ref_angular_speed": float(
+            masked_mean_with_validity_no_inf(
+                ref_angular_speed, speed_validity
+            ).numpy()
+        ),
+        "ref_angular_accel": float(
+            masked_mean_with_validity_no_inf(
+                ref_angular_accel, accel_validity
+            ).numpy()
+        ),
+    }
+
+    wandb_metrics = {}
+    for key, value in metrics.items():
+        wandb_metrics[f"realism/{key}"] = value
+    wandb.log(wandb_metrics)
+
+    del wandb_metrics
diff --git a/gpudrive/visualize/color.py b/gpudrive/visualize/color.py
index e249dadf8..4cf250dec 100644
--- a/gpudrive/visualize/color.py
+++ b/gpudrive/visualize/color.py
@@ -27,7 +27,7 @@
     "ok": "#4B77BE",  # Controlled and doing fine
     "collided": "r",  # Controlled and collided
     "off_road": "orange",  # Controlled and off-road
-    "log_replay": "#c7c7c7",  # Agents marked as expert controlled or static
+    "log_replay": "#787878",  # Agents marked as expert controlled or static
 }
 
 REL_OBS_OBJ_COLORS = {
@@ -35,4 +35,4 @@
     "ego_goal": "#0099cc",
     "other_agents": "#ff884d",
 }
-AGENT_COLOR_BY_POLICY= ['g','b','p']
\ No newline at end of file
+AGENT_COLOR_BY_POLICY = ["g", "b", "p"]
diff --git a/gpudrive/visualize/core.py b/gpudrive/visualize/core.py
index a5a5c310c..02545c92f 100644
--- a/gpudrive/visualize/core.py
+++ b/gpudrive/visualize/core.py
@@ -105,11 +105,17 @@ def plot_simulator_state(
         time_steps: Optional[List[int]] = None,
         center_agent_indices: Optional[List[int]] = None,
         zoom_radius: int = 100,
-        plot_log_replay_trajectory: bool = False,
+        plot_waypoints: bool = False,
         plot_vbd_trajectory: bool = False,
         agent_positions: Optional[torch.Tensor] = None,
         backward_goals: bool = False,
-        policy_masks: Optional[Dict[int,Dict[str,torch.Tensor]]] = None,
+        policy_masks: Optional[Dict[int, Dict[str, torch.Tensor]]] = None,
+        colorbar: bool = False,
+        multiple_rollouts: bool = False,
+        line_color="#1f77b4",
+        line_alpha: float = 0.3,
+        line_width: float = 1.0,
+        weights: Optional[Dict[str, torch.Tensor]] = None,
     ):
         """
         Plot simulator states for one or multiple environments.
@@ -120,18 +126,18 @@ def plot_simulator_state(
             center_agent_indices: Optional list of center agent indices for zooming.
             figsize: Tuple for figure size of each subplot.
             zoom_radius: Radius for zooming in around the center agent.
-            plot_log_replay_trajectory: If True, plots the log replay trajectory.
+            plot_waypoints: If True, plots the waypoints from the human replays.
             agent_positions: Optional tensor to plot rolled out agent positions.
             backward_goals: If True, plots backward goals for controlled agents.
             policy_mask: dict
-            A dictionary that maps policies to world and specifies which agents are assigned to each policy. 
+            A dictionary that maps policies to world and specifies which agents are assigned to each policy.
             For now maximum number of policies is 3 as there are only 3 colors in COLOR_AGENT_BY_POLICY
             The structure follows the format: {Policy Name: (Policy Function,mask) }, where:
                 - Policy (str): The policy assigned to agents within the world.
 
                 - Policy Function  (Neural Network): The identifier for the simulation environment.
-                
-                - Mask (torch.Tensor): A boolean or index-based mask indicating which agents follow the given policy, for all worlds. 
+
+                - Mask (torch.Tensor): A boolean or index-based mask indicating which agents follow the given policy, for all worlds.
         """
         if not isinstance(env_indices, list):
             env_indices = [env_indices]  # Ensure env_indices is a list
@@ -150,6 +156,12 @@ def plot_simulator_state(
             device=self.device,
         )
 
+        self.multi_rollouts = multiple_rollouts
+        self.line_color = line_color
+        self.line_alpha = line_alpha
+        self.line_width = line_width
+        self.weights = weights
+
         if backward_goals:
 
             # Get world means for coordinate transformation
@@ -244,16 +256,15 @@ def plot_simulator_state(
         marker_scale = max(self.figsize) / 15
         line_width_scale = max(self.figsize) / 15
 
-
         if policy_masks:
 
             world_based_policy_mask = {}
-            
-            for policy_name, (fn,mask) in policy_masks.items():
+
+            for policy_name, (fn, mask) in policy_masks.items():
                 for world in range(mask.shape[0]):
                     if world not in world_based_policy_mask:
                         world_based_policy_mask[world] = {}
-                    world_based_policy_mask[world][policy_name] = mask[world]                   
+                    world_based_policy_mask[world][policy_name] = mask[world]
 
         else:
             world_based_policy_mask = None
@@ -297,15 +308,15 @@ def plot_simulator_state(
                 marker_size_scale=marker_scale,
             )
 
-            if plot_log_replay_trajectory:
-                self._plot_log_replay_trajectory(
+            if plot_waypoints:
+                self._plot_waypoints(
                     ax=ax,
                     control_mask=controlled_live,
                     env_idx=env_idx,
                     log_trajectory=self.log_trajectory,
                     line_width_scale=line_width_scale,
                 )
-            
+
             if plot_vbd_trajectory:
                 self._plot_vbd_trajectory(
                     ax=ax,
@@ -332,122 +343,21 @@ def plot_simulator_state(
             )
 
             if agent_positions is not None:
-                # First calculate the maximum valid trajectory length across all agents for this env_idx
-                max_valid_length = 0
-                for agent_idx in range(agent_positions.shape[1]):
-                    if controlled_live[agent_idx]:
-                        trajectory = agent_positions[
-                            env_idx, agent_idx, :time_step, :
-                        ]
-                        valid_mask = (
-                            (trajectory[:, 0] != 0)
-                            & (trajectory[:, 1] != 0)
-                            & (torch.abs(trajectory[:, 0]) < OUT_OF_BOUNDS)
-                            & (torch.abs(trajectory[:, 1]) < OUT_OF_BOUNDS)
-                        )
-                        max_valid_length = max(
-                            max_valid_length, valid_mask.sum().item()
-                        )
-
-                # Create color palette
-                palette = sns.light_palette(AGENT_COLOR_BY_STATE["ok"])
-                cmap = ListedColormap(palette)
-                norm = plt.Normalize(vmin=0, vmax=max_valid_length)
-                sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
-
-                for agent_idx in range(agent_positions.shape[1]):
-                    if controlled_live[agent_idx]:
-                        trajectory = agent_positions[
-                            env_idx, agent_idx, :time_step, :
-                        ]
-                        valid_mask = (
-                            (trajectory[:, 0] != 0)
-                            & (trajectory[:, 1] != 0)
-                            & (torch.abs(trajectory[:, 0]) < OUT_OF_BOUNDS)
-                            & (torch.abs(trajectory[:, 1]) < OUT_OF_BOUNDS)
-                        )
-                        # Get valid trajectory points
-                        valid_trajectory = trajectory[valid_mask]
-
-                        if len(valid_trajectory) > 1:
-                            points = valid_trajectory.cpu().numpy()
-
-                            if self.render_3d:
-                                trajectory_height = 0.05
-                                segments_3d = []
-                                for i in range(len(points) - 1):
-                                    segment = np.array(
-                                        [
-                                            [
-                                                points[i][0],
-                                                points[i][1],
-                                                trajectory_height,
-                                            ],
-                                            [
-                                                points[i + 1][0],
-                                                points[i + 1][1],
-                                                trajectory_height,
-                                            ],
-                                        ]
-                                    )
-                                    segments_3d.append(segment)
-
-                                # Adjust color mapping to use actual position in the valid trajectory
-                                t = np.linspace(
-                                    0, len(segments_3d), len(segments_3d)
-                                )
-                                colors = cmap(norm(t))
-                                colors[:, 3] = np.linspace(
-                                    0.3, 0.9, len(segments_3d)
-                                )
-
-                                lc = Line3DCollection(
-                                    segments_3d,
-                                    colors=colors,
-                                    linewidth=5,
-                                    zorder=1,
-                                )
-                                ax.add_collection3d(lc)
-                            else:
-                                segments = []
-                                for i in range(len(points) - 1):
-                                    segment = np.array(
-                                        [
-                                            [points[i][0], points[i][1]],
-                                            [
-                                                points[i + 1][0],
-                                                points[i + 1][1],
-                                            ],
-                                        ]
-                                    )
-                                    segments.append(segment)
-
-                                # Adjust color mapping to use actual position in the valid trajectory
-                                t = np.linspace(
-                                    0, len(segments), len(segments)
-                                )
-                                colors = cmap(norm(t))
-                                colors[:, 3] = np.linspace(
-                                    0.3, 0.9, len(segments)
-                                )
-
-                                lc = LineCollection(
-                                    segments,
-                                    colors=colors,
-                                    linewidth=5,
-                                    zorder=1,
-                                )
-                                ax.add_collection(lc)
-
-                # Add the colorbar
-                try:
-                    fig = ax.get_figure()
-                    cbar_ax = fig.add_axes([0.92, 0.09, 0.02, 0.8])
-                    cbar = fig.colorbar(sm, cax=cbar_ax)
-                    cbar.set_label("Timestep", fontsize=15 * marker_scale)
-                    cbar.ax.tick_params(labelsize=12 * marker_scale)
-                except Exception as e:
-                    print(f"Warning: Could not add colorbar: {e}")
+                self.plot_agent_trajectories(
+                    ax=ax,
+                    agent_positions=agent_positions,
+                    env_idx=env_idx,
+                    time_step=time_step,
+                    controlled_live=controlled_live,
+                    render_3d=self.render_3d,
+                    colorbar=colorbar,
+                    marker_scale=marker_scale,
+                    multiple_rollouts=self.multi_rollouts,
+                    line_color=self.line_color,
+                    line_alpha=self.line_alpha,
+                    line_width=self.line_width,
+                    weights=self.weights,
+                )
 
             # Determine center point for zooming
             if center_agent_idx is not None:
@@ -484,7 +394,239 @@ def plot_simulator_state(
 
         return figs
 
-    def _plot_log_replay_trajectory(
+    def plot_agent_trajectories(
+        self,
+        ax,
+        agent_positions,
+        env_idx=0,
+        time_step=None,
+        controlled_live=None,
+        render_3d=False,
+        colorbar=True,
+        marker_scale=1,
+        line_color=None,
+        line_alpha=None,
+        line_width=None,
+        multiple_rollouts=True,
+        weights=None,
+    ):
+        """
+        Plot agent trajectories on the given matplotlib axis.
+
+        Parameters:
+        -----------
+        ax : matplotlib.axes.Axes
+            The axis to plot on
+        agent_positions : torch.Tensor
+            Tensor of shape [env, rollouts, agent, time, 2] or
+            [rollouts, agent, time, 2] (legacy format)
+        env_idx : int, default=0
+            Index of the environment to plot
+        time_step : int, optional
+            Current time step to plot trajectories up to. If None, uses all timesteps.
+        controlled_live : list or tensor, optional
+            Boolean mask indicating which agents are controlled and alive.
+            If None, assumes all agents are active.
+        render_3d : bool, default=False
+            Whether to render in 3D
+        colorbar : bool, default=True
+            Whether to add a colorbar
+        marker_scale : float, default=1
+            Scale factor for markers and text
+        line_color : str, optional
+            Color for trajectory lines (only used for multiple rollouts mode without weights)
+        line_alpha : float, optional
+            Transparency of trajectory lines
+        line_width : float, optional
+            Width of trajectory lines
+        multiple_rollouts : bool, default=True
+            Whether agent_positions contains multiple rollouts
+        weights : list, optional
+            Used to color lines by the absolute magnitude of weights.
+
+        Returns:
+        --------
+        matplotlib.cm.ScalarMappable or None: Returns the color mapper
+        """
+        import torch
+        import numpy as np
+        import matplotlib.pyplot as plt
+        import seaborn as sns
+        from matplotlib.colors import ListedColormap
+        from matplotlib.collections import LineCollection
+
+        if render_3d:
+            try:
+                from mpl_toolkits.mplot3d.art3d import Line3DCollection
+            except ImportError:
+                print(
+                    "Warning: 3D rendering requested but mplot3d not available. Falling back to 2D."
+                )
+                render_3d = False
+
+        if agent_positions is None:
+            return None
+
+        # Determine shape format and extract appropriate data
+        if len(agent_positions.shape) == 5:  # [env, rollouts, agent, time, 2]
+            # New format with environment dimension first
+            if env_idx >= agent_positions.shape[0]:
+                print(
+                    f"Warning: env_idx {env_idx} out of range. Using env_idx=0"
+                )
+                env_idx = 0
+
+            # Extract the specific environment data
+            positions_to_plot = agent_positions[
+                env_idx
+            ]  # Shape: [rollouts, agent, time, 2]
+            n_rollouts, n_agents, n_steps, _ = positions_to_plot.shape
+
+        elif len(agent_positions.shape) == 4:  # [rollouts, agent, time, 2]
+            # Legacy format without environment dimension
+            positions_to_plot = agent_positions
+            n_rollouts, n_agents, n_steps, _ = positions_to_plot.shape
+            print("Warning: Using legacy format without environment dimension")
+        else:
+            raise ValueError(
+                f"Unexpected shape for agent_positions: {agent_positions.shape}"
+            )
+
+        # Set defaults for multiple rollouts mode
+        line_color = line_color or "#1f77b4"  # Default blue
+        line_alpha = 0.3 if line_alpha is None else line_alpha
+        line_width = 1 if line_width is None else line_width
+
+        # If time_step is not provided, use all timesteps
+        if time_step is None:
+            time_step = n_steps
+
+        # If controlled_live is not provided, assume all agents are active
+        if controlled_live is None:
+            controlled_live = [True] * n_agents
+
+        # Setup for weight-based coloring
+        if weights is not None:
+            weight_values = np.array(
+                weights
+            )  # Use absolute values for coloring
+
+            # Set up a colormap for weights
+            weight_cmap = plt.cm.coolwarm
+            weight_norm = plt.Normalize(
+                vmin=weight_values.min().item(),
+                vmax=weight_values.max().item(),
+            )
+            weight_sm = plt.cm.ScalarMappable(
+                cmap=weight_cmap, norm=weight_norm
+            )
+
+        # Process each rollout and each agent
+        for rollout_idx in range(n_rollouts):
+            for agent_idx in range(n_agents):
+                if not controlled_live[agent_idx]:
+                    continue
+
+                # Get trajectory for this rollout and agent
+                trajectory = positions_to_plot[
+                    rollout_idx, agent_idx, :time_step, :
+                ]
+
+                # Create valid mask
+                valid_mask = (
+                    (trajectory[:, 0] != 0)
+                    & (trajectory[:, 1] != 0)
+                    & (torch.abs(trajectory[:, 0]) < OUT_OF_BOUNDS)
+                    & (torch.abs(trajectory[:, 1]) < OUT_OF_BOUNDS)
+                )
+
+                # Get valid trajectory points
+                valid_trajectory = trajectory[valid_mask]
+
+                # Only proceed if we have at least 2 points
+                if len(valid_trajectory) > 1:
+                    points = valid_trajectory.cpu().numpy()
+
+                    # Determine color based on weights or fixed color
+                    if weights is not None:
+                        # Use the weight value for this rollout
+                        weight_value = weight_values[rollout_idx].item()
+                        segment_color = weight_cmap(weight_norm(weight_value))
+                    else:
+                        segment_color = line_color
+
+                    if render_3d:
+                        trajectory_height = 0.05
+                        segments_3d = []
+                        for i in range(len(points) - 1):
+                            segment = np.array(
+                                [
+                                    [
+                                        points[i][0],
+                                        points[i][1],
+                                        trajectory_height,
+                                    ],
+                                    [
+                                        points[i + 1][0],
+                                        points[i + 1][1],
+                                        trajectory_height,
+                                    ],
+                                ]
+                            )
+                            segments_3d.append(segment)
+
+                        # Create line collection for 3D
+                        lc = Line3DCollection(
+                            segments_3d,
+                            colors=segment_color,
+                            linewidths=line_width,
+                            alpha=line_alpha,
+                            zorder=1,
+                        )
+                        ax.add_collection3d(lc)
+                    else:
+                        segments = []
+                        for i in range(len(points) - 1):
+                            segment = np.array(
+                                [
+                                    [points[i][0], points[i][1]],
+                                    [points[i + 1][0], points[i + 1][1]],
+                                ]
+                            )
+                            segments.append(segment)
+
+                        # Create line collection for 2D
+                        lc = LineCollection(
+                            segments,
+                            colors=segment_color,
+                            linewidths=line_width,
+                            alpha=line_alpha,
+                            zorder=1,
+                        )
+                        ax.add_collection(lc)
+
+        # Add colorbar for weight-based coloring - outside the loops
+        if weights is not None and colorbar:
+            try:
+                fig = ax.get_figure()
+                # Create horizontal colorbar at the bottom
+                # Parameters: [left, bottom, width, height]
+                cbar_ax = fig.add_axes([0.15, 0.05, 0.7, 0.03])
+                cbar = fig.colorbar(
+                    weight_sm, cax=cbar_ax, orientation="horizontal"
+                )
+                cbar.set_label(
+                    f"Conditioning param value", fontsize=15 * marker_scale
+                )
+                cbar.ax.tick_params(labelsize=12 * marker_scale)
+            except Exception as e:
+                print(f"Warning: Could not add colorbar: {e}")
+
+            return weight_sm
+
+        return None
+
+    def _plot_waypoints(
         self,
         ax: matplotlib.axes.Axes,
         env_idx: int,
@@ -558,14 +700,100 @@ def _plot_log_replay_trajectory(
         else:
             # Original 2D plotting
             ax.scatter(
-                log_trajectory.pos_xy[env_idx, control_mask, :, 0].numpy(),
-                log_trajectory.pos_xy[env_idx, control_mask, :, 1].numpy(),
+                log_trajectory.pos_xy[env_idx, control_mask, :, 0]
+                .cpu()
+                .numpy(),
+                log_trajectory.pos_xy[env_idx, control_mask, :, 1]
+                .cpu()
+                .numpy(),
                 color="lightgreen",
                 linewidth=0.35 * line_width_scale,
                 alpha=0.35,
                 zorder=0,
             )
-    
+
+    def _plot_vbd_trajectory(
+        self,
+        ax: matplotlib.axes.Axes,
+        env_idx: int,
+        control_mask: torch.Tensor,
+        vbd_trajectory: VBDTrajectory,
+        line_width_scale: int = 1.0,
+    ):
+        """Plot the VBD trajectory for controlled agents in either 2D or 3D."""
+        if self.render_3d:
+            # Get trajectory points
+            trajectory_points = vbd_trajectory.pos_xy[
+                env_idx, control_mask, :, :
+            ].numpy()
+
+            # Set a fixed height for trajectory visualization
+            trajectory_height = 0.05
+
+            # Plot trajectories for each controlled agent
+            for agent_trajectory in trajectory_points:
+                # Filter out invalid points (zeros or out of bounds)
+                valid_mask = (
+                    (agent_trajectory[:, 0] != 0)
+                    & (agent_trajectory[:, 1] != 0)
+                    & (np.abs(agent_trajectory[:, 0]) < OUT_OF_BOUNDS)
+                    & (np.abs(agent_trajectory[:, 1]) < OUT_OF_BOUNDS)
+                )
+                valid_points = agent_trajectory[valid_mask]
+
+                if len(valid_points) > 1:
+                    # Create segments for the trajectory
+                    segments = []
+                    for i in range(len(valid_points) - 1):
+                        segment = np.array(
+                            [
+                                [
+                                    valid_points[i, 0],
+                                    valid_points[i, 1],
+                                    trajectory_height,
+                                ],
+                                [
+                                    valid_points[i + 1, 0],
+                                    valid_points[i + 1, 1],
+                                    trajectory_height,
+                                ],
+                            ]
+                        )
+                        segments.append(segment)
+
+                    # Create line collection with fade effect
+                    colors = np.zeros((len(segments), 4))
+                    colors[:, 1] = 0.9  # Green component
+                    colors[:, 3] = np.linspace(
+                        0.2, 0.6, len(segments)
+                    )  # Alpha gradient
+
+                    lc = Line3DCollection(
+                        segments, colors=colors, linewidth=2 * line_width_scale
+                    )
+                    ax.add_collection3d(lc)
+
+                    # Add points at trajectory positions
+                    ax.scatter3D(
+                        valid_points[:, 0],
+                        valid_points[:, 1],
+                        np.full_like(valid_points[:, 0], trajectory_height),
+                        color="lightgreen",
+                        s=10,
+                        alpha=0.5,
+                        zorder=0,
+                    )
+        else:
+            # Original 2D plotting
+            ax.scatter(
+                vbd_trajectory.pos_xy[env_idx, control_mask, :, 0].numpy(),
+                vbd_trajectory.pos_xy[env_idx, control_mask, :, 1].numpy(),
+                color="lightgreen",
+                linewidth=0.35 * line_width_scale,
+                alpha=0.35,
+                zorder=0,
+            )
+
     def _plot_vbd_trajectory(
         self,
         ax: matplotlib.axes.Axes,
@@ -1071,7 +1299,9 @@ def _plot_filtered_agent_bounding_boxes(
         line_width_scale: int = 1.0,
         marker_size_scale: int = 1.0,
         extended_goals: Optional[Dict[str, torch.Tensor]] = None,
-        world_based_policy_mask : Optional[Dict[int,Dict[str,torch.Tensor]]] = None,
+        world_based_policy_mask: Optional[
+            Dict[int, Dict[str, torch.Tensor]]
+        ] = None,
     ) -> None:
         """Plots bounding boxes for agents filtered by environment index and mask.
 
@@ -1173,8 +1403,7 @@ def plot_agent_group_3d(
                     zorder=5,
                 )
 
-
-        def plot_agent_group_2d(bboxes, color,by_policy = False):
+        def plot_agent_group_2d(bboxes, color, by_policy=False):
             """Helper function to plot a group of agents in 2D"""
             if not by_policy:
                 utils.plot_numpy_bounding_boxes(
@@ -1188,15 +1417,16 @@ def plot_agent_group_2d(bboxes, color,by_policy = False):
                 )
             else:
                 num_policies = len(bboxes)
-                utils.plot_numpy_bounding_boxes_multiple_policy(            
-                ax=ax,
-                bboxes_s=bboxes,
-                colors=color[:num_policies],
-                alpha=alpha,
-                line_width_scale=line_width_scale,
-                as_center_pts=as_center_pts,
-                label=label,
-                    )
+                utils.plot_numpy_bounding_boxes_multiple_policy(
+                    ax=ax,
+                    bboxes_s=bboxes,
+                    colors=color[:num_policies],
+                    alpha=alpha,
+                    line_width_scale=line_width_scale,
+                    as_center_pts=as_center_pts,
+                    label=label,
+                )
+
         # Off-road agents
         bboxes_controlled_offroad = np.stack(
             (
@@ -1308,7 +1538,7 @@ def plot_agent_group_2d(bboxes, color,by_policy = False):
             axis=1,
         )
 
-        if not world_based_policy_mask: ## controlled by the same policy
+        if not world_based_policy_mask:  ## controlled by the same policy
             # Living agents
             bboxes_controlled_ok = np.stack(
                 (
@@ -1332,7 +1562,7 @@ def plot_agent_group_2d(bboxes, color,by_policy = False):
         else:
             bboxes_controlled_ok = []
             policy_mask = world_based_policy_mask[env_idx]
-            for policy_name,mask in policy_mask.items():
+            for policy_name, mask in policy_mask.items():
 
                 bboxes = np.stack(
                     (
@@ -1343,11 +1573,11 @@ def plot_agent_group_2d(bboxes, color,by_policy = False):
                         agent_states.rotation_angle[env_idx, mask].numpy(),
                     ),
                     axis=1,
-                    )
+                )
                 bboxes_controlled_ok.append(bboxes)
 
             plot_agent_group_2d(
-                bboxes_controlled_ok, AGENT_COLOR_BY_POLICY,by_policy=True
+                bboxes_controlled_ok, AGENT_COLOR_BY_POLICY, by_policy=True
             )
         # Plot log replay agents
         log_replay = (
@@ -1445,7 +1675,7 @@ def plot_agent_observation(
         trajectory: Optional[np.ndarray] = None,
     ):
         """
-        Plot observation from agent POV to inspect the information available 
+        Plot observation from agent POV to inspect the information available
         to the agent.
         Args:
             agent_idx (int): Index of the agent whose observation is to be plotted.
@@ -1589,7 +1819,7 @@ def plot_agent_observation(
 
         if observation_ego is not None:
             ego_agent_color = (
-                "darkred"
+                "r"
                 if observation_ego.is_collided[env_idx, agent_idx]
                 else REL_OBS_OBJ_COLORS["ego"]
             )
@@ -1617,55 +1847,89 @@ def plot_agent_observation(
                 0,  # Arrow points to the right, proportional to speed
                 head_width=1.0,
                 head_length=1.1,
-                fc=REL_OBS_OBJ_COLORS["ego"],
-                ec=REL_OBS_OBJ_COLORS["ego"],
-            )
-
-            ax.scatter(
-                observation_ego.rel_goal_x[env_idx, agent_idx],
-                observation_ego.rel_goal_y[env_idx, agent_idx],
-                s=5,
-                linewidth=1.5,
-                c=ego_agent_color,
-                marker="x",
+                fc="k",
+                ec="k",
+                zorder=1,
             )
 
-            circle = Circle(
-                (
-                    observation_ego.rel_goal_x[env_idx, agent_idx],
-                    observation_ego.rel_goal_y[env_idx, agent_idx],
-                ),
-                radius=self.goal_radius,
-                color=ego_agent_color,
-                fill=False,
-                linestyle="--",
-            )
-            ax.add_patch(circle)
-
-            observation_radius = Circle(
-                (0, 0),
-                radius=self.env_config.obs_radius,
-                color="#000000",
-                linewidth=0.8,
-                fill=False,
-                linestyle="-",
-            )
-            ax.add_patch(observation_radius)
+            # ax.scatter(
+            #     observation_ego.rel_goal_x[env_idx, agent_idx],
+            #     observation_ego.rel_goal_y[env_idx, agent_idx],
+            #     s=5,
+            #     linewidth=1.5,
+            #     c=ego_agent_color,
+            #     marker="x",
+            # )
+
+            # circle = Circle(
+            #     (
+            #         observation_ego.rel_goal_x[env_idx, agent_idx],
+            #         observation_ego.rel_goal_y[env_idx, agent_idx],
+            #     ),
+            #     radius=self.goal_radius,
+            #     color=ego_agent_color,
+            #     fill=False,
+            #     linestyle="--",
+            # )
+            # ax.add_patch(circle)
+
+            # observation_radius = Circle(
+            #     (0, 0),
+            #     radius=self.env_config.obs_radius,
+            #     color="#000000",
+            #     linewidth=0.8,
+            #     fill=False,
+            #     linestyle="-",
+            # )
+            # ax.add_patch(observation_radius)
             plt.axis("off")
 
+        time_step = (
+            self.env_config.episode_len
+            - self.sim_object.steps_remaining_tensor().to_torch()[
+                env_idx, agent_idx
+            ]
+        ).item()
+
+        # Add time step text to the figure
+        ax.text(
+            0.05,  # x position in axes coordinates (5% from left)
+            0.95,  # y position in axes coordinates (95% from bottom)
+            f"t = {time_step}",
+            transform=ax.transAxes,  # Use axes coordinates
+            fontsize=15,
+            color="black",
+            ha="left",
+            va="top",
+        )
+
+        attn_reference_idx = torch.where(trajectory[:, 2] == 1)[0]
+
         if trajectory is not None and len(trajectory) > 0:
             # Plot the trajectory as a line
-            ax.plot(
+            ax.scatter(
                 trajectory[:, 0],  # x coordinates
                 trajectory[:, 1],  # y coordinates
-                color='blue',      # trajectory color
-                linestyle='-',     # solid line
-                linewidth=1.0,     # line width
-                marker='o',        # circular markers at each point
-                markersize=1,      # size of markers
-                alpha=0.7,         # slight transparency
-                label='Trajectory' # label for legend
+                color="g",
+                linewidth=0.3,
+                marker="o",
+                alpha=0.2,
+                zorder=0,
             )
+            # Add a purple star above the reference position
+            if len(attn_reference_idx) > 0:
+                ref_idx = attn_reference_idx[0]
+                ref_x = trajectory[ref_idx, 0]
+                ref_y = trajectory[ref_idx, 1]
+
+                ax.scatter(
+                    ref_x,
+                    ref_y,
+                    color="#9D00FF",
+                    marker="*",
+                    s=120,
+                    zorder=10,
+                )
 
         ax.set_xlim((-self.env_config.obs_radius, self.env_config.obs_radius))
         ax.set_ylim((-self.env_config.obs_radius, self.env_config.obs_radius))
diff --git a/src/consts.hpp b/src/consts.hpp
index 41d7a5282..d5e76b834 100644
--- a/src/consts.hpp
+++ b/src/consts.hpp
@@ -10,7 +10,7 @@ namespace consts {
 
 inline constexpr madrona::CountT kMaxAgentCount = 64;
 inline constexpr madrona::CountT kMaxRoadEntityCount = 10000;
-inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 200;
+inline constexpr madrona::CountT kMaxAgentMapObservationsCount = 128;
 
 inline constexpr bool useEstimatedYaw = true;
 
@@ -22,7 +22,7 @@ inline constexpr float worldLength = 40.f;
 // This factor rescales the length of the vehicles by a tiny amount
 // To account for the fact that noise occasionally puts vehicles into initial
 // collisions. This is a dataset artifact that we are handling here like this.
-inline constexpr float vehicleLengthScale = 0.7f;
+inline constexpr float vehicleLengthScale = 0.9f;
 
 // Each unit of distance forward (+ y axis) rewards the agents by this amount
 inline constexpr float rewardPerDist = 0.05f;
@@ -31,7 +31,7 @@ inline constexpr float rewardPerDist = 0.05f;
 inline constexpr float slackReward = -0.005f;
 
 // Steps per episode
-inline constexpr int32_t episodeLen = 91;
+inline constexpr int32_t episodeLen = 90;
 
 // Number of lidar samples, arranged in circle around agent
 inline constexpr madrona::CountT numLidarSamples = 50;
diff --git a/src/sim.cpp b/src/sim.cpp
index f42ab7f5d..1a0e39189 100755
--- a/src/sim.cpp
+++ b/src/sim.cpp
@@ -630,16 +630,16 @@ inline void doneSystem(Engine &ctx,
         done.v = 1;
     }
 
-    // An agent can be done early if it reaches the goal
-    if (done.v != 1 || info.reachedGoal != 1)
-    {
-        float dist = (position.xy() - goal.position).length();
-        if (dist < ctx.data().params.rewardParams.distanceToGoalThreshold)
-        {
-            done.v = 1;
-            info.reachedGoal = 1;
-        }
-    }
+    // // An agent can be done early if it reaches the goal
+    // if (done.v != 1 || info.reachedGoal != 1)
+    // {
+    //     float dist = (position.xy() - goal.position).length();
+    //     if (dist < ctx.data().params.rewardParams.distanceToGoalThreshold)
+    //     {
+    //         done.v = 1;
+    //         info.reachedGoal = 1;
+    //     }
+    // }
 }