The KITScenes dataset is provided to you under a Creative Commons Attribution-NonCommercial 4.0 International Public License (CC BY-NC 4.0), with the additional terms included herein. When you download or use the dataset, you are agreeing to comply with the terms of CC BY-NC 4.0 as applicable, and also agreeing to the dataset terms (listed below). Where these dataset terms conflict with the terms of CC BY-NC 4.0, these dataset terms shall prevail.

Dataset terms:

In case you use the dataset within your research papers, you refer to at least one of our publications listed below. If the dataset is used in media, a link to our websites (kitscenes.com) is included.
We take steps to protect the privacy of individuals by anonymizing faces and license plates using state-of-the-art anonymization software from BrighterAI. To the extent that you like to request removal of specific images/data frames from the dataset, please contact info@mrt.kit.edu.
We reserve all rights that are not explicitly granted to you. The dataset is provided as is, and you take full responsibility for any risk of using it.

Publications:

Wagner et al.: LongTail Driving Scenarios with Reasoning Traces: The KITScenes LongTail Dataset. In arXiv, 2026

KITScenes LongTail Dataset

Handling rare events is the central open challenge in autonomous driving. Reasoning models, which generate explicit chains of reasoning before acting, promise to generalize to such events. Here we show that these models frequently do not follow their own reasoning: the actions they state in their reasoning often diverge from the actions they ultimately execute (see figure below). We introduce KITScenes LongTail, a curated dataset of rare driving scenarios to quantify this divergence through a measure of semantic reasoning-action coherence and pseudo-simulation. We find that incoherence is widespread across current general-purpose and domain-specific models. Strikingly, when reasoned actions and executed actions disagree, the reasoning is usually right: extracting actions from the reasoning trace and executing them through a kinematic model enforces coherence and typically improves motion planning. These results suggest that the reasoning capabilities of current models exceed what their actions reveal, and that coherently acting on stated reasoning is a prerequisite for trustworthy autonomous driving.

Scenarios

We collected our data over the course of two years, beginning in late 2023. Our recordings include urban and suburban environments, as well as highways (the main locations are Karlsruhe, Heidelberg, Mannheim and the Black Forest). We adjusted our routes to include many construction zones and intersections. In particular, we filtered for rare events such as adverse weather conditions (heavy rain, snow, fog), road closures, and accidents. Consequently, our dataset encompasses scenarios that diverge from nominal data distributions (i.e., long-tail scenarios). Overall, our dataset contains one thousand 9s-long scenarios that are divided into three splits: train (500), test (400), and validation (100).

In addition to specifically selected challenging scenarios, adverse weather, and construction zones, we use the Pareto principle to determine further long-tail data. Specifically, we use the well-established nuScenes dataset (Caesar et al., 2020) as reference and rank-frequency plots with a 80% cumulative frequency threshold to define long-tail data. In nuScenes approx. 88% of the scenarios are recorded during the day, thus nighttime scenarios are long-tail data. For maneuver types, driving straight and regular turns account for approx. 90% of nuScenes. Therefore, overtaking and lane changing are part of the remaining long-tail. As an exception, we also include nominal driving at intersections to better evaluate instruction following since there are more viable trajectories than in most long-tail scenarios.

Our dataset contains multi-view video data with a 360° horizontal field of view (FoV) and six viewing angles (see (a) to (f) in the video below). Furthermore, we perform frame-wise image stitching (see Fig. 9 in our paper). Our stitching method introduces gradual image warping to generate 360° views.

Metrics

Semantic reasoning-action coherence (SRAC)

We use Rocchio classification and sentence embeddings to measure semantic coherence between reasoning traces and planned trajectories. We define semantic reasoning-action coherence (SRAC) as how well the driving actions described in the reasoning traces match the actions in the planned future trajectory. We apply heuristics to classify the driving actions (i.e., steering and acceleration commands) of a given planned trajectory. Then, we generate embeddings of the corresponding segment of reasoning traces using EmbeddingGemma 0.3B. Afterwards, we perform Rocchio classification on these embeddings, comparing them to reference embeddings that represent all possible driving actions according to our taxonomy.

Python implementation of our SRAC metric

import numpy as np

from sentence_transformers import SentenceTransformer


