diff --git a/EXTENSIONS.md b/EXTENSIONS.md
new file mode 100644
index 0000000..6b236c8
--- /dev/null
+++ b/EXTENSIONS.md
@@ -0,0 +1,112 @@
+# Project extensions (16-831)
+
+Additions to FlashSAC for the course project. With the default config the training behaviour is unchanged.
+
+## Config keys
+
+All keys live in `configs/agent/flashSAC.yaml` and are set with `--overrides agent.<key>=<value>`.
+
+| Key | Values (default first) | Meaning |
+|---|---|---|
+| `sampler` | `uniform`, `swd`, `laber` | Replay sampling method |
+| `swd_decay_steps` | `2000` | SWD decay horizon, in interaction steps |
+| `swd_min_weight` | `0.1` | SWD weight floor |
+| `laber_multiplier` | `4` | LaBER candidate batch = multiplier × `sample_batch_size` |
+| `actor_delay` | `fixed`, `ema` | Actor delay rule |
+| `actor_update_period` | `2` | Delay `d` for `actor_delay=fixed` |
+| `actor_delay_ema_interval` | `100` | `k`: critic updates between delay recomputations |
+| `actor_delay_ema_beta` | `0.9` | EMA decay, applied once per interval |
+| `actor_delay_ema_scale` | `2.0` | Delay when the TD error equals its EMA |
+| `actor_delay_ema_min` / `_max` | `1.0` / `8.0` | Clip range of the delay |
+| `actor_lr_schedule` | `actor_step`, `global_step` | What drives the actor/temperature learning-rate schedule |
+
+`log_csv` (default `true`, in `configs/flashSAC_base.yaml`) turns the CSV log on or off.
+
+## Methods
+
+**SWD** (`flash_rl/buffers/torch_buffer.py`). WarpSAC's Sample Weight Decay: a transition added `age` interaction
+steps ago is sampled with probability ∝ `max(swd_min_weight, 1 - age / swd_decay_steps)`. No importance correction,
+as in WarpSAC: both the loss and the BatchNorm statistics follow the recency-biased batch.
+This is FlashSAC + SWD, not full WarpSAC (which also changes the critic).
+
+**LaBER** (`FlashSACAgent._select_laber_batch`). Draw `laber_multiplier × B` transitions uniformly, score each with
+
+    surprise_i = mean over the 2 critics of ‖softmax(logits(s_i, a_i)) − target_probs_i‖₂
+
+and keep `B` of them with probability ∝ surprise (with replacement). The importance weights
+`w_i = mean(surprise) / surprise_i` correct the critic update for this selection in two places: the loss terms, and the
+BatchNorm batch statistics of the critic and target critic (weighted mean and variance). Both corrections are
+self-normalised estimates of their uniform-sampling counterparts, so the update is approximately, not exactly,
+unbiased. Scoring runs with BatchNorm in eval mode. The actor is updated on a uniform slice of the candidates, not on
+the high-surprise selection.
+
+**EMA actor delay** (`flash_rl/agents/flashSAC/actor_delay.py`). Every `interval` critic updates, with `e` the mean
+absolute TD error over those updates:
+
+    ema   = beta * ema + (1 - beta) * e
+    delay = clip(scale * e / ema, min, max)
+
+The delay is real-valued: each critic update earns `1/delay` credit and an actor update costs 1.
+
+**Actor LR schedule.** In FlashSAC the actor's cosine decay advances once per actor update, so its learning-rate
+schedule depends on the delay. `actor_lr_schedule=global_step` ties it to the number of critic updates instead. Use it
+for all runs of a delay comparison (it also changes the `d=2` baseline).
+
+## Running
+
+    scripts/run_humanoid.sh <exp_name> [agent overrides...]
+
+runs the four IsaacLab humanoid tasks for each seed; see the examples at the top of the script.
+
+## Logs
+
+Each run writes `logs/<group_name>/<exp_name>/<env_name>/seed<seed>_<time>/`:
+
+- `config.yaml`: the resolved config of the run.
+- `metrics.csv`: one row per logging interval (1% of training). Metrics are averaged over the interval unless noted.
+  A cell is empty when the metric was not produced in that interval.
+
+| Columns | Meaning |
+|---|---|
+| `env_step`, `wall_time` | Row index: environment steps, and seconds since the logger was created |
+| `avg_return`, `avg_length`, `avg_success_*` | Evaluation results (10 evaluations per run, plus one at step 0) |
+| `eval_env_step`, `eval_train_time`, `eval_num_updates` | Exactly when that evaluation ran. Use these for return curves |
+| `time/train_time` | Seconds of training, excluding evaluation and video recording |
+| `time/collect_time`, `time/update_time`, `time/eval_time` | Cumulative seconds in env stepping, gradient updates, evaluation |
+| `time/env_steps_per_sec`, `time/gpu_max_memory_gb` | Throughput and peak GPU memory |
+| `train/num_updates`, `train/num_actor_updates` | Cumulative critic and actor updates |
+| `critic/td_abs` | Mean abs. TD error between distribution means (importance-weighted under LaBER). Drives the EMA delay |
+| `critic/surprise` | Mean surprise, same weighting |
+| `critic/loss`, `critic/q_mean`, `critic/learning_rate` | Critic loss, mean Q of the batch, learning rate |
+| `actor/loss`, `actor/entropy`, `actor/learning_rate`, `temperature/value` | Actor and temperature state |
+| `replay/age_mean`, `_median`, `_p90`, `_max` | Staleness of the critic's batch, in interaction steps |
+| `replay/batch_td_abs`, `replay/batch_surprise` | Unweighted error of the critic's batch |
+| `replay/age_surprise_corr` | Pearson correlation between age and surprise in the critic's batch |
+| `replay/size` | Transitions in the buffer |
+| `actor_delay/delay`, `td_ratio`, `td_ema` | Current delay, `e / ema`, and the EMA |
+| `actor_delay/actor_updated` | Fraction of critic updates that also updated the actor |
+| `laber/candidate_*` | Surprise, TD error, age and their correlation over the uniform candidates |
+| `laber/effective_sample_frac`, `weight_max`, `unique_frac` | How concentrated the LaBER selection is |
+
+## Videos
+
+Checkpoints are saved at the end of training to `models/<group_name>/<exp_name>/<env_name>/seed<seed>-<time>/step<N>/`.
+To record a trained policy to an mp4 without a display:
+
+    uv run python play_isaaclab.py \
+        --checkpoint_path 'models/humanoid/<exp_name>/Isaac-Velocity-Flat-G1-v0/seed0-<time>/step<N>' \
+        --video --video_length 500 --follow_robot \
+        --overrides env=isaaclab \
+        --overrides env.env_name='Isaac-Velocity-Flat-G1-v0' \
+        --overrides agent.buffer_max_length=1
+
+The video (`rl-video-step-0.mp4`, 50 steps per second) goes to `<checkpoint_path>/videos` unless `--video_dir` is set.
+`--follow_robot` keeps the camera on the robot of environment 0; without it the camera is fixed. Pass any overrides
+that change the network (e.g. `agent.critic_hidden_dim`) exactly as in training. Without `--video` the script opens
+the Isaac Sim viewport as before.
+
+## Tests
+
+    python -m pytest tests/test_extensions.py
+
+CPU-only; covers the SWD sampling distribution, ages, the delay rules, LaBER weights, the LR schedule and the CSV log.
diff --git a/configs/agent/flashSAC.yaml b/configs/agent/flashSAC.yaml
index c584cf2..faa7def 100755
--- a/configs/agent/flashSAC.yaml
+++ b/configs/agent/flashSAC.yaml
@@ -12,6 +12,17 @@ buffer_min_length: 10_000
 buffer_device_type: 'cuda'
 sample_batch_size: 2048
 
+# Replay sampling
+#   uniform: FlashSAC default.
+#   swd:     WarpSAC's Sample Weight Decay, p(i) ∝ max(swd_min_weight, 1 - age(i) / swd_decay_steps),
+#            with age in interaction steps.
+#   laber:   draw laber_multiplier * sample_batch_size transitions uniformly, then keep sample_batch_size
+#            of them with probability ∝ TD surprise (importance-weighted critic loss).
+sampler: 'uniform'        # ['uniform', 'swd', 'laber']
+swd_decay_steps: 2000
+swd_min_weight: 0.1
+laber_multiplier: 4
+
 normalize_reward: true
 normalized_G_max: 5.0
 
@@ -32,7 +43,22 @@ actor_hidden_dim: 128
 actor_bc_alpha: 0.0
 actor_noise_zeta_mu: 2.0
 actor_noise_zeta_max: 16
+
+# Actor delay = number of critic updates per actor update.
+#   fixed: delay = actor_update_period (FlashSAC default: 2).
+#   ema:   every `interval` critic updates, with e = mean TD error over those updates,
+#          delay = clip(scale * e / EMA_beta(e), min, max).
+actor_delay: 'fixed'      # ['fixed', 'ema']
 actor_update_period: 2
+actor_delay_ema_interval: 100
+actor_delay_ema_beta: 0.9
+actor_delay_ema_scale: 2.0
+actor_delay_ema_min: 1.0
+actor_delay_ema_max: 8.0
+# What drives the actor/temperature learning-rate schedule.
+#   actor_step:  number of actor updates (FlashSAC default; the schedule then depends on the actor delay).
+#   global_step: number of critic updates (same schedule for every actor delay).
+actor_lr_schedule: 'actor_step'   # ['actor_step', 'global_step']
 
 critic_num_blocks: 2
 critic_hidden_dim: 256