def classify_overall_acceleration(x, y, dt=0.2):
    """Computes overall acceleration class for a trajectory."""
    vx = np.diff(x) / dt
    vy = np.diff(y) / dt
    speed = np.sqrt(vx**2 + vy**2)
    acc = np.diff(speed) / dt
    mean_acc = np.mean(acc)
    abs_acc = abs(mean_acc)

    # Average speed in km/h
    avg_speed_kmh = np.mean(speed) * 3.6

    # Thresholds for acceleration (m/s²)
    if avg_speed_kmh > 60:
        keep_thresh = 1.2
        slight_thresh = 5.0
    else:
        keep_thresh = 0.6
        slight_thresh = 2.5

    if -keep_thresh <= mean_acc <= keep_thresh:
        return "maintain the current speed"
    elif mean_acc > keep_thresh:
        if abs_acc < slight_thresh:
            return "accelerate slightly"
        else:
            return "accelerate strongly"
    else:
        if abs_acc < slight_thresh:
            return "decelerate slightly"
        else:
            return "decelerate strongly"

def classify_steering_by_lateral_offset(x, y, dt=0.2):
    """Classifies overall steering behavior by comparing the actual trajectory's final point
    to an extrapolated straight trajectory from the first two points.
    """
    x = np.asarray(x)
    y = np.asarray(y)
    if len(x) < 3:
        return "steering straight"  # Not enough points
    
    direction = np.array([x[1] - x[0], y[1] - y[0]])
    direction_unit = direction / np.linalg.norm(direction)
    trajectory_length = np.sqrt((x[-1] - x[0])**2 + (y[-1] - y[0])**2)

    extrapolated_end = np.array([x[0], y[0]]) + direction_unit * trajectory_length
    offset_vector = np.array([x[-1] - extrapolated_end[0], y[-1] - extrapolated_end[1]])

    # Project perpendicular offset magnitude (lateral deviation)
    # Positive means left, negative means right relative to the initial heading
    normal = np.array([-direction_unit[1], direction_unit[0]])
    lateral_offset = np.dot(offset_vector, normal)

    # Speed-based sensitivity
    vx = np.diff(x) / dt
    vy = np.diff(y) / dt
    avg_speed_kmh = np.mean(np.sqrt(vx**2 + vy**2)) * 3.6

    # Adaptive thresholds (in meters)
    if avg_speed_kmh > 60:
        slight_thresh = 0.2   # small offset at high speeds
        strong_thresh = 0.6
    else:
        slight_thresh = 0.5   # more tolerance at low speeds
        strong_thresh = 1.5

    abs_offset = abs(lateral_offset)

    if abs_offset < slight_thresh:
        return "steer straight"
    elif abs_offset < strong_thresh:
        return "steer slightly to the left" if lateral_offset > 0 else "steer slightly to the right"
    else:
        return "steer to the left" if lateral_offset > 0 else "steer to the right"

def roccio_classifier_topk(emb_model, text, ref_embs, criterion="cos", k=1):
    """Rocchio classifier that returns the indices of the k closest reference embeddings."""
    emb = np.asarray(emb_model.encode(text))
    if emb.ndim == 2 and emb.shape[0] == 1:
        emb = emb[0]
    if emb.ndim != 1:
        raise ValueError(f"text embedding must be 1-dimensional; got shape {emb.shape}")

    ref_embs = np.asarray(ref_embs)
    if ref_embs.ndim != 2:
        raise ValueError(
            "ref_embs must be a 2D embedding matrix or a language-keyed dict "
            f"of 2D embedding matrices; got shape {ref_embs.shape}"
        )

    if criterion == "cos":
        dist = cdist(emb[np.newaxis, :], ref_embs, metric="cosine")[0]
    elif criterion == "l2":
        dist = np.linalg.norm(ref_embs - emb, axis=1)
    else:
        raise ValueError(f"Unknown criterion: {criterion}")

    return np.argsort(dist)[:k]

ref_labels = {
    "maintain the current speed": 0,
    "accelerate slightly": 1,
    "accelerate strongly": 2,
    "decelerate slightly": 3,
    "decelerate strongly": 4,
    "steer straight": 5,
    "steer slightly to the left": 6,
    "steer to the left": 7,
    "steer slightly to the right": 8,
    "steer to the right": 9,
}

spanish_ref_labels = {
    "mantener la velocidad actual": 0,
    "acelerar ligeramente": 1,
    "acelerar fuertemente": 2,
    "desacelerar ligeramente": 3,
    "desacelerar fuertemente": 4,
    "seguir recto": 5,
    "girar ligeramente a la izquierda": 6,
    "girar a la izquierda": 7,
    "girar ligeramente a la derecha": 8,
    "girar a la derecha": 9,
}

chinese_ref_labels = {
    "保持当前速度": 0,
    "稍微加快一点": 1,
    "大幅加快": 2,
    "稍微减速": 3,
    "急剧减速": 4,
    "保持直线行驶": 5,
    "稍微向左打方向盘": 6,
    "向左转": 7,
    "稍微向右打方向盘": 8,
    "向右转": 9,
}

emb_model = SentenceTransformer("google/embeddinggemma-300m")
ref_embs = emb_model.encode(list(ref_labels.keys()))

Multi-maneuver scores (MMS) for pseudo-simulation

MMS ranks planned trajectories based on similarity to reference trajectories and comfort. For each scenario, we provide 3 reference trajectories according to the following categories (and base MMS values): Expert-like trajectory (10), wrong speed (7), neglect instruction (4), driving off road w/o crashing (1), crash (0). Unmatched trajectories get a base MMS of 3.5. As comfort penalty, we reduce the MMS value by 1 if the jerk of a planned trajectory is more than 44% higher than that of a reference trajectory. Similarly, we reduce the MMS value by 1 if the tortuosity is more than 6% higher. Further details are in our paper and the following figure shows an example.

Python implementation of our MMS metric

import numpy as np


def thresholded_similarity_separate(d_lat, d_long, thresh_lat=1.8, thresh_long=3.6):
    """Computes a distance-based similarity as in our Eq. 1."""
    lat_score = max(0, 1 - (d_lat - thresh_lat) / thresh_lat) if d_lat > thresh_lat else 1
    long_score = max(0, 1 - (d_long - thresh_long) / thresh_long) if d_long > thresh_long else 1

    return min(lat_score, long_score)

def scale_thresholds(v_x, v_y, thresh_lat=1.8, thresh_lon=3.6, v_high=11.0, v_low=1.4):
    """Scales lateral and longitudinal thresholds as descibed by Ettinger et al., 2021."""
    scale_v_x = (max(0, min(1, (v_x - v_low) / (v_high - v_low)))) / 2 + 0.5
    scale_v_y = (max(0, min(1, (v_y - v_low) / (v_high - v_low)))) / 2 + 0.5

    return thresh_lon * scale_v_x, thresh_lat * scale_v_y

def get_current_velocity(trajectory, delta_time=0.2):
    """Computes the current velocity (x and y components) from a trajectory."""
    if trajectory.shape[0] < 2:
        raise ValueError("Trajectory must have at least two time steps to calculate velocity.")
    
    displacement = trajectory[-1] - trajectory[-2]
    vx, vy = displacement / delta_time
    
    return vx, vy

def compute_average_jerk(trajectory, delta_time=0.2):
    """Computes the average jerk magnitude of a trajectory."""
    if trajectory.shape[0] < 4:
        raise ValueError("Trajectory must have at least 4 points to compute jerk.")

    velocities = np.diff(trajectory, axis=0) / delta_time
    accelerations = np.diff(velocities, axis=0) / delta_time
    jerks = np.diff(accelerations, axis=0) / delta_time

    jerk_magnitudes = np.linalg.norm(jerks, axis=1)
    avg_jerk = np.mean(jerk_magnitudes)
    
    return avg_jerk


def compute_tortuosity(trajectory):
    """Computes the tortuosity of a trajectory.
    
    Tortuosity = total path length / straight-line distance between start and end.
    """
    if trajectory.shape[0] < 2:
        raise ValueError("Trajectory must have at least two points.")
    
    # Compute path length: sum of Euclidean distances between consecutive points
    diffs = np.diff(trajectory, axis=0)
    segment_lengths = np.linalg.norm(diffs, axis=1)
    path_length = np.sum(segment_lengths)
    
    # Straight-line distance between first and last points
    start_to_end_dist = np.linalg.norm(trajectory[-1] - trajectory[0])
    
    # Avoid division by zero (when start and end points coincide)
    if start_to_end_dist == 0:
        return np.inf  # Infinite tortuosity for degenerate case
    
    tortuosity = path_length / start_to_end_dist
    return tortuosity


def _endpoint_heading(ref_traj):
    """Heading of the reference at its endpoint.

    Walks backwards past degenerate (zero-length) final segments, e.g. when
    the reference ends in a full stop. Falls back to 0.0 if the whole
    trajectory is a single point.
    """
    for t in range(len(ref_traj) - 1, 0, -1):
        seg = ref_traj[t] - ref_traj[t - 1]
        if np.linalg.norm(seg) > 1e-9:
            return np.arctan2(seg[1], seg[0])
    return 0.0