diff --git a/configs/flashSAC_base.yaml b/configs/flashSAC_base.yaml
index d9bdf29..35a503b 100644
--- a/configs/flashSAC_base.yaml
+++ b/configs/flashSAC_base.yaml
@@ -9,6 +9,7 @@ exp_name: 'test'
 seed: 0
 
 logger_type: 'tensorboard'  # ['wandb','tensorboard']
+log_csv: true               # also write logs/<group>/<exp>/<env>/seed<seed>_<time>/{metrics.csv,config.yaml}
 save_path: 'models/${group_name}/${exp_name}/${env.env_name}/seed${seed}-TIMESTAMP'
 agent_load_path: null
 buffer_load_path: null
diff --git a/flash_rl/agents/flashSAC/actor_delay.py b/flash_rl/agents/flashSAC/actor_delay.py
new file mode 100644
index 0000000..b49689c
--- /dev/null
+++ b/flash_rl/agents/flashSAC/actor_delay.py
@@ -0,0 +1,76 @@
+from typing import Any, Optional
+
+
+class ActorDelay:
+    """
+    Decides, at every critic update, whether the actor is updated too.
+    `delay` is the number of critic updates per actor update.
+
+    fixed: delay = period (FlashSAC uses 2).
+    ema:   every `interval` critic updates, with e = mean TD error over those updates,
+               ema   = beta * ema + (1 - beta) * e
+               delay = clip(scale * e / ema, min_delay, max_delay)
+           The actor is updated less often while the critic error is above its recent average.
+    """
+
+    def __init__(
+        self,
+        mode: str,
+        period: int,
+        interval: int,
+        beta: float,
+        scale: float,
+        min_delay: float,
+        max_delay: float,
+    ):
+        assert mode in ("fixed", "ema"), f"Unknown actor delay: {mode}"
+        assert interval >= 1 and 0.0 <= beta < 1.0 and 0.0 < min_delay <= max_delay
+        self._mode = mode
+        self._interval = interval
+        self._beta = beta
+        self._scale = scale
+        self._min_delay = min_delay
+        self._max_delay = max_delay
+
+        # until the first interval ends, the error ratio is taken to be 1
+        self.delay = float(period) if mode == "fixed" else self._clip(scale)
+        self.ratio = 1.0
+        self.ema: Optional[float] = None
+        self._window_sum = 0.0
+        self._window_count = 0
+        # `delay` is real-valued: each critic update earns 1/delay credit, an actor update costs 1
+        self._credit = 1.0
+
+    def _clip(self, delay: float) -> float:
+        return min(max(delay, self._min_delay), self._max_delay)
+
+    def should_update_actor(self, update_step: int) -> bool:
+        if self._mode == "fixed":
+            return update_step % int(self.delay) == 0
+        do_update = self._credit >= 1.0 - 1e-6
+        if do_update:
+            self._credit -= 1.0
+        self._credit += 1.0 / self.delay
+        return do_update
+
+    def observe(self, td_error: float) -> None:
+        """Record the TD error of one critic update."""
+        if self._mode == "fixed":
+            return
+        self._window_sum += td_error
+        self._window_count += 1
+        if self._window_count < self._interval:
+            return
+        error = self._window_sum / self._window_count
+        self._window_sum, self._window_count = 0.0, 0
+        self.ema = error if self.ema is None else self._beta * self.ema + (1 - self._beta) * error
+        self.ratio = error / (self.ema + 1e-8)
+        self.delay = self._clip(self._scale * self.ratio)
+
+    def state_dict(self) -> dict[str, Any]:
+        keys = ("delay", "ratio", "ema", "_window_sum", "_window_count", "_credit")
+        return {key: getattr(self, key) for key in keys}
+
+    def load_state_dict(self, state: dict[str, Any]) -> None:
+        for key, value in state.items():
+            setattr(self, key, value)
diff --git a/flash_rl/agents/flashSAC/agent.py b/flash_rl/agents/flashSAC/agent.py
index 254e6f5..392119e 100644
--- a/flash_rl/agents/flashSAC/agent.py
+++ b/flash_rl/agents/flashSAC/agent.py
@@ -1,7 +1,7 @@
 import math
 import os
 from dataclasses import dataclass, replace
-from typing import Any, MutableMapping, Optional, cast
+from typing import Any, Callable, MutableMapping, Optional, cast
 
 import gymnasium as gym
 import torch
@@ -9,12 +9,15 @@
 from torch.amp.grad_scaler import GradScaler
 
 from flash_rl.agents.base_agent import BaseAgent
+from flash_rl.agents.flashSAC.actor_delay import ActorDelay
 from flash_rl.agents.flashSAC.network import (
     FlashSACActor,
     FlashSACDoubleCritic,
     FlashSACTemperature,
 )
 from flash_rl.agents.flashSAC.update import (
+    compute_td_surprise,
+    pearson_corr,
     update_actor,
     update_critic,
     update_target_network,
@@ -41,6 +44,11 @@ class FlashSACConfig:
     buffer_device_type: str
     sample_batch_size: int
 
+    sampler: str  # 'uniform' | 'swd' | 'laber'
+    swd_decay_steps: int
+    swd_min_weight: float
+    laber_multiplier: int
+
     learning_rate_init: float
     learning_rate_peak: float
     learning_rate_end: float
@@ -55,6 +63,13 @@ class FlashSACConfig:
     actor_noise_zeta_mu: float
     actor_noise_zeta_max: int
     actor_update_period: int
+    actor_delay: str  # 'fixed' | 'ema'
+    actor_delay_ema_interval: int
+    actor_delay_ema_beta: float
+    actor_delay_ema_scale: float
+    actor_delay_ema_min: float
+    actor_delay_ema_max: float
+    actor_lr_schedule: str  # 'actor_step' | 'global_step'
 
     critic_num_blocks: int
     critic_hidden_dim: int
@@ -78,21 +93,35 @@ class FlashSACConfig:
     load_reward_normalizer: bool
 
 
+def _make_lr_schedule(cfg: FlashSACConfig) -> Callable[[int], float]:
+    return warmup_cosine_decay_scheduler(
+        init_value=cfg.learning_rate_init,
+        peak_value=cfg.learning_rate_peak,
+        end_value=cfg.learning_rate_end,
+        warmup_steps=cfg.learning_rate_warmup_step,
+        decay_steps=cfg.learning_rate_decay_step,
+    )
+
+
 def _init_flashsac_networks(
     actor_observation_dim: int,
     critic_observation_dim: int,
     action_dim: int,
     cfg: FlashSACConfig,
     device: torch.device,
+    global_step_fn: Optional[Callable[[], int]] = None,
 ) -> tuple[Network, Network, Network, Network]:
+    """
+    global_step_fn: if given, the actor and temperature learning rates follow this step count
+        (the number of critic updates) instead of their own number of updates.
+    """
     # Create learning rate schedule
-    warmup_cosine_decay_lr = warmup_cosine_decay_scheduler(
-        init_value=cfg.learning_rate_init,
-        peak_value=cfg.learning_rate_peak,
-        end_value=cfg.learning_rate_end,
-        warmup_steps=cfg.learning_rate_warmup_step,
-        decay_steps=cfg.learning_rate_decay_step,
-    )
+    warmup_cosine_decay_lr = _make_lr_schedule(cfg)
+
+    def actor_lr_lambda(step: int) -> float:
+        if global_step_fn is not None:
+            step = global_step_fn()
+        return warmup_cosine_decay_lr(step) / cfg.learning_rate_peak
 
     # Initialize actor
     actor_net = FlashSACActor(
@@ -104,10 +133,7 @@ def _init_flashsac_networks(
 
     use_fused = device.type == "cuda" and torch.cuda.is_available()
     actor_optimizer = optim.Adam(actor_net.parameters(), lr=cfg.learning_rate_peak, fused=use_fused)
-    actor_scheduler = torch.optim.lr_scheduler.LambdaLR(
-        actor_optimizer,
-        lr_lambda=lambda step: warmup_cosine_decay_lr(step) / cfg.learning_rate_peak,
-    )
+    actor_scheduler = torch.optim.lr_scheduler.LambdaLR(actor_optimizer, lr_lambda=actor_lr_lambda)
     actor = Network(
         network=actor_net,
         optimizer=actor_optimizer,
@@ -176,10 +202,7 @@ def _init_flashsac_networks(
         lr=cfg.learning_rate_peak,
         fused=use_fused,
     )
-    temp_scheduler = torch.optim.lr_scheduler.LambdaLR(
-        temp_optimizer,
-        lr_lambda=lambda step: warmup_cosine_decay_lr(step) / cfg.learning_rate_peak,
-    )
+    temp_scheduler = torch.optim.lr_scheduler.LambdaLR(temp_optimizer, lr_lambda=actor_lr_lambda)
     temperature = Network(
         network=temp_net,
         optimizer=temp_optimizer,
@@ -259,6 +282,7 @@ def _sample_flashsac_actions(
 
 def _update_networks(
     batch: dict[str, torch.Tensor],
+    actor_batch: dict[str, torch.Tensor],
     actor: Network,
     critic: Network,
     target_critic: Network,
@@ -274,7 +298,7 @@ def _update_networks(
             actor=actor,
             critic=critic,
             temperature=temperature,
-            batch=batch,  # type: ignore
+            batch=actor_batch,  # type: ignore
             bc_alpha=cfg.actor_bc_alpha,
             device=device,
             use_amp=cfg.use_amp,
@@ -372,6 +396,20 @@ def __init__(
         )
         self._device = torch.device(device_type)
 
+        assert cfg.sampler in ("uniform", "swd", "laber"), f"Unknown sampler: {cfg.sampler}"
+        assert cfg.actor_lr_schedule in ("actor_step", "global_step")
+        self._update_step = 0
+        self._lr_schedule = _make_lr_schedule(cfg)
+        self._actor_delay = ActorDelay(
+            mode=cfg.actor_delay,
+            period=cfg.actor_update_period,
+            interval=cfg.actor_delay_ema_interval,
+            beta=cfg.actor_delay_ema_beta,
+            scale=cfg.actor_delay_ema_scale,
+            min_delay=cfg.actor_delay_ema_min,
+            max_delay=cfg.actor_delay_ema_max,
+        )
+
         # Initialize networks
         (
             self._actor,
@@ -384,8 +422,8 @@ def __init__(
             action_dim=self._action_dim,
             cfg=self._cfg,
             device=self._device,
+            global_step_fn=(lambda: self._update_step) if cfg.actor_lr_schedule == "global_step" else None,
         )
-        self._update_step = 0
 
         # Grad scaler for FP16 AMP
         self._grad_scaler = GradScaler(device=self._device.type, enabled=self._cfg.use_amp)
@@ -419,6 +457,10 @@ def __init__(
             min_length=self._cfg.buffer_min_length,
             sample_batch_size=self._cfg.sample_batch_size,
             device_type=self._cfg.buffer_device_type,
+            # LaBER draws its candidates uniformly and re-samples them in `update`
+            sampler="swd" if self._cfg.sampler == "swd" else "uniform",
+            swd_decay_steps=self._cfg.swd_decay_steps,
+            swd_min_weight=self._cfg.swd_min_weight,
         )
 
     def sample_actions(
@@ -472,8 +514,54 @@ def process_transition(self, transition: MutableMapping[str, Tensor]) -> None:
     def can_start_training(self) -> bool:
         return self._replay_buffer.can_sample()
 
+    def _select_laber_batch(
+        self, candidates: dict[str, torch.Tensor]
+    ) -> tuple[dict[str, torch.Tensor], dict[str, Any]]:
+        """
+        LaBER (https://arxiv.org/abs/2110.01528): score a large uniform batch with the current networks,
+        then draw the training batch from it with probability proportional to the score.
+        The "weight" entry is the importance weight that corrects the critic update for the selection.
+        """
+        batch_size = self._cfg.sample_batch_size
+        surprise, td_abs = compute_td_surprise(
+            actor=self._actor,
+            critic=self._critic,
+            target_critic=self._target_critic,
+            temperature=self._temperature,
+            batch=candidates,  # type: ignore
+            min_v=self._cfg.critic_min_v,
+            max_v=self._cfg.critic_max_v,
+            num_bins=self._cfg.critic_num_bins,
+            gamma=self._cfg.gamma,
+            n_step=self._cfg.n_step,
+            device=self._device,
+            use_amp=self._cfg.use_amp,
+        )
+        priorities = surprise + 1e-6
+        idxs = torch.multinomial(priorities, batch_size, replacement=True)
+        batch = {k: v[idxs] for k, v in candidates.items()}
+        weights = priorities.mean() / priorities[idxs]
+        batch["weight"] = weights
+
+        info = {
+            # the candidates are a uniform sample of the buffer
+            "laber/candidate_surprise_mean": surprise.mean(),
+            "laber/candidate_surprise_max": surprise.max(),
+            "laber/candidate_td_abs": td_abs.mean(),
+            "laber/candidate_age_mean": candidates["age"].mean(),
+            "laber/candidate_age_surprise_corr": pearson_corr(candidates["age"], surprise),
+            # how concentrated the selection is
+            "laber/weight_max": weights.max(),
+            "laber/effective_sample_frac": weights.sum() ** 2 / (weights.square().sum() * batch_size),
+            "laber/unique_frac": torch.unique(idxs).numel() / batch_size,
+        }
+        return batch, info
+
     def update(self) -> dict[str, Any]:
-        batch = cast(dict[str, torch.Tensor], self._replay_buffer.sample())
+        batch_size = self._cfg.sample_batch_size
+        use_laber = self._cfg.sampler == "laber"
+        num_samples = batch_size * self._cfg.laber_multiplier if use_laber else batch_size
+        batch = cast(dict[str, torch.Tensor], self._replay_buffer.sample(batch_size=num_samples))
 
         for k, v in batch.items():
             batch[k] = v.to(self._device, non_blocking=True)
@@ -490,28 +578,60 @@ def update(self) -> dict[str, Any]:
             # batch["unnormalized_reward"] = batch["reward"].clone()
             batch["reward"] = self.reward_normalizer.normalize_rewards(batch["reward"])
 
+        # The actor trains on the same batch as the critic, except under LaBER: there the critic gets the
+        # high-surprise selection and the actor a uniform slice of the candidates, so the policy objective
+        # needs no importance weights.
+        actor_batch = batch
+        sampler_info: dict[str, Any] = {}
+        if use_laber:
+            actor_batch = {k: v[:batch_size] for k, v in batch.items()}
+            batch, sampler_info = self._select_laber_batch(batch)
+
         # Update step
+        do_actor_update = self._actor_delay.should_update_actor(self._update_step)
+        if do_actor_update and self._cfg.actor_lr_schedule == "global_step":
+            # schedulers only refresh the learning rate after an optimizer step, i.e. one actor delay ago
+            lr = self._lr_schedule(self._update_step)
+            for network in (self._actor, self._temperature):
+                assert network.optimizer is not None
+                for param_group in network.optimizer.param_groups:
+                    param_group["lr"] = lr
         _update_info = _update_networks(
             batch=batch,
+            actor_batch=actor_batch,
             actor=self._actor,
             critic=self._critic,
             target_critic=self._target_critic,
             temperature=self._temperature,
             cfg=self._cfg,
-            do_actor_update=(self._update_step % self._cfg.actor_update_period == 0),
+            do_actor_update=do_actor_update,
             device=self._device,
             grad_scaler=self._grad_scaler,
         )
         self._update_step += 1
+        _update_info.update(sampler_info)
 
-        # Convert tensors to floats
+        # Convert tensors to floats (a single device sync for all of them)
         update_info: dict[str, float] = {}
+        tensor_keys = [k for k, v in _update_info.items() if isinstance(v, torch.Tensor)]
+        if tensor_keys:
+            values = torch.stack([_update_info[k].detach().float().reshape(()) for k in tensor_keys]).tolist()
+            update_info.update(zip(tensor_keys, values))
         for key, value in _update_info.items():
-            if isinstance(value, torch.Tensor):
-                update_info[key] = value.item()
-            elif not isinstance(value, dict):
+            if not isinstance(value, (torch.Tensor, dict)):
                 update_info[key] = float(value)
 
+        # Actor delay
+        self._actor_delay.observe(update_info["critic/td_abs"])
+        update_info["actor_delay/delay"] = self._actor_delay.delay
+        update_info["actor_delay/td_ratio"] = self._actor_delay.ratio
+        if self._actor_delay.ema is not None:
+            update_info["actor_delay/td_ema"] = self._actor_delay.ema
+        update_info["actor_delay/actor_updated"] = float(do_actor_update)
+        update_info["actor/learning_rate"] = self._actor.optimizer.param_groups[0]["lr"]  # type: ignore
+        update_info["critic/learning_rate"] = self._critic.optimizer.param_groups[0]["lr"]  # type: ignore
+        update_info["replay/size"] = float(len(self._replay_buffer))
+
         return update_info
 
     def save(self, path: str) -> None:
@@ -526,6 +646,7 @@ def save(self, path: str) -> None:
         agent_state: dict[str, Any] = {
             "update_step": self._update_step,
             "grad_scaler_state_dict": self._grad_scaler.state_dict(),
+            "actor_delay_state_dict": self._actor_delay.state_dict(),
         }
         torch.save(agent_state, os.path.join(path, "agent_state.pt"))
         print(f"\033[32m[FlashSAC]\033[0m Successfully saved checkpoint {self._update_step} at {path}.")
@@ -548,6 +669,8 @@ def load(self, path: str) -> None:
             agent_state = torch.load(agent_state_path, map_location=self._device)
             self._update_step = agent_state["update_step"]
             self._grad_scaler.load_state_dict(agent_state["grad_scaler_state_dict"])
+            if "actor_delay_state_dict" in agent_state:
+                self._actor_delay.load_state_dict(agent_state["actor_delay_state_dict"])
 
         if self._cfg.load_reward_normalizer:
             assert self.reward_normalizer is not None
diff --git a/flash_rl/agents/flashSAC/layer.py b/flash_rl/agents/flashSAC/layer.py
index 0c9f4fe..7572ebf 100644
--- a/flash_rl/agents/flashSAC/layer.py
+++ b/flash_rl/agents/flashSAC/layer.py
@@ -1,4 +1,5 @@
 import math
+from typing import Optional
 
 import torch
 import torch.nn as nn
@@ -194,10 +195,22 @@ def __init__(self, num_ensemble: int, input_dim: int, momentum: float = 0.01, ep
         self.register_buffer("running_mean", torch.zeros(num_ensemble, input_dim))
         self.register_buffer("running_var", torch.ones(num_ensemble, input_dim))
 
-    def forward(self, x: torch.Tensor, training: bool) -> torch.Tensor:
+    def forward(self, x: torch.Tensor, training: bool, sample_weights: Optional[torch.Tensor] = None) -> torch.Tensor:
+        """
+        sample_weights: (B,) importance weights of a non-uniformly sampled batch. The batch statistics are
+            then weighted so that they estimate the statistics of uniformly sampled data.
+        """
         if training:
-            mean = x.mean(dim=1, keepdim=True)
-            var = x.var(dim=1, correction=0, keepdim=True)
+            if sample_weights is None:
+                mean = x.mean(dim=1, keepdim=True)
+                var = x.var(dim=1, correction=0, keepdim=True)
+            else:
+                # float32: the normalized weights are too small for FP16 AMP
+                w = (sample_weights.float() / sample_weights.float().sum()).view(1, -1, 1)
+                x32 = x.float()
+                mean32 = (x32 * w).sum(dim=1, keepdim=True)
+                var32 = ((x32 - mean32).square() * w).sum(dim=1, keepdim=True)
+                mean, var = mean32.to(x.dtype), var32.to(x.dtype)
             with torch.no_grad():
                 B = x.shape[1]
                 # Cast to float32 for running stats (BatchNorm uses float32 even in AMP)
@@ -241,8 +254,8 @@ def __init__(self, num_ensemble: int, input_dim: int, hidden_dim: int):
         self.norm = EnsembleUnitBatchNorm(num_ensemble, input_dim)
         self.w = EnsembleUnitLinear(num_ensemble, input_dim, hidden_dim)
 
-    def forward(self, x: torch.Tensor, training: bool) -> torch.Tensor:
-        x = self.norm(x, training=training)
+    def forward(self, x: torch.Tensor, training: bool, sample_weights: Optional[torch.Tensor] = None) -> torch.Tensor:
+        x = self.norm(x, training=training, sample_weights=sample_weights)
         x = self.w(x)
         return x
 
@@ -255,13 +268,13 @@ def __init__(self, num_ensemble: int, hidden_dim: int, expansion: int = 4):
         self.norm1 = EnsembleUnitBatchNorm(num_ensemble, hidden_dim * expansion)
         self.norm2 = EnsembleUnitBatchNorm(num_ensemble, hidden_dim)
 
-    def forward(self, x: torch.Tensor, training: bool) -> torch.Tensor:
+    def forward(self, x: torch.Tensor, training: bool, sample_weights: Optional[torch.Tensor] = None) -> torch.Tensor:
         residual = x
         x = self.w1(x)
-        x = self.norm1(x, training=training)
+        x = self.norm1(x, training=training, sample_weights=sample_weights)
         x = F.relu(x)
         x = self.w2(x)
-        x = self.norm2(x, training=training)
+        x = self.norm2(x, training=training, sample_weights=sample_weights)
         x = F.relu(x)
         x = x + residual
         return x
diff --git a/flash_rl/agents/flashSAC/network.py b/flash_rl/agents/flashSAC/network.py
index 7ce086d..521c298 100644
--- a/flash_rl/agents/flashSAC/network.py
+++ b/flash_rl/agents/flashSAC/network.py
@@ -1,4 +1,5 @@
 import math
+from typing import Optional
 
 import torch
 import torch.nn as nn
@@ -94,12 +95,14 @@ def forward(
         observations: torch.Tensor,
         actions: torch.Tensor,
         training: bool,
+        sample_weights: Optional[torch.Tensor] = None,
     ) -> tuple[torch.Tensor, dict[str, torch.Tensor]]:
+        """sample_weights: optional (B,) importance weights for the BatchNorm statistics (training only)."""
         x = torch.cat((observations, actions), dim=-1)  # [B, in_dim]
         x = x.unsqueeze(0).expand(self.num_qs, -1, -1)  # [num_qs, B, in_dim]
-        x = self.embedder(x, training)
+        x = self.embedder(x, training, sample_weights)
         for block in self.encoder:
-            x = block(x, training)
+            x = block(x, training, sample_weights)
         x = self.post_norm(x)
         qs, infos = self.predictor(x, training)
         return qs, infos
diff --git a/flash_rl/agents/flashSAC/update.py b/flash_rl/agents/flashSAC/update.py
index 2686b06..b2fe18a 100644
--- a/flash_rl/agents/flashSAC/update.py
+++ b/flash_rl/agents/flashSAC/update.py
@@ -1,4 +1,4 @@
-from typing import Any, Optional
+from typing import Any, Optional, cast
 
 import torch
 from torch.amp.grad_scaler import GradScaler
@@ -78,6 +78,83 @@ def _compute_categorical_td_target(
     return target_probs
 
 
+def _td_surprise(
+    pred_qs: torch.Tensor,  # (2, B)
+    pred_log_probs: torch.Tensor,  # (2, B, num_bins)
+    target_probs: torch.Tensor,  # (B, num_bins)
+    min_v: float,
+    max_v: float,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Per-sample critic error, averaged over the two critics. Both outputs have shape (B,).
+
+    surprise: ||softmax(logits) - target_probs||_2, the norm of the cross-entropy gradient w.r.t. the logits.
+    td_abs: |E[Z] - E[target]|, the absolute TD error between the distribution means.
+    """
+    target_probs = target_probs.float()
+    surprise = (pred_log_probs.float().exp() - target_probs.unsqueeze(0)).norm(dim=-1).mean(dim=0)
+    bin_values = torch.linspace(min_v, max_v, target_probs.shape[-1], device=target_probs.device)
+    target_qs = (target_probs * bin_values).sum(dim=-1)
+    td_abs = (pred_qs.float() - target_qs.unsqueeze(0)).abs().mean(dim=0)
+    return surprise, td_abs
+
+
+def pearson_corr(x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:
+    x = x - x.mean()
+    y = y - y.mean()
+    corr: torch.Tensor = (x * y).sum() / (x.norm() * y.norm() + 1e-8)
+    return corr
+
+
+@torch.no_grad()
+def compute_td_surprise(
+    actor: Network,
+    critic: Network,
+    target_critic: Network,
+    temperature: Network,
+    batch: Batch,
+    min_v: float,
+    max_v: float,
+    num_bins: int,
+    gamma: float,
+    n_step: int,
+    device: torch.device,
+    use_amp: bool,
+) -> tuple[torch.Tensor, torch.Tensor]:
+    """
+    Score a batch for LaBER without training on it. Returns per-sample (surprise, td_abs), see `_td_surprise`.
+
+    Networks run with training=False so that scoring does not touch the BatchNorm running statistics.
+    """
+    with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp):
+        next_actions, info = actor(observations=batch["actor_next_observation"], training=False)
+        # Clone variables to prevent overwriting
+        next_actions = next_actions.clone()
+        next_actor_entropy = temperature() * info["log_prob"].clone()
+
+        next_qs, next_q_infos = target_critic(
+            observations=batch["next_observation"],
+            actions=next_actions,
+            training=False,
+        )
+        target_probs = _compute_categorical_td_target(
+            target_log_probs=_select_min_q_log_probs(next_qs, next_q_infos["log_prob"]),
+            reward=batch["reward"],  # type: ignore
+            done=batch["terminated"],  # type: ignore
+            actor_entropy=next_actor_entropy,
+            gamma=gamma**n_step,
+            num_bins=num_bins,
+            min_v=min_v,
+            max_v=max_v,
+        )
+        pred_qs, pred_q_infos = critic(
+            observations=batch["observation"],
+            actions=batch["action"],
+            training=False,
+        )
+    return _td_surprise(pred_qs, pred_q_infos["log_prob"], target_probs, min_v, max_v)
+
+
 def update_actor(
     actor: Network,
     critic: Network,
@@ -186,7 +263,8 @@ def update_critic(
         critic: Critic network.
         target_critic: Target critic network.
         temperature: Temperature network.
-        batch: Batch of transitions.
+        batch: Batch of transitions. An optional "weight" entry holds per-sample importance weights that
+            correct for non-uniform sampling. They weight the loss and the critics' BatchNorm statistics.
         min_v: Minimum value for categorical distribution.
         max_v: Maximum value for categorical distribution.
         num_bins: Number of bins for categorical distribution.
@@ -197,6 +275,10 @@ def update_critic(
         grad_scaler: GradScaler for FP16 AMP.
     """
 
+    weights = cast(Optional[torch.Tensor], batch.get("weight"))
+    # extra arguments for the critics; empty for uniform batches, so that code path is untouched
+    critic_kwargs = {} if weights is None else {"sample_weights": torch.cat([weights, weights])}
+
     with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=use_amp):
         # Compute target values
         with torch.no_grad():
@@ -220,6 +302,7 @@ def update_critic(
                 observations=obs_all,
                 actions=act_all,
                 training=True,
+                **critic_kwargs,
             )
             next_qs = qs_all.chunk(2, dim=1)[1]
             next_q_log_probs = q_infos_all["log_prob"].chunk(2, dim=1)[1]
@@ -243,12 +326,38 @@ def update_critic(
             observations=obs_all,
             actions=act_all,
             training=True,
+            **critic_kwargs,
         )
         pred_log_probs = torch.chunk(pred_q_infos["log_prob"], 2, dim=1)[0]
 
         ce_loss = -(target_probs.unsqueeze(0) * pred_log_probs).sum(dim=-1)  # (2, B)
+        if weights is not None:
+            ce_loss = ce_loss * weights
         critic_loss = ce_loss.mean()
 
+    # Diagnostics (computed before the gradient step)
+    with torch.no_grad():
+        pred_qs = pred_qs_all.chunk(2, dim=1)[0]
+        surprise, td_abs = _td_surprise(pred_qs, pred_log_probs, target_probs, min_v, max_v)
+        ages = cast(torch.Tensor, batch["age"])
+        age_quantiles = torch.quantile(ages, torch.tensor([0.5, 0.9], device=ages.device))
+        if weights is None:
+            weights = torch.ones_like(td_abs)
+        diagnostics = {
+            # weighted means: estimates over the whole buffer when importance weights are given
+            "critic/td_abs": (td_abs * weights).mean(),
+            "critic/surprise": (surprise * weights).mean(),
+            "critic/q_mean": pred_qs.float().mean(),
+            # what the critic was actually trained on
+            "replay/batch_td_abs": td_abs.mean(),
+            "replay/batch_surprise": surprise.mean(),
+            "replay/age_mean": ages.mean(),
+            "replay/age_median": age_quantiles[0],
+            "replay/age_p90": age_quantiles[1],
+            "replay/age_max": ages.max(),
+            "replay/age_surprise_corr": pearson_corr(ages, surprise),
+        }
+
     # Gradient step
     assert critic.optimizer is not None
     critic.optimizer.zero_grad(set_to_none=True)
@@ -273,6 +382,7 @@ def update_critic(
         "max_entropy_bonus": max_entropy_bonus,
     }
     update_info = add_prefix_to_keys(update_info, "critic")
+    update_info.update(diagnostics)
 
     return update_info
 
diff --git a/flash_rl/buffers/torch_buffer.py b/flash_rl/buffers/torch_buffer.py
index f6e3943..2d5bf73 100644
--- a/flash_rl/buffers/torch_buffer.py
+++ b/flash_rl/buffers/torch_buffer.py
@@ -44,7 +44,20 @@ def __init__(
         min_length: int,
         sample_batch_size: int,
         device_type: str,
+        sampler: str = "uniform",
+        swd_decay_steps: int = 2000,
+        swd_min_weight: float = 0.1,
     ):
+        """
+        sampler: "uniform", or "swd" for WarpSAC's Sample Weight Decay (recency-biased sampling).
+        swd_decay_steps: SWD decay horizon, in interaction steps (one step = one `add` call).
+        swd_min_weight: SWD weight floor for transitions older than the decay horizon.
+        """
+        assert sampler in ("uniform", "swd"), f"Unknown buffer sampler: {sampler}"
+        assert swd_decay_steps > 0 and 0.0 < swd_min_weight <= 1.0
+        self._sampler = sampler
+        self._swd_decay_steps = swd_decay_steps
+        self._swd_min_weight = swd_min_weight
         super(TorchUniformBuffer, self).__init__(
             observation_space,
             action_space,
@@ -93,6 +106,7 @@ def reset(self) -> None:
         self._n_step_transitions: deque[dict[str, Any]] = deque(maxlen=self._n_step)
         self._num_in_buffer = 0
         self._current_idx = 0
+        self._add_batch_size = 1  # transitions written per `add` call (= number of train envs)
 
     def _to_tensor(self, value: Any) -> torch.Tensor:
         """Convert a value to a tensor on the buffer device (cloned if already a tensor)."""
@@ -145,6 +159,7 @@ def add(self, transition: Batch) -> None:
             n_step_prev_transition = cast(dict[str, torch.Tensor], self._get_n_step_prev_transition())
 
             add_batch_size = len(n_step_prev_transition["observation"])
+            self._add_batch_size = add_batch_size
             end_idx = self._current_idx + add_batch_size
 
             if end_idx <= self._max_length:
@@ -166,11 +181,34 @@ def add(self, transition: Batch) -> None:
     def can_sample(self) -> bool:
         return self._num_in_buffer >= self._min_length
 
-    def sample(self, sample_idxs: Optional[NDArray] = None) -> Batch:
-        if sample_idxs is None:
-            idxs = torch.randint(0, self._num_in_buffer, (self._sample_batch_size,), device=self._device)
-        else:
+    def _sample_swd_idxs(self, batch_size: int) -> torch.Tensor:
+        """
+        Sample Weight Decay (WarpSAC, https://arxiv.org/abs/2608.24479).
+        A transition added `age` interaction steps ago is drawn with probability proportional to
+        max(swd_min_weight, 1 - age / swd_decay_steps).
+        All transitions of one `add` call share an age, so we draw the step first and then a slot within it.
+        """
+        n = self._add_batch_size
+        num_steps = -(-self._num_in_buffer // n)  # ceil: the oldest step may be partially overwritten
+        step_ages = torch.arange(1, num_steps + 1, device=self._device)  # newest step has age 1, as in WarpSAC
+        step_weights = torch.clamp(1.0 - step_ages / self._swd_decay_steps, min=self._swd_min_weight)
+        step_sizes = torch.full((num_steps,), n, device=self._device)
+        step_sizes[-1] = self._num_in_buffer - (num_steps - 1) * n
+
+        steps = torch.multinomial(step_weights * step_sizes, batch_size, replacement=True)
+        offsets = (torch.rand(batch_size, device=self._device) * step_sizes[steps]).long()
+        slot_ages = steps * n + offsets  # 0 = most recently written slot
+        idxs: torch.Tensor = (self._current_idx - 1 - slot_ages) % self._max_length
+        return idxs
+
+    def sample(self, sample_idxs: Optional[NDArray] = None, batch_size: Optional[int] = None) -> Batch:
+        batch_size = batch_size or self._sample_batch_size
+        if sample_idxs is not None:
             idxs = torch.as_tensor(sample_idxs, device=self._device)
+        elif self._sampler == "swd":
+            idxs = self._sample_swd_idxs(batch_size)
+        else:
+            idxs = torch.randint(0, self._num_in_buffer, (batch_size,), device=self._device)
 
         batch: Batch = {}
         batch["observation"] = self._observations[idxs]
@@ -179,6 +217,9 @@ def sample(self, sample_idxs: Optional[NDArray] = None) -> Batch:
         batch["terminated"] = self._terminateds[idxs]
         batch["truncated"] = self._truncateds[idxs]
         batch["next_observation"] = self._next_observations[idxs]
+        # staleness: how many interaction steps ago each transition was added (0 = newest)
+        slot_ages = (self._current_idx - 1 - idxs) % self._max_length
+        batch["age"] = (slot_ages // self._add_batch_size).float()
 
         return batch
 
@@ -199,6 +240,7 @@ def save(self, path: str) -> None:
             "next_observation": self._next_observations[:n],
             "num_in_buffer": self._num_in_buffer,
             "current_idx": self._current_idx,
+            "add_batch_size": self._add_batch_size,
         }
         torch.save(dataset, path)
 
@@ -220,6 +262,8 @@ def load(self, path: str) -> None:
 
         self._num_in_buffer = n
         self._current_idx = dataset["current_idx"]
+        # needed for ages and SWD; buffers saved before this key existed fall back to the next `add`
+        self._add_batch_size = dataset.get("add_batch_size", self._add_batch_size)
         # Note: _n_step_transitions is intentionally not saved/loaded.
         # At most (n_step - 1) in-flight transitions are lost, which is negligible.
         self._n_step_transitions.clear()
diff --git a/flash_rl/common/__init__.py b/flash_rl/common/__init__.py
index 433bc60..42d682f 100755
--- a/flash_rl/common/__init__.py
+++ b/flash_rl/common/__init__.py
@@ -1,23 +1,29 @@
 from typing import Any, Union
 
-from flash_rl.common.logger import TensorboardTrainerLogger, WandbTrainerLogger  # noqa
+from flash_rl.common.logger import CsvTrainerLogger, TensorboardTrainerLogger, WandbTrainerLogger  # noqa
 
-TrainerLogger = Union[WandbTrainerLogger, TensorboardTrainerLogger]
+TrainerLogger = Union[WandbTrainerLogger, TensorboardTrainerLogger, CsvTrainerLogger]
 
 
 def create_logger(cfg: Any) -> TrainerLogger:
     logger_type = getattr(cfg, "logger_type", "wandb")
 
+    logger: TrainerLogger
     if logger_type == "wandb":
-        return WandbTrainerLogger(cfg)
+        logger = WandbTrainerLogger(cfg)
     elif logger_type == "tensorboard":
-        return TensorboardTrainerLogger(cfg)
+        logger = TensorboardTrainerLogger(cfg)
     else:
         raise ValueError
 
+    if getattr(cfg, "log_csv", False):
+        logger = CsvTrainerLogger(cfg, logger)
+    return logger
+
 
 __all__ = [
     "WandbTrainerLogger",
     "TensorboardTrainerLogger",
+    "CsvTrainerLogger",
     "create_logger",
 ]
diff --git a/flash_rl/common/logger.py b/flash_rl/common/logger.py
index 3ba3276..871ae4f 100755
--- a/flash_rl/common/logger.py
+++ b/flash_rl/common/logger.py
@@ -1,3 +1,7 @@
+import csv
+import os
+import time
+from datetime import datetime
 from typing import Any, Optional
 
 import numpy as np
@@ -94,6 +98,49 @@ def reset(self) -> None:
         self.media_dict.clear()
 
 
+class CsvTrainerLogger:
+    """
+    Wraps another logger and mirrors every scalar it logs to `<log_dir>/metrics.csv`
+    (one row per `log_metric` call, one column per metric). The run config is saved next to it.
+    """
+
+    def __init__(self, cfg: Any, logger: Any):
+        self._logger = logger
+        timestamp = datetime.now().strftime("%m%d_%H%M%S")
+        self.log_dir = f"logs/{cfg.group_name}/{cfg.exp_name}/{cfg.env.env_name}/seed{cfg.seed}_{timestamp}"
+        os.makedirs(self.log_dir, exist_ok=True)
+        OmegaConf.save(cfg, os.path.join(self.log_dir, "config.yaml"))
+        self._path = os.path.join(self.log_dir, "metrics.csv")
+        self._columns = ["env_step", "wall_time"]
+        self._rows: list[dict[str, float]] = []
+        self._start_time = time.perf_counter()
+
+    def update_metric(self, **kwargs: Any) -> None:
+        self._logger.update_metric(**kwargs)
+
+    def log_metric(self, step: int) -> None:
+        row = {"env_step": step, "wall_time": time.perf_counter() - self._start_time}
+        row.update(self._logger.average_meter_dict.averages())
+        self._rows.append(row)
+
+        new_columns = [k for k in row if k not in self._columns]
+        self._columns += new_columns
+        # a new metric changes the header, so the file is rewritten; otherwise the row is appended
+        rewrite = bool(new_columns) or len(self._rows) == 1
+        with open(self._path, "w" if rewrite else "a", newline="") as f:
+            writer = csv.DictWriter(f, fieldnames=self._columns, restval="")
+            if rewrite:
+                writer.writeheader()
+                writer.writerows(self._rows)
+            else:
+                writer.writerow(row)
+
+        self._logger.log_metric(step)
+
+    def reset(self) -> None:
+        self._logger.reset()
+
+
 class AverageMeter:
     """
     Tracks and calculates the average and current values of a series of numbers.
diff --git a/flash_rl/envs/isaaclab.py b/flash_rl/envs/isaaclab.py
index cb85b74..d14b36a 100644
--- a/flash_rl/envs/isaaclab.py
+++ b/flash_rl/envs/isaaclab.py
@@ -1,4 +1,4 @@
-from typing import Any, Union, cast
+from typing import Any, Optional, Union, cast
 
 import gymnasium as gym
 import numpy as np
@@ -53,6 +53,10 @@ class IsaacLabVectorEnv(
         seed (int):
         action_bounds (float):
         to_numpy (bool): If True, will convert all outputs from jnp.ndarray to np.array.
+        video_dir (str): If given, the first `video_length` steps are recorded to an mp4 file in this directory.
+            Works headless (off-screen rendering).
+        video_length (int): Number of steps to record.
+        follow_robot (bool): If True, the camera follows the robot of the first environment.
     """
 
     def __init__(
@@ -64,10 +68,14 @@ def __init__(
         action_bounds: float,
         to_numpy: bool = True,
         headless: bool = True,
+        video_dir: Optional[str] = None,
+        video_length: int = 500,
+        follow_robot: bool = False,
     ):
         from isaaclab.app import AppLauncher
 
-        app_launcher = AppLauncher(headless=headless, device=device, enable_cameras=not headless)
+        record_video = video_dir is not None
+        app_launcher = AppLauncher(headless=headless, device=device, enable_cameras=record_video or not headless)
         self.simulation_app = app_launcher.app
 
         from isaaclab_tasks.utils.parse_cfg import parse_env_cfg
@@ -80,7 +88,22 @@ def __init__(
         env_cfg.seed = seed
         self.seed = seed
         self.device = device
-        self.envs = gym.make(env_name, cfg=env_cfg, render_mode=None)
+        if follow_robot:
+            env_cfg.viewer.origin_type = "asset_root"
+            env_cfg.viewer.asset_name = "robot"
+            env_cfg.viewer.env_index = 0
+        self.envs = gym.make(env_name, cfg=env_cfg, render_mode="rgb_array" if record_video else None)
+
+        self._video_recorder: Optional[Any] = None
+        if video_dir is not None:
+            self._video_recorder = gym.wrappers.RecordVideo(
+                self.envs,
+                video_folder=video_dir,
+                step_trigger=lambda step: step == 0,
+                video_length=video_length,
+                disable_logger=True,
+            )
+            self.envs = self._video_recorder
 
         self.num_envs = cast(Any, self.envs.unwrapped).num_envs
         self.max_episode_steps = cast(Any, self.envs.unwrapped).max_episode_length
@@ -184,12 +207,20 @@ def close(self, **kwargs: Any) -> None:
     def render(self) -> None:
         raise NotImplementedError("We don't support rendering for IsaacLab environments")
 
+    def finish_video(self) -> None:
+        """Write the video file if it is still being recorded (fewer than `video_length` steps were taken)."""
+        if self._video_recorder is not None and self._video_recorder.recording:
+            self._video_recorder.stop_recording()
+
 
 def make_isaaclab_env(
     env_name: str,
     num_envs: int,
     seed: int,
     headless: bool = True,
+    video_dir: Optional[str] = None,
+    video_length: int = 500,
+    follow_robot: bool = False,
 ) -> IsaacLabVectorEnv:
     if env_name not in ACTION_BOUNDS:
         print(f"Action bounds not defined for {env_name}; using default value 1.0.")
@@ -202,5 +233,8 @@ def make_isaaclab_env(
         action_bounds=action_bounds,
         to_numpy=True,
         headless=headless,
+        video_dir=video_dir,
+        video_length=video_length,
+        follow_robot=follow_robot,
     )
     return env
diff --git a/play_isaaclab.py b/play_isaaclab.py
index 3206405..d2b9b6a 100644
--- a/play_isaaclab.py
+++ b/play_isaaclab.py
@@ -43,12 +43,18 @@ def play(args: argparse.Namespace) -> None:
         torch.backends.cudnn.allow_tf32 = True
         torch.set_float32_matmul_precision("high")
 
-    # Create environment with rendering (headless=False)
+    # Create environment: Isaac Sim viewport, or headless recording to an mp4 file with --video
+    video_dir = None
+    if args.video:
+        video_dir = args.video_dir or os.path.join(checkpoint_path, "videos")
     env = make_isaaclab_env(
         env_name=cfg.env.env_name,
         num_envs=num_envs,
         seed=cfg.seed,
-        headless=False,
+        headless=args.video,
+        video_dir=video_dir,
+        video_length=args.video_length,
+        follow_robot=args.follow_robot,
     )
 
     # Create agent using config (same as train.py)
@@ -68,8 +74,11 @@ def play(args: argparse.Namespace) -> None:
     prev_transition: MutableMapping[str, Tensor] = {"next_observation": observations}
     completed_episodes = 0
     episode_returns = np.zeros(num_envs)
+    num_steps = 0
 
-    while completed_episodes < num_episodes:
+    # with --video, play for the length of the video instead of a number of episodes
+    while num_steps < args.video_length if args.video else completed_episodes < num_episodes:
+        num_steps += 1
         actions = agent.sample_actions(interaction_step=0, prev_transition=prev_transition, training=False)
         actions = np.array(actions)
         next_observations, rewards, terminateds, truncateds, infos = env.step(actions)
@@ -82,12 +91,16 @@ def play(args: argparse.Namespace) -> None:
                 completed_episodes += 1
                 print(f"Episode {completed_episodes}: return = {episode_returns[idx]:.2f}")
                 episode_returns[idx] = 0.0
-                if completed_episodes >= num_episodes:
+                if not args.video and completed_episodes >= num_episodes:
                     break
 
         observations = next_observations
         prev_transition = {"next_observation": observations}
 
+    if args.video:
+        env.finish_video()
+        print(f"Saved video to {video_dir}")
+
     env.close()
 
 
@@ -99,5 +112,9 @@ def play(args: argparse.Namespace) -> None:
     parser.add_argument("--checkpoint_path", type=str, required=True, help="Path to agent checkpoint directory")
     parser.add_argument("--num_envs", type=int, default=16, help="Number of parallel environments for visualization")
     parser.add_argument("--num_episodes", type=int, default=10, help="Number of episodes to play")
+    parser.add_argument("--video", action="store_true", help="Record an mp4 headless instead of opening the viewport")
+    parser.add_argument("--video_length", type=int, default=500, help="Number of steps to record (50 steps = 1 s)")
+    parser.add_argument("--video_dir", type=str, default=None, help="Default: <checkpoint_path>/videos")
+    parser.add_argument("--follow_robot", action="store_true", help="Camera follows the robot of environment 0")
     args = parser.parse_args()
     play(args)
diff --git a/scripts/run_humanoid.sh b/scripts/run_humanoid.sh
new file mode 100755
index 0000000..4ba6bad
--- /dev/null
+++ b/scripts/run_humanoid.sh
@@ -0,0 +1,61 @@
+#!/bin/bash
+##################################################################################
+# Project experiments: IsaacLab humanoid locomotion (G1 / H1, flat / rough)
+#
+# usage: scripts/run_humanoid.sh <exp_name> [agent overrides...]
+#
+#   scripts/run_humanoid.sh uniform_d2
+#   scripts/run_humanoid.sh swd_d2      agent.sampler=swd
+#   scripts/run_humanoid.sh laber_d2    agent.sampler=laber
+#   scripts/run_humanoid.sh uniform_d4  agent.actor_update_period=4 agent.actor_lr_schedule=global_step
+#   scripts/run_humanoid.sh uniform_ema agent.actor_delay=ema agent.actor_delay_ema_interval=100 \
+#                                       agent.actor_lr_schedule=global_step
+#
+# SEEDS and ENVS can be set in the environment, e.g. SEEDS="0 1000" ENVS="Isaac-Velocity-Flat-G1-v0".
+# Metrics are written to logs/humanoid/<exp_name>/<env_name>/seed<seed>_<time>/metrics.csv
+##################################################################################
+
+exp_name=${1:?usage: scripts/run_humanoid.sh <exp_name> [agent overrides...]}
+shift
+
+extra_overrides=()
+for override in "$@"; do
+    extra_overrides+=(--overrides "$override")
+done
+
+read -r -a seeds <<< "${SEEDS:-0 1000 2000}"
+read -r -a env_names <<< "${ENVS:-Isaac-Velocity-Flat-G1-v0 Isaac-Velocity-Rough-G1-v0 Isaac-Velocity-Flat-H1-v0 Isaac-Velocity-Rough-H1-v0}"
+
+for seed in "${seeds[@]}"; do
+    for env_name in "${env_names[@]}"; do
+        echo "$exp_name, $env_name, $seed"
+        uv run python train.py \
+            --config_name flashSAC_base \
+            --overrides group_name=humanoid \
+            --overrides exp_name=${exp_name} \
+            --overrides seed=${seed} \
+            `#=== Environment (GPU sim) ===#` \
+            --overrides env=isaaclab \
+            --overrides env.env_name=${env_name} \
+            --overrides num_env_steps=50_000_896 \
+            --overrides num_train_envs=1024 \
+            --overrides num_eval_envs=null \
+            --overrides num_record_envs=null \
+            --overrides num_eval_episodes=1024 \
+            --overrides num_record_episodes=0 \
+            `#=== Agent (GPU sim) ===#` \
+            --overrides agent=flashSAC \
+            --overrides agent.buffer_max_length=10_000_000 \
+            --overrides agent.buffer_min_length=100_000 \
+            --overrides agent.buffer_device_type='cuda' \
+            --overrides agent.sample_batch_size=2048 \
+            --overrides agent.use_amp=true \
+            --overrides updates_per_interaction_step=2 \
+            `#=== Benchmark default ===#` \
+            --overrides agent.asymmetric_observation=false \
+            --overrides gamma=0.99 \
+            --overrides n_step=3 \
+            `#=== Experiment ===#` \
+            "${extra_overrides[@]}"
+    done
+done
diff --git a/tests/test_extensions.py b/tests/test_extensions.py
new file mode 100644
index 0000000..c3b163b
--- /dev/null
+++ b/tests/test_extensions.py
@@ -0,0 +1,286 @@
+"""
+CPU tests for the project extensions (SWD / LaBER sampling, adaptive actor delay, logging).
+
+    python -m pytest tests/test_extensions.py
+"""
+
+import csv
+import os
+
+os.environ.setdefault("TORCH_COMPILE_DISABLE", "1")  # no compiler needed for the tests
+
+import gymnasium as gym
+import hydra
+import numpy as np
+import pytest
+import torch
+from omegaconf import OmegaConf
+
+from flash_rl.agents import create_agent
+from flash_rl.agents.flashSAC.actor_delay import ActorDelay
+from flash_rl.agents.flashSAC.layer import EnsembleUnitBatchNorm
+from flash_rl.buffers.torch_buffer import TorchUniformBuffer
+from flash_rl.common.logger import CsvTrainerLogger
+
+OBS_DIM, ACTION_DIM, NUM_ENVS = 5, 2, 8
+OBS_SPACE = gym.spaces.Box(-np.inf, np.inf, (NUM_ENVS, OBS_DIM), np.float32)
+ACTION_SPACE = gym.spaces.Box(-1.0, 1.0, (NUM_ENVS, ACTION_DIM), np.float32)
+
+if not OmegaConf.has_resolver("eval"):
+    OmegaConf.register_new_resolver("eval", lambda s: eval(s))
+
+
+def make_transition(step: int) -> dict[str, np.ndarray]:
+    """A transition whose observation stores the interaction step it was added at."""
+    rng = np.random.default_rng(step)
+    return {
+        "observation": np.full((NUM_ENVS, OBS_DIM), step, dtype=np.float32),
+        "action": rng.uniform(-1, 1, (NUM_ENVS, ACTION_DIM)).astype(np.float32),
+        "reward": rng.normal(size=NUM_ENVS).astype(np.float32),
+        "terminated": rng.random(NUM_ENVS) < 0.05,
+        "truncated": np.zeros(NUM_ENVS, dtype=bool),
+        "next_observation": rng.normal(size=(NUM_ENVS, OBS_DIM)).astype(np.float32),
+    }
+
+
+def make_buffer(max_length: int, **kwargs) -> TorchUniformBuffer:
+    return TorchUniformBuffer(
+        observation_space=OBS_SPACE,
+        action_space=ACTION_SPACE,
+        n_step=1,
+        gamma=0.99,
+        max_length=max_length,
+        min_length=1,
+        sample_batch_size=64,
+        device_type="cpu",
+        **kwargs,
+    )
+
+
+def make_agent(*overrides: str):
+    with hydra.initialize(version_base=None, config_path="../configs"):
+        cfg = hydra.compose(
+            "flashSAC_base",
+            overrides=[
+                "agent.device_type=cpu",
+                "agent.buffer_device_type=cpu",
+                "agent.use_compile=false",
+                "agent.use_amp=false",
+                "agent.buffer_max_length=4000",
+                "agent.buffer_min_length=100",
+                "agent.sample_batch_size=64",
+                *overrides,
+            ],
+        )
+    OmegaConf.resolve(cfg)
+    agent = create_agent(OBS_SPACE, ACTION_SPACE, {}, cfg.agent)
+    for step in range(100):
+        agent.process_transition(make_transition(step))
+    return agent
+
+
+# max_length 100 is not a multiple of NUM_ENVS: the oldest step is partially overwritten after wrap-around
+@pytest.mark.parametrize("max_length, num_steps", [(1000, 50), (96, 40), (100, 40)])
+def test_buffer_age(max_length: int, num_steps: int) -> None:
+    buffer = make_buffer(max_length)
+    for step in range(num_steps):
+        buffer.add(make_transition(step))
+    batch = buffer.sample(batch_size=5000)
+    added_at = batch["observation"][:, 0]
+    assert torch.equal(batch["age"], (num_steps - 1) - added_at)
+
+
+@pytest.mark.parametrize("max_length, num_steps", [(1000, 50), (96, 40), (100, 40)])
+def test_swd_distribution(max_length: int, num_steps: int) -> None:
+    torch.manual_seed(0)
+    decay_steps, min_weight = 8, 0.1
+    buffer = make_buffer(max_length, sampler="swd", swd_decay_steps=decay_steps, swd_min_weight=min_weight)
+    for step in range(num_steps):
+        buffer.add(make_transition(step))
+
+    # expected: every stored transition weighted by max(min_weight, 1 - age / decay_steps), newest age = 1
+    stored_age = (num_steps - 1) - buffer.get_observations()[:, 0] + 1
+    weights = torch.clamp(1 - stored_age / decay_steps, min=min_weight)
+    max_age = int(stored_age.max())
+    expected = torch.zeros(max_age + 1).index_add_(0, stored_age.long(), weights)
+    expected = expected / expected.sum()
+
+    ages = buffer.sample(batch_size=400_000)["age"] + 1
+    assert ages.max() <= max_age
+    observed = torch.bincount(ages.long(), minlength=max_age + 1) / len(ages)
+    assert torch.allclose(observed, expected, atol=3e-3)
+
+
+def test_fixed_actor_delay_matches_modulo() -> None:
+    for period in (1, 2, 4, 8):
+        delay = ActorDelay("fixed", period, interval=10, beta=0.9, scale=2.0, min_delay=1.0, max_delay=8.0)
+        for step in range(50):
+            assert delay.should_update_actor(step) == (step % period == 0)
+            delay.observe(1.0)
+        assert delay.delay == period
+
+
+def test_ema_actor_delay() -> None:
+    delay = ActorDelay("ema", 2, interval=10, beta=0.9, scale=2.0, min_delay=1.0, max_delay=8.0)
+
+    def run(td_error: float, num_steps: int) -> float:
+        updates = 0
+        for step in range(num_steps):
+            updates += delay.should_update_actor(step)
+            delay.observe(td_error)
+        return updates / num_steps
+
+    # constant error: ratio 1, so the delay stays at `scale` (FlashSAC's 2)
+    assert run(1.0, 1000) == pytest.approx(0.5)
+    assert delay.delay == pytest.approx(2.0)
+    # error spike: the actor slows down, bounded by max_delay
+    run(100.0, 10)
+    assert delay.delay == 8.0
+    assert run(100.0, 10) <= 0.2
+    # error collapse: the actor speeds up, bounded by min_delay
+    run(1e-3, 10)
+    assert delay.delay == 1.0
+    # the state survives a checkpoint
+    restored = ActorDelay("ema", 2, interval=10, beta=0.9, scale=2.0, min_delay=1.0, max_delay=8.0)
+    restored.load_state_dict(delay.state_dict())
+    assert restored.state_dict() == delay.state_dict()
+
+
+@pytest.mark.parametrize("sampler", ["uniform", "swd", "laber"])
+@pytest.mark.parametrize("actor_delay", ["fixed", "ema"])
+def test_agent_update(sampler: str, actor_delay: str) -> None:
+    agent = make_agent(
+        f"agent.sampler={sampler}",
+        f"agent.actor_delay={actor_delay}",
+        "agent.actor_delay_ema_interval=5",
+        "agent.swd_decay_steps=20",
+    )
+    infos = [agent.update() for _ in range(30)]
+    for info in infos:
+        assert all(np.isfinite(v) for v in info.values()), info
+    info = infos[-1]
+    for key in ("critic/td_abs", "critic/surprise", "replay/age_mean", "replay/age_surprise_corr", "actor_delay/delay"):
+        assert key in info
+    assert ("laber/effective_sample_frac" in info) == (sampler == "laber")
+    assert ("actor_delay/td_ema" in info) == (actor_delay == "ema")
+    if actor_delay == "fixed":
+        assert sum("actor/loss" in i for i in infos) == 15
+
+
+def test_laber_selection() -> None:
+    torch.manual_seed(0)
+    agent = make_agent("agent.sampler=laber", "agent.laber_multiplier=8")
+    candidates = agent._replay_buffer.sample(batch_size=512)
+    candidates["actor_observation"] = candidates["observation"]
+    candidates["actor_next_observation"] = candidates["next_observation"]
+    batch, info = agent._select_laber_batch(dict(candidates))
+
+    assert batch["observation"].shape == (64, OBS_DIM)
+    assert batch["weight"].shape == (64,)
+    assert 0.0 < float(info["laber/effective_sample_frac"]) <= 1.0
+    assert 0.0 < info["laber/unique_frac"] <= 1.0
+
+    # importance weights have mean 1 in expectation, i.e. the weighted critic loss is unbiased
+    mean_weights = [float(agent._select_laber_batch(dict(candidates))[0]["weight"].mean()) for _ in range(300)]
+    assert np.mean(mean_weights) == pytest.approx(1.0, abs=0.02)
+
+
+def test_weighted_batchnorm_recovers_uniform_statistics() -> None:
+    torch.manual_seed(0)
+    norm = EnsembleUnitBatchNorm(num_ensemble=2, input_dim=3)
+    population = torch.randn(2, 20_000, 3).exp()  # skewed, so that prioritizing large values shifts the statistics
+    priorities = population[0].norm(dim=-1)
+    idxs = torch.multinomial(priorities, 4096, replacement=True)
+    batch, weights = population[:, idxs], priorities.mean() / priorities[idxs]
+
+    def normalized_population_mean(sample_weights):
+        norm.running_mean.zero_()
+        norm.momentum = 1.0  # running_mean becomes the batch mean used for normalization
+        norm(batch, training=True, sample_weights=sample_weights)
+        return (norm.running_mean - population.mean(dim=1)).abs().max()
+
+    assert normalized_population_mean(None) > 0.5  # selection bias
+    assert normalized_population_mean(weights) < 0.1  # corrected
+    # uniform weights reproduce the unweighted layer
+    out = norm(batch, training=True)
+    assert torch.allclose(norm(batch, training=True, sample_weights=torch.ones(4096)), out, atol=1e-4)
+
+
+def test_buffer_save_load(tmp_path) -> None:
+    buffer = make_buffer(1000, sampler="swd")
+    for step in range(50):
+        buffer.add(make_transition(step))
+    path = str(tmp_path / "buffer" / "replay_buffer.pt")
+    buffer.save(path)
+
+    loaded = make_buffer(1000, sampler="swd")
+    loaded.load(path)
+    batch = loaded.sample(batch_size=2000)
+    assert torch.equal(batch["age"], 49 - batch["observation"][:, 0])
+
+
+def test_actor_lr_schedule() -> None:
+    used = {}
+    for schedule in ("actor_step", "global_step"):
+        agent = make_agent(
+            f"agent.actor_lr_schedule={schedule}",
+            "agent.actor_update_period=4",
+            "agent.learning_rate_decay_step=40",
+            "agent.learning_rate_warmup_step=0",
+        )
+        # record the learning rate each optimizer actually steps with
+        lrs: dict[str, list[float]] = {"actor": [], "critic": []}
+        for name, network in (("actor", agent._actor), ("critic", agent._critic)):
+            optimizer = network.optimizer
+
+            def step(*args, _name=name, _optimizer=optimizer, _step=optimizer.step, **kwargs):
+                lrs[_name].append(_optimizer.param_groups[0]["lr"])
+                return _step(*args, **kwargs)
+
+            optimizer.step = step
+        for _ in range(37):
+            agent.update()
+        used[schedule] = lrs
+
+    # global_step: every actor update uses exactly the critic's learning rate of that update
+    assert used["global_step"]["actor"] == pytest.approx(used["global_step"]["critic"][::4], rel=1e-9)
+    # actor_step (FlashSAC): the actor's schedule advances 4x slower than the critic's
+    assert used["actor_step"]["actor"] == pytest.approx(used["actor_step"]["critic"][:10], rel=1e-9)
+
+
+def test_csv_logger(tmp_path, monkeypatch) -> None:
+    monkeypatch.chdir(tmp_path)
+
+    class DummyLogger:
+        def __init__(self) -> None:
+            self.metrics: dict[str, float] = {}
+
+        @property
+        def average_meter_dict(self):
+            return self
+
+        def averages(self) -> dict[str, float]:
+            return dict(self.metrics)
+
+        def update_metric(self, **kwargs) -> None:
+            self.metrics.update(kwargs)
+
+        def log_metric(self, step: int) -> None:
+            pass
+
+        def reset(self) -> None:
+            self.metrics = {}
+
+    cfg = OmegaConf.create({"group_name": "g", "exp_name": "e", "seed": 0, "env": {"env_name": "Env"}})
+    logger = CsvTrainerLogger(cfg, DummyLogger())
+    for step, metrics in enumerate([{"a": 1.0}, {"a": 2.0}, {"a": 3.0, "b": 4.0}, {"b": 5.0}]):
+        logger.update_metric(**metrics)
+        logger.log_metric(step)
+        logger.reset()
+
+    with open(os.path.join(logger.log_dir, "metrics.csv")) as f:
+        rows = list(csv.DictReader(f))
+    assert [r["env_step"] for r in rows] == ["0", "1", "2", "3"]
+    assert [r["a"] for r in rows] == ["1.0", "2.0", "3.0", ""]
+    assert [r["b"] for r in rows] == ["", "", "4.0", "5.0"]
+    assert os.path.exists(os.path.join(logger.log_dir, "config.yaml"))
diff --git a/train.py b/train.py
index ae97948..326dec6 100755
--- a/train.py
+++ b/train.py
@@ -10,6 +10,7 @@
 import argparse
 import random
 import sys
+import time
 from datetime import datetime
 from typing import Optional
 
@@ -116,11 +117,54 @@ def run(args: argparse.Namespace) -> None:
     update_counter = 0
     update_info = {}
 
+    # wall-clock accounting (seconds) and update counts, logged with every metrics row
+    times = {"collect": 0.0, "update": 0.0, "eval": 0.0}
+    num_updates = 0
+    num_actor_updates = 0
+    train_start = time.perf_counter()
+
+    def run_evaluation(env_step: int) -> None:
+        start = time.perf_counter()
+        eval_info = evaluate(agent, eval_env, cfg.num_eval_episodes, cfg.env.env_type)
+        times["eval"] += time.perf_counter() - start
+        logger.update_metric(**eval_info)
+        # when exactly this evaluation happened (rows are only written every logging interval)
+        logger.update_metric(
+            eval_env_step=env_step,
+            eval_train_time=time.perf_counter() - train_start - times["eval"],
+            eval_num_updates=num_updates,
+        )
+
+    def run_recording() -> None:
+        start = time.perf_counter()
+        video_info = record_video(agent, record_env, cfg.num_record_episodes, cfg.env.env_type)
+        times["eval"] += time.perf_counter() - start
+        logger.update_metric(**video_info)
+
+    def log_progress(env_step: int) -> None:
+        elapsed = time.perf_counter() - train_start
+        train_time = elapsed - times["eval"]
+        progress = {
+            "time/train_time": train_time,  # wall-clock without evaluation / video recording
+            "time/collect_time": times["collect"],
+            "time/update_time": times["update"],
+            "time/eval_time": times["eval"],
+            "time/env_steps_per_sec": env_step / max(train_time, 1e-8),
+            "train/num_updates": num_updates,
+            "train/num_actor_updates": num_actor_updates,
+        }
+        if torch.cuda.is_available():
+            progress["time/gpu_max_memory_gb"] = torch.cuda.max_memory_allocated() / 1e9
+        logger.update_metric(**progress)
+        logger.log_metric(step=env_step)
+        logger.reset()
+
     for interaction_step in tqdm.tqdm(range(1, int(cfg.num_interaction_steps + 1)), smoothing=0.1, mininterval=0.5):
         # using env steps simplifies the comparison with the performance reported in the paper.
         env_step = interaction_step * cfg.num_train_envs
 
         # collect data. use random actions until agent.can_start_training()
+        collect_start = time.perf_counter()
         if agent.can_start_training() and transition is not None:
             actions = agent.sample_actions(interaction_step, prev_transition=transition, training=True)
         else:
@@ -148,20 +192,24 @@ def run(args: argparse.Namespace) -> None:
         agent.process_transition(transition)
         transition["next_observation"] = next_observations
         observations = next_observations
+        times["collect"] += time.perf_counter() - collect_start
 
         if agent.can_start_training():
             # update network
             # updates_per_interaction_step can be below 1.0
+            update_start = time.perf_counter()
             update_counter += cfg.updates_per_interaction_step
             while update_counter >= 1:
                 update_info = agent.update()
                 logger.update_metric(**update_info)
                 update_counter -= 1
+                num_updates += 1
+                num_actor_updates += "actor/loss" in update_info
+            times["update"] += time.perf_counter() - update_start
 
             # evaluation
             if cfg.evaluation_per_interaction_step and interaction_step % cfg.evaluation_per_interaction_step == 0:
-                eval_info = evaluate(agent, eval_env, cfg.num_eval_episodes, cfg.env.env_type)
-                logger.update_metric(**eval_info)
+                run_evaluation(env_step)
 
             # metrics
             if cfg.metrics_per_interaction_step and interaction_step % cfg.metrics_per_interaction_step == 0:
@@ -170,13 +218,11 @@ def run(args: argparse.Namespace) -> None:
 
             # video recording
             if cfg.recording_per_interaction_step and interaction_step % cfg.recording_per_interaction_step == 0:
-                video_info = record_video(agent, record_env, cfg.num_record_episodes, cfg.env.env_type)
-                logger.update_metric(**video_info)
+                run_recording()
 
             # logging
             if cfg.logging_per_interaction_step and interaction_step % cfg.logging_per_interaction_step == 0:
-                logger.log_metric(step=env_step)
-                logger.reset()
+                log_progress(env_step)
 
             # checkpointing
             if (
@@ -192,12 +238,9 @@ def run(args: argparse.Namespace) -> None:
                 agent.save_replay_buffer(save_path)
 
     # final evaluation
-    eval_info = evaluate(agent, eval_env, cfg.num_eval_episodes, cfg.env.env_type)
-    video_info = record_video(agent, record_env, cfg.num_record_episodes, cfg.env.env_type)
-    logger.update_metric(**eval_info)
-    logger.update_metric(**video_info)
-    logger.log_metric(step=env_step)
-    logger.reset()
+    run_evaluation(env_step)
+    run_recording()
+    log_progress(env_step)
 
     train_env.close()
     eval_env.close()