def mms_score(
    traj, past_traj, ref_traj_0, ref_traj_1, ref_traj_2, points_ref_2,
    points_ref_0=10, points_ref_1=7, thresh_tortuosity=0.06, thresh_jerk=0.44,
    thresh_lat=1.8, thresh_lon=3.6, sim_thresh=0.4, score_unmatched=3.5, delta_time=0.2,
):
    """Computes the multi-maneuver score (MMS).
    
    MMS ranks planned trajectories based on similarity to reference trajectories
    and comfort. For each scenario, we provide 3 reference trajectories according 
    to the following categories (and base MMS values): Expert-like trajectory (10),
    wrong speed (7), neglect instruction (4), driving off road w/o crashing (1),
    crash (0). Unmatched trajectories get a base MMS of 3.5.
    """
    ref_trajs = (ref_traj_0, ref_traj_1, ref_traj_2)
    ref_scores = (points_ref_0, points_ref_1, points_ref_2)

    # Velocity-dependent lat/lon thresholds (Ettinger et al. heuristic).
    v_x, v_y = get_current_velocity(past_traj[:, :2], delta_time=delta_time)
    thresh_lon, thresh_lat = scale_thresholds(v_x, v_y, thresh_lat, thresh_lon)

    # Case 1 in Eq. 2:
    v_init_expert = ref_traj_0[0]
    v_init_pred = traj[0]
    if np.dot(v_init_expert, v_init_pred) < 0.5 * np.linalg.norm(v_init_expert):
        return 0

    # Displacement at the evaluation horizon (5s), decomposed in the reference's
    # endpoint-heading frame (per the miss-rate heuristic of Ettinger et al.),
    # rotating the signed diff first and taking abs of the components after.
    sim_scores = []
    valid_idx = []  # map each sim back to its original reference index

    for i, ref_traj in enumerate(ref_trajs):
        if ref_traj is None:
            continue
        theta = _endpoint_heading(ref_traj)
        c, s = np.cos(theta), np.sin(theta)
        R = np.array([[c, s],
                      [-s, c]], dtype=float)  # rotation by -theta
        diff = traj[-1] - ref_traj[-1]
        d_lon, d_lat = np.abs(R @ diff)
        sim = thresholded_similarity_separate(d_lat, d_lon, thresh_lat, thresh_lon)
        sim_scores.append(sim)
        valid_idx.append(i)

    best = int(np.argmax(sim_scores))
    ref_idx = valid_idx[best]
    ref_traj = ref_trajs[ref_idx]
    ref_score = ref_scores[ref_idx]
    sim_score = sim_scores[best]

    # Case 2 in Eq. 2:
    if ref_score in (0, 1) and sim_score >= sim_thresh:
        return ref_score

    # Comfort penalties:
    ref_tortuosity = compute_tortuosity(ref_traj)
    tortuosity = compute_tortuosity(traj)
    tortuosity_penalty = 1 if (tortuosity - ref_tortuosity) / ref_tortuosity > thresh_tortuosity else 0

    ref_jerk = compute_average_jerk(ref_traj, delta_time)
    jerk = compute_average_jerk(traj, delta_time)
    jerk_penalty = 1 if (jerk - ref_jerk) / ref_jerk > thresh_jerk else 0

    # Cases 3 & 4 in Eq. 2:
    cp = tortuosity_penalty + jerk_penalty
    score = sim_score * (ref_score - cp)
    floor = score_unmatched - cp

    return max(score, floor)

Intrinsic and extrinsic camera parameters

Pinhole camera model

import numpy as np

camera_parameters = {
    "front": {
        "K": np.array([
            [1841.0, 0.0, 1765.0],
            [0.0, 1841.0, 1139.0],
            [0.0, 0.0, 1.0],
        ]),
        "R": np.array([
            [0.01709344, -0.99983669, 0.00586657],
            [0.00538969, -0.0057752, -0.9999688],
            [0.99983937, 0.01712452, 0.00529009],
        ]),
        "t": np.array([-0.0183397, -0.18646863, -0.20817565]),
    },
    "front_left": {
        "K": np.array([
            [1844.0, 0.0, 1764.0],
            [0.0, 1844.0, 1131.0],
            [0.0, 0.0, 1.0],
        ]),
        "R": np.array([
            [0.87490947, -0.48422726, 0.00757555],
            [0.00382071, -0.00874058, -0.9999545],
            [0.48427144, 0.87489861, -0.00579713],
        ]),
        "t": np.array([-0.00990917, -0.18619818, -0.19092926]),
    },
    "front_right": {
        "K": np.array([
            [1845.0, 0.0, 1749.0],
            [0.0, 1845.0, 1138.0],
            [0.0, 0.0, 1.0],
        ]),
        "R": np.array([
            [-8.51906736e-01, -5.23693303e-01, 4.85398655e-04],
            [1.04631263e-03, -2.62893385e-03, -9.99995998e-01],
            [5.23692486e-01, -8.51902824e-01, 2.78755405e-03],
        ]),
        "t": np.array([-0.00863543, -0.18592461, -0.22478478]),
    },
    "rear": {
        "K": np.array([
            [1845.0, 0.0, 1765.0],
            [0.0, 1845.0, 1135.0],
            [0.0, 0.0, 1.0],
        ]),
        "R": np.array([
            [-2.32531565e-02, 9.99699927e-01, -7.70433147e-03],
            [-9.34666883e-04, -7.72815425e-03, -9.99969706e-01],
            [-9.99729168e-01, -2.32452442e-02, 1.11409296e-03],
        ]),
        "t": np.array([0.01893959, -0.18635925, -0.20259226]), 
    },
    "rear_left": {
        "K": np.array([
            [1843.0, 0.0, 1769.0],
            [0.0, 1843.0, 1136.0],
            [0.0, 0.0, 1.0],
        ]),
        "R": np.array([
            [0.85288016, 0.52210461, 0.00148434],
            [0.00680007, -0.00826537, -0.99994272],
            [-0.52206244, 0.85284141, -0.01059972],
        ]),
        "t": np.array([0.00806251, -0.18614501, -0.18860823]),
    },
    "rear_right": {
        "K": np.array([
            [1847.0, 0.0, 1756.0],
            [0.0, 1847.0, 1148.0],
            [0.0, 0.0, 1.0],
        ]),
        "R": np.array([
            [-8.81148667e-01, 4.72814031e-01, 4.89123238e-03],
            [-4.20872288e-03, 2.50132715e-03, -9.99988016e-01],
            [-4.72820592e-01, -8.81158694e-01, -2.14095393e-04],
        ]),
        "t": np.array([0.01272224, -0.18561945, -0.22249366]),
    },
}

Reasoning Traces

We ask domain experts (i.e., researchers working on self-driving) with diverse cultural backgrounds (from Spain, China, and Germany) to label reasoning traces about driving actions. The experts answer five questions related to a given driving scenario and an expert-driven trajectory. The first question is open-ended, similar to the training data of VLMs, and asks annotators to describe what they notice when observing the scenario video combined with the high-level instruction. The subsequent four questions are grounded in the expert trajectory: questions two and three address the reasons behind steering and acceleration commands during the next 0 - 3s, while questions four and five focus on these commands in the last two seconds (from 3 - 5s into the future). These questions are generated using our heuristics that classify acceleration commands as slight or strong acceleration, deceleration, or maintaining speed, and steering commands as slightly or regularly steering to the left/right or going straight. Our annotations enable fine-tuning jointly on reasoning and motion planning in future work to improve progress in reasoning-action coherence.

Citation

If you use KITScenes LongTail, please cite:

@misc{wagner2026longtaildrivingscenariosreasoning,
  title={Reasoning models do not yet follow their reasoning in autonomous driving: The KITScenes LongTail Dataset},
  author={Royden Wagner and Omer Sahin Tas and Jaime Villa and Felix Hauser and Yinzhe Shen and Marlon Steiner and
          Dominik Strutz and Carlos Fernandez and Quentin Delfosse and Christoph Weinhuber and Christian Kinzig and
          Guillermo S. Guitierrez-Cabello and Hendrik Königshof and Fabian Immel and Richard Schwarzkopf and Nils
          Alexander Rack and Kevin Rösch and Kaiwen Wang and Jan-Hendrik Pauls and Martin Lauer and Igor Gilitschenski
          and Holger Caesar and Christoph Stiller},
  year={2026},
  eprint={2603.23607},
  archivePrefix={arXiv},
  primaryClass={cs.CV},
  url={https://arxiv.org/abs/2603.23607},
}

Paper: arXiv:2603.23607

Changelog

Jul 21, 2026: Version 2.0. We release the val and full train split, which includes 100 reasoning traces in English as preview. We will release more reasoning traces and stitched images in later versions.
Mar 31, 2026: Version 1.0. We release the test split and 3 training samples for few-shot evaluations. We will release the val and train splits and stitched images in later versions.

Downloads last month: 376

Total file size:

172 GB

Space using KIT-MRT/KITScenes-LongTail 1

Paper for KIT-MRT/KITScenes-LongTail

LongTail Driving Scenarios with Reasoning Traces: The KITScenes LongTail Dataset

Paper • 2603.23607 • Published Mar 24 • 21