V2V-GoT: Vehicle-to-Vehicle Cooperative Autonomous Driving with Multimodal Large Language Models and Graph-of-Thoughts

ArXiv: 2509.18053

🎯 Pitch

Cooperative autonomous driving MLLMs fail catastrophically when occlusions are simply treated as missing detections—V2V-GoT fixes this by structuring reasoning as a graph where occlusion-aware perception explicitly models what is visible, occluding, and invisible, then feeds that into planning-aware prediction. Without this graph-of-thoughts decomposition, the model cannot reliably predict occluded pedestrian trajectories, leading to significantly higher collision rates.

---

1. Executive Summary

This paper proposes a novel graph-of-thoughts reasoning framework for MLLM-based cooperative autonomous driving, introducing two specific reasoning mechanisms—occlusion-aware perception (decomposing notable-object identification into separate visible, occluding, and invisible subtasks connected by directed context edges) and planning-aware prediction (splitting future trajectory prediction into perception-based and planning-based branches that merge their outputs)—that are structured as a graph of 9 QA types across perception, prediction, and planning. The authors curate the V2V-GoT-QA dataset on top of the V2V4Real real-world cooperative driving benchmark and develop the V2V-GoT model (extending V2V-LLM with multi-timestep perception features and LLaVA-based multimodal fusion). The proposed method achieves the lowest collision rates and L2 trajectory errors among all compared fusion baselines in the final planning task, establishing that graph-of-thoughts reasoning with task-specific cooperative QA decomposition improves overall cooperative perception, prediction, and planning performance only when both the occlusion-aware perception subgraph and the planning-aware prediction subgraph are present—removing either degrades results relative to the full graph.

2. Context and Motivation

The Core Problem: Cooperative Autonomous Driving Needs Better Reasoning About Occlusion

The central problem this paper addresses is that today's autonomous vehicles are fundamentally limited by what their individual sensors can see. A self-driving car navigating a busy urban street might have its field of view completely blocked by a large truck or bus in the adjacent lane. From the car's perspective, a pedestrian stepping off the curb behind that truck is invisible — the LiDAR beams and camera pixels simply cannot penetrate the occluding vehicle. If that pedestrian enters the road, the autonomous vehicle has no way to detect them, predict their trajectory, or plan an evasive maneuver. This is not a corner case; it is a recurring scenario in dense traffic environments that existing perception systems handle poorly.

Vehicle-to-Vehicle (V2V) cooperative perception has emerged as the natural solution: if nearby connected autonomous vehicles (CAVs) share their sensor data, the truck that blocks your view might have a clear line of sight from the vehicle next to it. By fusing perception information across vehicles, the system can "see through" occlusions and detect objects that no single vehicle could observe alone. The research community has made substantial progress on the perception side of this problem — cooperative 3D object detection and tracking algorithms have been validated on real-world datasets like V2V4Real (Xu et al., 2023) — but the reasoning side remains underdeveloped. Knowing that an occluded object exists is necessary but not sufficient; the system must also integrate that knowledge into prediction and planning decisions in a structured, interpretable way.

Why This Problem Matters: Safety and Deployment Realities

The safety implications are direct and urgent. The authors open the paper by noting that "current state-of-the-art autonomous vehicles could face safety-critical situations when their local sensors are occluded by large nearby objects on the road" (Section I). This is not a hypothetical concern — any deployment of autonomous vehicles in mixed traffic with human drivers, buses, delivery trucks, and other large vehicles will encounter occlusion regularly. Without cooperative perception and the reasoning infrastructure to act on shared sensor data, these situations become inherently unsafe.

The practical deployment question is equally important: how should cooperative information be integrated into an end-to-end driving system? The prior V2V cooperative perception literature focused heavily on detection and tracking benchmarks — measuring mean Average Precision (mAP), tracking accuracy metrics, and communication cost — but stopped short of the planning task. A cooperative detector that identifies an invisible pedestrian with high accuracy is valuable, but the ultimate test is whether that identification leads to a better driving trajectory that avoids a collision. Closing this perception-to-planning gap requires a reasoning framework that explicitly connects what the system perceives (including what it learns from other vehicles) to what it predicts about object motion and what trajectory it plans for itself.

Where Prior Approaches Fall Short

The paper identifies limitations in three related but distinct lines of prior work:

Cooperative perception research stops at detection and tracking. The V2V cooperative perception community has produced substantial work on fusion architectures — early fusion (raw point cloud aggregation), intermediate fusion (feature map sharing, exemplified by CoBEVT, V2X-ViT, and AttFuse), and late fusion (object-level detection sharing). V2V4Real (Xu et al., 2023) provided the first large-scale real-world cooperative driving dataset with 7,105 training frames and 1,993 testing frames, enabling robust benchmarking. However, this line of work "focuses on perception and has not explored the planning part of autonomous driving" (Section II-A). The connection between better cooperative perception and better driving decisions remains unexamined.

LLM-based autonomous driving focuses on single-vehicle scenarios. More recent work has explored using Large Language Models and Multimodal LLMs for end-to-end driving, motivated by the belief that these models' reasoning capabilities — acquired through large-scale pretraining — can generalize to driving decision-making. GPT-driver (Mao et al., 2023, 2024) encodes ego-vehicle state and detection results as text and uses an LLM to identify notable objects and suggest trajectories. DriveLM (Sima et al., 2024) develops a graph-of-thoughts framework for MLLM-based driving, but crucially, "only for a single autonomous vehicle without V2V cooperation" (Section II-B). These systems have no mechanism to incorporate shared perception from other vehicles, which means they inherit the occlusion blindness of single-vehicle sensor suites. The graph-of-thoughts idea exists in the single-vehicle context, but its extension to cooperative driving — where the reasoning must account for information from multiple perspectives, some of which reveal objects invisible to the ego vehicle — has not been explored.

LLM-based cooperative driving uses language-only negotiation, not multimodal perception. The few works that have explored LLMs for cooperative driving (CoDrivingLLM, CoLMDriver; Fang et al., 2025; Liu et al., 2025) use LLMs purely as text-based negotiators. In these systems, each vehicle makes an independent plan, and the LLM resolves conflicts between plans through language exchange — essentially, the vehicles "talk out" who goes first at an intersection. The paper explicitly critiques this narrow application: both prior works use the LLM "as a pure language-based conflict coordinator" or "as a negotiator based on pure language" and have "not taken advantage of the multimodal understanding ability of MLLMs in their V2V cooperation modules" (Section II-C). This means the rich perceptual information that cooperative perception systems are designed to share — LiDAR feature maps, object detections with spatial coordinates, occlusion relationships — is reduced to textual descriptions, discarding the spatial and visual structure that makes cooperative perception effective.

V2V-LLM integrates multimodal perception with an MLLM but lacks structured reasoning. The most directly relevant prior work is V2V-LLM (Chiu et al., 2025), which proposes an MLLM-based cooperative driving model that fuses perception features from multiple CAVs and answers perception and planning questions. This approach takes advantage of the MLLM's multimodal understanding — the model processes LiDAR-derived features, not just text — and shows promising results on real-world V2V4Real data. However, V2V-LLM suffers from a critical limitation: "the chain-of-thoughts or graph-of-thoughts reasoning capabilities have not been explored in this prior work" (Section II-C). In V2V-LLM, the MLLM answers each question independently — there is no structured flow of reasoning where earlier analytical steps inform later ones. This matters particularly for cooperative driving because the logical dependencies are strong: you cannot predict the trajectory of an occluded object unless you first identify that object as occluded (requiring knowledge of what is occluding it), and you cannot plan a collision-free trajectory unless you first predict where all notable objects — visible and invisible — will be.

DriveLM's graph-of-thoughts is single-vehicle and lacks cooperative-specific reasoning. The paper notes that DriveLM does incorporate graph-of-thoughts reasoning — structuring perception, prediction, and planning as connected QA nodes where parent answers inform child questions. However, DriveLM's graph is designed for single-vehicle scenarios and does not include concepts central to cooperative driving: distinguishing between visible, occluding, and invisible objects; merging predictions derived from perceptual observation with predictions derived from other vehicles' explicitly shared plans; or reasoning about which objects a cooperating vehicle can see that the ego vehicle cannot. The paper's key innovation is not merely applying graph-of-thoughts to a cooperative setting, but designing the graph's QA types specifically around the structural properties of multi-vehicle perception and prediction — the occlusion-aware perceptual decomposition and the perception-vs-planning prediction split.

How This Paper Positions Itself

The paper positions itself at the intersection of two lines of work that have not yet been combined: MLLM-based cooperative autonomous driving (the paradigm from V2V-LLM) and graph-of-thoughts structured reasoning (the paradigm from DriveLM). The core claim is that bringing these together — and designing the graph's nodes and edges around the specific reasoning demands of cooperative perception — yields benefits that neither approach achieves alone. As the abstract states, "despite the potential benefit of applying graph-of-thoughts reasoning to the MLLM, this idea has not been considered by previous cooperative autonomous driving research."

The paper's positioning is additive rather than adversarial. It does not argue that V2V-LLM is wrong or that DriveLM's graph is flawed; it argues that V2V-LLM is incomplete (it lacks structured reasoning) and that DriveLM's graph design is insufficient for cooperative scenarios (it lacks occlusion-aware and planning-aware reasoning steps). The contribution is therefore the design of a graph structure that is both cooperatively-relevant and reasoning-complete.

Two design principles anchor this positioning:

1. Occlusion-aware perception (Q1–Q4): Rather than asking a single question "what notable objects are near my planned trajectory?" which conflates visible and invisible objects, the graph decomposes this into separate reasoning steps. It first identifies visible objects (Q1), then identifies the occluding objects that might block the ego vehicle's view (Q2), then uses knowledge of those occluders from Q2 as context to identify which notable objects are invisible to the ego but visible to cooperating CAVs (Q3), and finally merges visible and invisible results (Q4). The authors call this a "divide-and-conquer design" that "can potentially make it easier for the model to learn which part of the perception feature maps to focus on" (Section III-D). This is a concrete hypothesis: structured decomposition guides the MLLM's attention to the right parts of the shared feature space.

2. Planning-aware prediction (Q5–Q7): Rather than asking a monolithic "predict the future trajectories of notable objects," the graph splits prediction into two branches. Q5 asks the MLLM to predict trajectories purely from perceptual observation (current and past positions of objects seen across all CAVs' feature maps). Q6 asks the MLLM to incorporate a privileged information source: if a notable object is itself a CAV, that vehicle explicitly shares its planned future trajectory, which can serve as a more accurate prediction than anything derivable from perception alone. Q7 then merges these two predictions, with the model expected to "learn to use that CAV's planned future trajectory as its predicted future trajectory" when such planning information is available. This design explicitly models the asymmetry in cooperative driving: some objects are passive (pedestrians, non-cooperating vehicles) whose motion must be inferred from perception, while others are active cooperators who can directly communicate their intentions.

The paper also positions itself as providing infrastructure for future research. By curating V2V-GoT-QA — a dataset of 110,610 training and 31,014 testing QA pairs across 9 structured QA types — and developing the V2V-GoT model as a baseline, the authors intend to "establish the benchmark and baseline method for future comparative research on MLLM-based cooperative autonomous driving with graph-of-thoughts reasoning" (Section I). This framing acknowledges that the specific graph design proposed is one possible instantiation of a broader idea, and that the dataset enables systematic comparison of alternative graph structures.

The implicit argument throughout the introduction and related work is that cooperative autonomous driving presents reasoning challenges that are structurally different from single-vehicle driving — occlusion creates information asymmetries between vehicles, cooperative prediction can exploit both perceptual and communicative information sources, and planning must integrate evidence that arrives from multiple spatial perspectives with different reliability characteristics. A reasoning framework that does not model these structural properties — whether it lacks graph-of-thoughts entirely (V2V-LLM) or uses a graph designed for single-vehicle scenarios (DriveLM) — will underperform one that does. The paper's experiments are designed to test this argument directly, with the ablation study comparing the full graph against simplified variants that remove occlusion-aware perception and planning-aware prediction respectively.

3. Technical Approach

3.1 Reader Orientation

The paper builds a graph-of-thoughts reasoning system for MLLM-based cooperative autonomous driving—a structured pipeline where a multimodal language model answers a sequence of connected perception, prediction, and planning questions, with each answer providing context for downstream questions, specifically designed around the information asymmetries (occlusion) and communication opportunities (shared plans) that arise when multiple autonomous vehicles cooperate through V2V data sharing. The system solves the problem of converting raw shared LiDAR perception features into a collision-free driving trajectory through a carefully designed nine-question reasoning graph that decomposes the driving task into occlusion-aware subtasks—identifying what each vehicle can and cannot see before merging perspectives, and then predicting object motion using both perceptual evidence and other vehicles' explicitly communicated plans before generating a trajectory.

3.2 Big-Picture Architecture (Diagram in Words)

The system has five major components:

1. PointPillars 3D Object Detector Backbone — processes raw LiDAR point clouds from each CAV independently to produce perception feature maps (the shared representation). This is a frozen pre-trained detector; no detection head is trained.

2. Projection Layers — a set of trainable linear layers that map the PointPillars feature maps (from both current and previous timesteps, from all CAVs) into "visual tokens" compatible with the MLLM's embedding space. These are the only non-LoRA parameters trained.

3. LLaVA-based Multimodal LLM — the core reasoning engine (Vicuna language model + visual encoder interface). It receives visual tokens from the projection layers and language tokens from the question text and any parent-node context, and generates natural language answers. Training uses LoRA adapters; the base LLM weights remain frozen.

4. Graph-of-Thoughts Execution Engine — the inference-time procedure that sequences nine QA types according to a predefined directed acyclic graph (Figure 1 and 4a). At each node, the MLLM is called with the appropriate question, visual tokens, and any parent-node answers as context. The graph is: Q1 (visible notable objects) and Q2 (occluding objects) execute in parallel → Q3 (invisible notable objects) takes Q1 and Q2 answers as context → Q4 (overall notable objects) merges Q1 and Q3 → Q5 (prediction by perception) and Q6 (prediction by planning) take Q4 as context → Q7 (overall prediction) merges Q5 and Q6 → Q8 (suggested action) takes Q7 → Q9 (suggested trajectory) takes Q8.

5. V2V-GoT-QA Dataset — the curated training and evaluation data of 110,610 training and 31,014 testing QA pairs across all 9 types, built on V2V4Real by extracting ground-truth bounding boxes, trajectories, and geometric occlusion relationships.

Information flows as follows: at each timestep, all CAVs share their PointPillars feature maps (current + previous timestep) with the MLLM → the ego CAV poses a driving question → the graph execution engine runs the MLLM through the sequence of QA nodes, feeding answers forward as context → the final output is a 6-waypoint suggested trajectory for the next 3 seconds.

3.3 Roadmap for the Deep Dive

• First, the PointPillars backbone and projection layer architecture, since these define the perceptual representation that all subsequent reasoning operates on — understanding what "visual tokens" are and how multi-timestep features are integrated is prerequisite.
• Second, the LLaVA MLLM architecture and its adaptation for cooperative driving (LoRA training, multimodal fusion), since this is the engine that answers every question in the graph.
• Third, the graph-of-thoughts structure itself — the 9 QA types, their logical dependencies, and why each edge exists — since the graph is the paper's central contribution.
• Fourth, the dataset curation pipeline for each QA type (ground-truth generation, context construction, metrics), since the graph design is inseparable from how the training and evaluation data were constructed.
• Fifth, the training procedure and inference execution (how answers propagate through the graph at test time vs. training time), since the gap between training with ground-truth context and inference with model-generated context is a critical design challenge.
• Sixth, the baseline methods and how they relate architecturally to V2V-GoT, since comparing against these baselines requires understanding what architectural choices differentiate them.

3.4 Detailed, Sentence-Based Technical Breakdown

This is primarily a systems and dataset paper whose core idea is that cooperative autonomous driving benefits from a specifically-designed graph-of-thoughts reasoning structure that decomposes perception by occlusion status and prediction by information source (perceptual observation vs. planned trajectory sharing), and that an MLLM can execute this graph to produce final planning trajectories that outperform unstructured MLLM-based cooperative driving and all non-LLM fusion baselines.

---

3.4.1 PointPillars Backbone and Multi-Timestep Feature Extraction

The perceptual front-end of V2V-GoT uses PointPillars (Lang et al., 2019), a LiDAR-based 3D object detector, but critically, only its feature extraction backbone is used — the detection head is discarded. PointPillars operates by discretizing the 3D point cloud into vertical columns ("pillars") in the x-y plane, applying a simplified PointNet to the points within each pillar to produce a fixed-length feature vector per pillar, and then scattering these pillar features back into a 2D pseudo-image (a dense bird's-eye view feature map). The output is a spatial feature map where each location encodes the geometric and reflectance properties of whatever objects occupy that region of the scene.

The paper states this explicitly: "Unlike the original LLaVA that uses an image encoder, we apply a LiDAR-based 3D object detector, PointPillars, to extract perception features from each individual CAV's point cloud" (Section IV-A). The choice of PointPillars over alternatives (VoxelNet, SECOND, etc.) is not explicitly justified in the paper, but follows the precedent set by V2V-LLM and is consistent with PointPillars' status as a fast, well-established LiDAR encoder with strong real-time performance characteristics — important for a cooperative driving pipeline where latency matters.

Multi-timestep input is a key architectural difference from V2V-LLM. The paper notes: "Unlike V2V-LLM's model that only uses the perception features at the current timestep, our model uses the perception features at the current and previous timesteps from all CAVs" (Section IV-A). This means for each CAV, two feature maps are generated — the PointPillars features at time $t$ and the PointPillars features at time $t-1$ — and both are passed through the projection layers to produce visual tokens. The rationale, stated in Section I, is that this design "can better capture the temporal dynamics of the surrounding driving scenes to provide better prediction and planning performance." Temporal information matters for prediction tasks: a single frame cannot distinguish a stationary vehicle from one beginning to accelerate, but two frames capture velocity and acceleration cues implicitly through the spatial displacement of features between timesteps.

The paper does not specify the exact dimensionality of the PointPillars feature maps, the pillar resolution, or the number of PointPillars layers — these are treated as fixed architectural choices inherited from V2V-LLM and the standard PointPillars implementation. What matters for understanding V2V-GoT is that each CAV produces a fixed-size spatial feature map from its LiDAR data, and that two such maps (current + previous) are produced per CAV per query.

---

3.4.2 Projection Layers: Mapping LiDAR Features to Visual Tokens

The PointPillars feature maps are not directly compatible with the LLaVA MLLM's input space. LLaVA was designed to process image patches via a CLIP vision encoder, producing embeddings in a specific dimensional space that the language model (Vicuna) expects. To bridge this gap, V2V-GoT introduces projection layers — trainable linear transformations that map the PointPillars features into the MLLM's visual token embedding space.

The architecture (Section IV-A, Figure 3) shows that the projection layers receive the concatenated PointPillars features from all CAVs (current and previous timesteps) and output a sequence of visual tokens. The paper states: "The MLLM takes the visual tokens and the language tokens from the question and the context as input and generates the final answer in the natural language format."

The specific architecture of the projection layers is not detailed in the paper beyond being described as "project layers in the MLLM" (Section IV-A). Based on the LLaVA architecture they extend, these are likely one or more linear (fully-connected) layers with a non-linear activation, possibly with a learned positional encoding since the PointPillars features are spatially structured. The key design points are:

• All projection layer parameters are trained (along with LoRA adapters in the LLM), while the PointPillars backbone and the base LLM weights are frozen. This is stated in Section IV-B: "During training, we only train the projector layers and the LoRA parts of the model and freeze the remaining parts."
• The projection layers must handle features from variable numbers of CAVs — the training data includes multiple CAV configurations, and the projection architecture must be flexible enough to accept features from whichever CAVs are present and communicating at inference time. The paper does not specify how this variable-input problem is handled (e.g., whether there is a fixed maximum number of CAVs with padding for absent vehicles, or whether features are pooled across CAVs before projection).

Design choice rationale. The projection layer approach — rather than fine-tuning the PointPillars backbone to produce MLLM-compatible features directly — allows the authors to reuse a pre-trained PointPillars model without modification. This is practically important because PointPillars was trained on a large-scale detection dataset, and its feature representations are known to be effective for 3D object perception. Training a new LiDAR encoder from scratch alongside the MLLM would risk overfitting given the moderate size of the V2V4Real dataset (7,105 training frames) and would lose the generalization benefits of the pre-trained detector's feature space.

---

3.4.3 LLaVA MLLM Architecture and LoRA Adaptation

The multimodal reasoning core of V2V-GoT is LLaVA (Large Language and Vision Assistant; Liu et al., 2023), a widely-used architecture for connecting vision encoders to language models. Standard LLaVA consists of three components:

1. A vision encoder (typically CLIP ViT-L/14) that converts images into a sequence of visual feature vectors.
2. A projection layer (typically a single linear transformation) that maps visual features into the language model's token embedding space.
3. A language model (typically Vicuna, a fine-tuned version of LLaMA optimized for instruction following) that processes the concatenation of visual tokens and text tokens autoregressively.

V2V-GoT replaces the vision encoder with the PointPillars + projection layers pipeline described above, but otherwise preserves the LLaVA architecture. The specific language model used is not named in the paper, but following V2V-LLM and LLaVA conventions, it is likely Vicuna-7B or Vicuna-13B.

LoRA (Low-Rank Adaptation) is the parameter-efficient fine-tuning method used to adapt the frozen base LLM to the driving domain. LoRA works by adding trainable low-rank matrices to the attention layers' query, key, value, and output projections. Instead of updating the full weight matrix $W \in \mathbb{R}^{d \times k}$, LoRA adds a low-rank update:

$W' = W + \frac{\alpha}{r} \cdot B A$

where $W \in \mathbb{R}^{d \times k}$ is the frozen pre-trained weight matrix, $B \in \mathbb{R}^{d \times r}$ and $A \in \mathbb{R}^{r \times k}$ are the trainable low-rank matrices, $r \ll \min(d, k)$ is the rank (typically 8, 16, or 32), and $\alpha$ is a scaling factor.

What it computes: For each attention projection in each transformer layer, the forward pass computes the standard output $Wx$ plus a learned correction $(\alpha/r) \cdot B(Ax)$. During training, only $A$ and $B$ receive gradient updates — the original weights $W$ are frozen. The effective number of trainable parameters is $r \times (d + k)$ per weight matrix rather than $d \times k$, reducing the parameter count by orders of magnitude.

Why this form: The low-rank assumption — that the task-specific weight update $\Delta W$ has low intrinsic rank — is both empirically validated across many NLP adaptation tasks and practically essential. Full fine-tuning of a 7B-13B parameter model on 110,610 QA pairs would be computationally expensive and risk catastrophic forgetting of the general language capabilities acquired during pretraining. LoRA preserves the base model's knowledge while allowing domain-specific adaptation with a small fraction of the parameters. The paper does not specify the rank $r$ or $\alpha$ used, referencing only that they "follow the similar training settings and hyperparameters from V2V-LLM and LLaVA" (Section IV-B).

Training hyperparameters (Section IV-B): The model is trained with the Adam optimizer, starting learning rate $2 \times 10^{-5}$, batch size 32, for 10 epochs on the V2V-GoT-QA training dataset. Hardware: NVIDIA H100-80GB GPUs (the paper does not specify how many GPUs, but the batch size of 32 and model scale suggest multi-GPU training).

Why LoRA + frozen projector training? The training setup freezes everything except the projection layers and the LoRA adapters. This has two motivations: (1) it reduces the risk of overfitting on the moderate-sized V2V4Real-derived dataset, since the vast majority of the model's parameters remain at their pre-trained values, and (2) it keeps the PointPillars backbone frozen so that its detection-quality feature representations — which were trained on much larger datasets — are preserved. The projection layers learn to translate PointPillars features into a representation the MLLM can use for driving reasoning, while the LoRA adapters learn the driving-specific language patterns and reasoning chains.

---

3.4.4 Graph-of-Thoughts Structure: The Nine QA Types and Their Dependencies

This is the paper's central contribution — a specifically designed reasoning graph for cooperative autonomous driving. The graph is a directed acyclic graph (DAG) with 9 nodes, each corresponding to a specific question type, and directed edges indicating that the answer to the parent node's question is provided as text context to the child node's question. The full graph is shown in Figure 4(a).

Perception Sub-Graph: Occlusion-Aware Decomposition (Q1–Q4)

The perception sub-graph is designed around the insight that identifying notable objects near the ego vehicle's planned path is a composite task that benefits from explicit decomposition by occlusion status. The authors call this "occlusion-aware perception."

Q1: Visible Notable Objects (leaf node). The MLLM is asked to identify notable objects that are visible to the ego CAV (detected by its own PointPillars backbone) and within 10 meters of its "current planned future trajectory" — a reference trajectory defined by 6 waypoints over the next 3 seconds. The question formulation explicitly provides these waypoints as reference.

Ground-truth curation (Section III-D): For each training frame, at most 3 ground-truth objects that are (a) within 10 meters of the reference trajectory AND (b) detected by the ego CAV's individual 3D object detector are used as the ground-truth answer. The detector here is the standard PointPillars detection head applied to the ego CAV's own LiDAR — objects that this detector successfully identifies are "visible." The output is a list of object identifiers (IDs and/or categories) in natural language.

Evaluation metric: F1 score — the harmonic mean of precision and recall in identifying the correct set of notable objects. F1 treats the answer as a set prediction problem: precision penalizes false positives (claiming an object is notable when it is not), recall penalizes false negatives (missing a notable object).

Q2: Occluding Objects (leaf node, parallel with Q1). Before identifying invisible objects, the graph first identifies which objects are actively occluding the ego CAV's view. The MLLM is asked to identify the occluding objects — those large nearby objects (trucks, buses) that block the ego CAV's LiDAR lines of sight.

Ground-truth curation: At most 3 ground-truth objects "closest to the ego CAV that are not occluded by other objects" are used as the answer. The phrasing suggests a geometric computation: objects that fall within the ego CAV's sensor frustum and are the closest along each LiDAR ray, thus physically blocking the view of anything behind them. The F1 score is used as the evaluation metric.

Why Q2 exists as a separate node: The paper's design rationale is that "locating the occluding objects first may provide useful information" for the subsequent Q3 task (Section III-D). This is a form of explicit attention guidance — telling the MLLM where the occluded regions are so it knows where to look, via other CAVs' feature maps, for invisible objects.

Q3: Invisible Notable Objects (child of Q1 and Q2). This is the key cooperative perception node. The MLLM is asked to identify notable objects that are invisible to the ego CAV (not detected by the ego's individual detector) but near its planned trajectory. Crucially, the question text includes the answer from Q2 (the list of occluding objects) as input context, and during training, also the answer from Q1. The Q2 context is hypothesized to help the model focus on the occluded regions in other CAVs' feature maps.

Ground-truth curation: At most 3 ground-truth objects that are (a) within 10 meters of the ego's reference trajectory AND (b) NOT detected by the ego CAV's individual 3D object detector. These are objects that the cooperating CAVs can see but the ego cannot — the cooperative perception gap that V2V is designed to fill. F1 score is the evaluation metric.

Design rationale for Q1 context: By knowing which objects are already visible (from Q1), the model can avoid redundant identification and focus specifically on objects that are present in cooperating CAVs' feature maps but absent from the ego's.

Q4: Overall Notable Objects (child of Q1 and Q3). This is a merge node. It takes the answers from Q1 (visible notable objects) and Q3 (invisible notable objects) as input context and produces a unified list of all notable objects near the ego's trajectory. The paper describes Q4 as simply "merging" the results — the MLLM is expected to combine the two lists, resolving any overlaps or inconsistencies.

Ground-truth curation: The ground-truth is the union of Q1 and Q3 ground-truth answers — all objects within 10 meters of the reference trajectory regardless of visibility. F1 score is the evaluation metric.

Why this decomposition? The authors argue (Section III-D) that the divide-and-conquer design "can potentially make it easier for the model to learn which part of the perception feature maps to focus on in order to find the notable objects." The ablation study in Section V-C tests this claim by removing the decomposition (simplified perception graph in Figure 4b) and showing degraded performance. The hypothesized mechanism is attention guidance: Q1 trains the model to attend to the ego CAV's own features; Q2 teaches it to identify occlusion boundaries; Q3, with Q2 context, directs attention to cooperating CAVs' features specifically in the occluded regions; Q4 then simply concatenates. Without this decomposition, a single "identify all notable objects" question (Q4 without Q1–Q3 context) must learn to simultaneously locate visible objects, reason about occlusion, and find invisible objects — a harder joint optimization problem.

Prediction Sub-Graph: Planning-Aware Decomposition (Q5–Q7)

The prediction sub-graph decomposes the task of predicting notable objects' future trajectories into two information sources that the authors argue should be handled separately.

Q5: Prediction by Perception (child of Q4). The MLLM is asked to predict the future trajectories of the notable objects (identified in Q4) and classify each object's movement into one of 4 categories: moving forward, turning left, turning right, or staying at the same location. The input context includes the Q4 answer (who the notable objects are and where they currently are). This prediction process relies mainly on the perception features at current and previous timesteps from all CAVs — the model observes where each notable object was and is, and extrapolates forward.

Ground-truth curation: The ground-truth future trajectories from V2V4Real are used. Motion classification is performed by applying "heuristic threshold values on the trajectories" — the paper does not specify these thresholds, but the approach likely computes the heading change over the 3-second trajectory (to classify straight vs. turning) and the displacement magnitude (to distinguish moving from stationary). L2 error (Euclidean distance between predicted and ground-truth waypoints) is the evaluation metric for Q5.

Q6: Prediction by Planning (child of Q4). This is the paper's second major cooperative insight after occlusion-aware perception. The MLLM is asked to incorporate other CAVs' explicitly shared planned future trajectories into its predictions. If a notable object is itself a CAV, that vehicle can transmit its planned trajectory — this is a privileged information source fundamentally different from perceptual observation. The Q4 answer (notable objects list) and the other CAVs' planned trajectories are provided as context.

Ground-truth curation and evaluation: Motion classification is performed identically to Q5. Additionally, Q6 asks the model to identify whether each other CAV is a notable object or not. The evaluation metric for Q6 is binary classification accuracy on this identification task — can the model correctly determine which cooperating vehicles are relevant (within 10m of the ego's trajectory) and which are not?

Why planning-based prediction separately: The paper argues (Section III-E) that "if a notable object suddenly accelerates, decelerates, or changes directions, it may be difficult to predict its future trajectory by only observing its current and past locations and motions." Perceptual prediction (Q5) is inherently reactive — it extrapolates from observed motion. But a CAV's planned future trajectory encodes its intent, which can change abruptly (e.g., a vehicle planning to turn right may maintain straight motion until the turn initiates). The planning-aware Q6 provides a forward-looking prediction that Q5 cannot derive from perceptual data alone.

Q7: Overall Prediction (child of Q5 and Q6). This is the prediction merge node. It takes Q5's perceptually-derived predictions and Q6's planning-derived predictions as context, and produces a unified prediction for each notable object. The key expected behavior is: "If the answer of Q6 indicates that another CAV is a notable object, the model is expected to learn to use that CAV's planned future trajectory as its predicted future trajectory" (Section III-E). For non-CAV notable objects (pedestrians, non-cooperating vehicles), the Q7 output should default to the Q5 perceptual prediction.

Evaluation: L2 error on the merged prediction output. The merge logic — when to trust Q6 over Q5 — is learned by the MLLM during training, not explicitly programmed.

Planning Sub-Graph: Action Classification then Trajectory Generation (Q8–Q9)

The planning sub-graph first classifies the suggested action into discrete speed and steering categories, then uses those categories as context to generate the concrete trajectory waypoints.

Q8: Suggested Action Classification (child of Q7). The MLLM is asked to classify the ego CAV's suggested speed and steering settings, taking the Q7 overall prediction answer as context (so it knows where all notable objects are predicted to go). Speed categories (5 levels): fast, moderate, slow, very slow, stop. Steering categories (5 levels): left, slightly left, straight, slightly right, right. This follows the approach from DriveLM (Sima et al., 2024).

Ground-truth curation: Speed and steering categories are derived from the ground-truth future trajectory by applying "heuristic threshold values on the average difference between consecutive waypoint coordinates." Speed is classified by the average displacement magnitude between waypoints; steering by the cumulative heading change. The specific thresholds are not disclosed. Evaluation uses L1 error between the output and ground-truth category indices. The paper provides an example: if the model outputs "fast" (index 0) and "slightly left" (index 1) while ground truth is "very slow" (index 3) and "right" (index 4), the L1 error is:

$|\text{index}(\text{fast}) - \text{index}(\text{very slow})| + |\text{index}(\text{slightly left}) - \text{index}(\text{right})| = |0 - 3| + |1 - 4| = 6$

where the first term $|0-3| = 3$ is the speed classification error and the second term $|1-4| = 3$ is the steering classification error.

What it computes: a discrete, ordinal distance between predicted and ground-truth action categories. The L1 metric penalizes large misclassifications (predicting "fast" when "stop" is correct) more heavily than small ones (predicting "slow" when "very slow" is correct), which is appropriate for an ordinal classification where adjacent categories are more similar.

Why this form: using L1 on category indices rather than classification accuracy provides a graded error signal. Accuracy would treat all misclassifications equally — predicting "left" when ground truth is "slightly left" would get the same penalty as predicting "left" when ground truth is "right." L1 error captures the ordinal structure and preserves a finer-grained signal for downstream trajectory generation.

Q9: Suggested Trajectory (child of Q8). The terminal node of the graph. The MLLM is asked to provide the 6 waypoints of the ego CAV's suggested future trajectory for the next 3 seconds, avoiding collisions with the predicted notable objects. The Q8 action classification (speed + steering) is provided as context, along with the Q7 overall prediction.

Ground-truth curation: The ego CAV's ground-truth future trajectory from V2V4Real is used. Evaluation metrics: L2 error (Euclidean distance between predicted and ground-truth waypoints) and collision rate (percentage of predicted trajectories that result in a collision with ground-truth object positions, computed using geometric intersection checking).

Why action classification before trajectory generation: This two-step approach (Q8 → Q9) follows DriveLM's design and is motivated by the idea that classifying the high-level maneuver first provides a strong prior for the continuous trajectory generation. Rather than directly regressing 12 continuous values (6 waypoints × 2 coordinates each), the model first commits to a discrete action category, which constrains the search space and provides interpretable intermediate output. This is a form of hierarchical planning: the discrete action sets the maneuver type, and the continuous trajectory fills in the specific path consistent with that maneuver.

---

3.4.5 Dataset Curation Pipeline: From V2V4Real to V2V-GoT-QA

The V2V-GoT-QA dataset is built on V2V4Real (Xu et al., 2023), which provides 7,105 training frames and 1,993 testing frames of real-world cooperative driving scenarios with two CAVs, LiDAR point clouds, ground-truth 3D bounding boxes, and ground-truth trajectories.

Temporal sampling strategy (Section III-B): For each driving sequence in V2V4Real, QA pairs are generated only for the frame that is "3 seconds before the end of each driving sequence." This is a deliberate choice: the frame 3 seconds from the end provides exactly 3 seconds of future ground-truth trajectory for the prediction and planning tasks. Using frames from earlier in the sequence would require shorter prediction horizons or longer ground-truth trajectories than available. Using the final frame would provide no future trajectory for evaluation. The 3-second lookahead horizon is standard in the autonomous driving prediction literature.

Per-CAV curation: For each qualifying frame, one QA pair per CAV per QA type is created. Since the V2V4Real scenes typically involve two CAVs, this produces approximately $n_{\text{frames}} \times n_{\text{CAVs}} \times n_{\text{QA types}}$ total QA pairs. The resulting dataset has 110,610 training and 31,014 testing QA pairs — approximately $7105 \times 2 \times 9 \approx 127,890$ training pairs before filtering, and $1993 \times 2 \times 9 \approx 35,874$ testing pairs before filtering, with the actual numbers being lower due to frames where some QA types are inapplicable (e.g., if a scene has no occluding objects, Q2 may have no valid ground-truth).

Ground-truth generation methodology: Each QA type's ground-truth answers are generated from V2V4Real's annotations using geometric computations:

• Object visibility (Q1 vs. Q3): An object is "visible" to a CAV if it is detected by that CAV's individual PointPillars 3D object detector. This is a detector-dependent definition — an object that is geometrically visible but missed by the detector would be labeled as "invisible" in Q3. This choice means the occlusion-aware perception is training on the actual detector's strengths and weaknesses, not an idealized geometric visibility model. For deployment, this is realistic: the system must work with whatever the actual LiDAR + detector can see, not some ideal omniscient ground truth.
• Occluding objects (Q2): Defined as the objects closest to the ego CAV that are not themselves occluded. This is a ray-casting-based geometric computation: for each LiDAR beam from the ego CAV, the first hit point identifies an occluding object. Objects behind that first hit are considered occluded.
• Notable objects (Q1, Q3, Q4): Objects within a 10-meter Euclidean distance threshold from any waypoint on the ego CAV's reference trajectory (the 6-waypoint, 3-second planned future path). The 10-meter threshold is a heuristic design choice — objects farther than 10 meters from the planned path are considered non-threatening and excluded from the notable set.
• Motion classification (Q5, Q6): Heuristic thresholds on trajectory displacement and heading change, categorizing motion into forward/turn-left/turn-right/stationary. The specific threshold values are not reported.
• Action classification (Q8): Heuristic thresholds on average displacement and heading change between consecutive ground-truth waypoints, categorizing speed into 5 levels and steering into 5 levels. Threshold values are not reported.
• Prediction and planning trajectories (Q5, Q6, Q7, Q9): Directly from V2V4Real's ground-truth future trajectories, which were collected via high-precision GPS/IMU.

Training vs. inference context construction (critical design choice, Section III-C): During training, the input context for child QA nodes uses ground-truth answers from parent nodes. This ensures the child node sees correct information during training and learns the correct mapping from perfect parent outputs to child outputs. During inference, the input context uses model-generated answers from parent nodes — the actual output of the previous QA node in the graph. This creates an exposure bias: the model is trained on clean context but tested on its own potentially noisy outputs, which can cause error propagation through the graph. This is a standard challenge in autoregressive structured prediction and is not explicitly addressed in the paper beyond the acknowledgment of the difference.

Why ground-truth context during training? Using model-generated context during training would require on-policy sampling (running the model to generate parent answers, then training on those), which is computationally expensive and can lead to training instability if early parent-node answers are poor. The ground-truth approach is simpler and ensures stable training, at the cost of potential mismatch at inference time. This is the same design choice made in most prior work on chained reasoning (including DriveLM).

---

3.4.6 Training Procedure and Graph Execution at Inference

Training procedure (Section IV-B): The V2V-GoT model is trained on all 9 QA types simultaneously — the training data includes samples of every QA type, and the model learns to answer any question in the graph given the appropriate visual tokens and text context. The training loss is the standard autoregressive language modeling loss (cross-entropy over the token sequence of the answer), although this is not explicitly stated. Training hyperparameters:

• Optimizer: Adam
• Starting learning rate: $2 \times 10^{-5}$
• Batch size: 32
• Epochs: 10
• GPU: NVIDIA H100-80GB (number unspecified)
• Trainable parameters: projection layers + LoRA adapters only
• Frozen parameters: PointPillars backbone, LLM base weights

The paper does not specify the learning rate schedule (constant? cosine decay?), weight decay, gradient clipping, or warmup steps. These are assumed to follow V2V-LLM and LLaVA conventions.

Inference execution (Section IV-B): At test time, the graph is executed sequentially according to the DAG structure in Figure 4(a). The execution order respects the topological sort of the graph:

1. Parallel execution: Q1 (visible notable objects) and Q2 (occluding objects) are generated independently — they share no dependencies and can be run in parallel.
2. Sequential with context: Q3 (invisible notable objects) runs with Q1 and Q2 answers as text context prepended to the question.
3. Merge: Q4 (overall notable objects) runs with Q1 and Q3 answers as context.
4. Parallel branch: Q5 (prediction by perception) and Q6 (prediction by planning) run with Q4 answer as context — these can execute in parallel since neither depends on the other.
5. Merge: Q7 (overall prediction) runs with Q5 and Q6 answers as context.
6. Sequential planning: Q8 (suggested action) runs with Q7 as context, then Q9 (suggested trajectory) runs with Q8 and Q7 as context.

Each QA call is a separate forward pass through the MLLM, reusing the same visual tokens (which are computed once from the shared PointPillars features) but with different text prompts and context. The computational cost of the graph is therefore $N_{\text{nodes}}$ forward passes through the LLM decoder, with the encoder/projection step done once. This is more expensive than V2V-LLM's single-question inference but amortizes the cost of the structured reasoning.

Error propagation risk: Because child nodes depend on parent-node outputs at inference time, errors in early nodes can cascade through the graph. For example, if Q1 misses a visible notable object, Q4 will not include it in the "overall notable objects" list, and Q5–Q7 will not predict its trajectory, potentially leading to a collision in Q9. The paper does not analyze error propagation explicitly, but the ablation study (Section V-C) implicitly tests this: the simplified graphs, which have fewer nodes and thus fewer error-propagation steps, serve as baselines that isolate the benefit of the decomposition from the cost of error propagation.

---

3.4.7 Baseline Methods: Architectural Comparison Points

The paper evaluates against baseline methods adopted from V2V-LLM, all using the same multi-timestep PointPillars features and MLLM architecture but differing in how cooperative information is fused and whether graph-of-thoughts reasoning is used (Table I). The baselines are described architecturally, not mathematically:

No Fusion: The MLLM receives only a single CAV's perception features (the ego CAV's own LiDAR). This baseline represents the single-vehicle case — no cooperation. The MLLM answers the planning question (Q9) directly, without graph-of-thoughts. Any improvement over this baseline is attributable to cooperative perception.

Early Fusion: The raw point clouds from both CAVs are combined into a single merged point cloud (union of all points), and PointPillars extracts features from this merged cloud. This provides the MLLM with a complete view of the scene but at the cost of high communication bandwidth — raw LiDAR point clouds are large (hundreds of thousands of points per frame). The paper notes this approach "usually requires high communication costs and is thus impractical for actual deployment" (Section V-A).

Intermediate Fusion (CoBEVT, V2X-ViT, AttFuse): Each CAV runs PointPillars independently to produce feature maps, and a cooperative 3D object detector (one of three architectures: CoBEVT, V2X-ViT, or AttFuse) fuses these feature maps across CAVs, producing a single set of perception features. The MLLM receives these fused features. These approaches achieve "a good balance of performance and communication cost" because feature maps are much smaller than raw point clouds.

V2V-LLM: The prior state-of-the-art. The MLLM receives both scene-level and object-level features from multiple CAVs and fuses them through the MLLM's own attention mechanism. V2V-LLM does not use graph-of-thoughts — it answers each question independently. The paper states V2V-LLM "achieves the best performance in V2V-QA's perception and planning tasks" among prior methods.

Fair comparison modifications: The paper modifies all baseline methods to also use perception features from both current and previous timesteps — the original V2V-LLM and its baselines used only current-timestep features. This ensures that any performance difference is attributable to the graph-of-thoughts reasoning structure rather than the temporal input. The comparison is on the final planning task (Q9 for V2V-GoT, equivalent Q5 in V2V-QA for the baselines), using L2 error and collision rate as metrics.

---

3.4.8 Communication Cost Analysis

The paper explicitly addresses the communication cost implications in Section VI, making the case that the graph-of-thoughts approach does not increase communication overhead relative to V2V-LLM. The reasoning: although V2V-GoT uses both current and previous timestep features (double the perceptual data), "the same perception features only need to be transferred from a CAV to the MLLM once" — features from the current timestep are saved and reused for the next timestep's "previous" features, so each feature map is transmitted once. Additionally, intermediate QA text (questions, answers, context) does not need to be transmitted between CAVs; the MLLM runs the full graph internally and sends only the final planning answer back to the CAVs. The conclusion: "the overall communication cost of V2V-GoT is the same as prior work V2V-LLM."

This analysis is important for practical deployment considerations but does not account for the computational cost of running the MLLM through 9 sequential decoding passes rather than 1, which is a latency concern the paper acknowledges only implicitly through the graph execution description.

4. Key Insights and Innovations

Innovation 1: The Occlusion-Aware Perception Decomposition — Splitting Perception by Visibility Status as a Reasoning Scaffold

The paper's most distinctive conceptual contribution is not simply adding more reasoning steps to an MLLM pipeline, but recognizing that occlusion creates a fundamentally different information-access problem for each object class in cooperative driving, and that a single perception question conflates tasks with incompatible attention requirements. The field's prior assumption — evident in both V2V-LLM's monolithic perception questions and the broader cooperative perception literature's focus on unified detection metrics — was that cooperative perception is one task: fuse features from multiple vehicles to build a better representation, then answer questions about what exists. The paper shows this assumption is suboptimal for reasoning.

The diagnostic move is to decompose "what notable objects are near my planned path?" into three structurally distinct sub-questions (Q1–Q3) that differ not in what they ask, but in which CAVs' feature maps the MLLM should attend to and why. Q1 (visible objects) requires attention to the ego CAV's own features — information the system already has. Q2 (occluding objects) requires geometric reasoning about which large nearby objects physically block sensor lines of sight — a spatial occlusion computation that the MLLM must learn from feature maps. Q3 (invisible objects) requires attention to cooperating CAVs' features specifically in regions the ego cannot see — regions identified by the Q2 output. By giving the MLLM the Q2 answer as context for Q3, the graph provides explicit spatial guidance about where to look in other vehicles' data, rather than requiring the model to simultaneously infer occlusion geometry, determine where other CAVs might see things, and identify objects — all in one forward pass.

This is not merely "break a hard problem into easier sub-problems" — that's a standard chain-of-thought intuition. What makes this distinctive is the recognition that the sub-problems require qualitatively different attention patterns over the same input features, and that providing parent-node answers as text context is a mechanism for directing the MLLM's cross-modal attention — not just conveying factual information. The ablation study in Table II supports this interpretation: when the occlusion-aware decomposition is removed (simplified perception graph, Figure 4b), Q4's perception F1 score drops from 72.01 to 67.48, and the downstream planning collision rate rises from 0.34 to 0.84. Critically, this simplified graph still has access to the same multi-CAV, multi-timestep perception features — the only difference is the removal of the Q1–Q2–Q3 scaffolding. This means the gain is not from additional information, but from the reasoning structure itself. This is a fundamental insight for MLLM-based autonomous systems: how you structure the question sequence shapes what the model attends to in the visual input, not just what logical relationships it computes.

The comparison to DriveLM's graph-of-thoughts sharpens this insight. DriveLM also decomposes perception, but its decomposition is based on semantic categories (identifying different types of road users, traffic elements, etc.) — it does not model occlusion as a reasoning dimension. In a single-vehicle setting, this is natural: the vehicle can only see what its sensors can see, so there is no "invisible" class to reason about. The V2V-GoT graph recognizes that cooperative driving introduces a visibility-status taxonomy (visible-to-ego, occluding-the-ego, invisible-to-ego-but-visible-to-others) that applies orthogonally to the object-category taxonomy, and that modeling this taxonomy explicitly in the reasoning graph is what unlocks the benefit of having multiple perceptual perspectives. This reframes cooperative perception from a sensor-fusion problem to a multi-perspective reasoning problem where the key challenge is not aggregating features but resolving information asymmetries between viewpoints.

Innovation 2: Planning-Aware Prediction — Treating Other Vehicles' Shared Plans as a Privileged Information Source Rather Than a Perceptual Input

The paper's second distinctive conceptual contribution is recognizing that in cooperative driving, prediction has access to two fundamentally different types of evidence — perceptual observation of object motion and explicit communication of intent — and that these should be processed in separate reasoning branches before merging. The standard prediction paradigm in autonomous driving (both single-vehicle and prior cooperative work) treats all objects symmetrically: observe their past trajectories, encode scene context, and predict future motion. Even when V2V communication is available, the default approach is to treat received information as additional perceptual data — more features to input to a unified prediction model.

The V2V-GoT graph makes a different design choice: Q5 (prediction by perception) and Q6 (prediction by planning) are separate leaf nodes that produce independent predictions and are merged only at Q7. This separation is consequential because the two information sources have different reliability characteristics and different failure modes. Perceptual prediction (Q5) is widely applicable — it works for any object, cooperating or not — but is fundamentally extrapolative and can fail when objects change behavior abruptly. Planning-based prediction (Q6) is more accurate when available — a CAV's communicated plan is ground-truth for that vehicle's intended motion — but applies only to cooperating vehicles and requires correctly identifying which CAVs are notable objects. By separating the branches, the graph allows Q7 to learn a conditional merge: when Q6 indicates a CAV is notable, trust the communicated plan; otherwise, default to the perceptual prediction. This conditional logic would be difficult to learn implicitly in a single unified prediction step that receives both perception features and other CAVs' plans as flat input.

The ablation study confirms this logic's importance. Removing the planning-aware decomposition (simplified prediction graph, Figure 4c) increases the planning collision rate from 0.34 to 0.84 — nearly identical to the degradation from removing the perception decomposition. This is striking because the simplified prediction graph still receives all the same information — the model still sees other CAVs' planned trajectories in the input, just without the Q5–Q6–Q7 structural decomposition. The decomposition matters not because it provides new data, but because it provides a reasoning template that makes the conditional merge logic explicit and learnable.

This insight generalizes beyond cooperative driving. Any multi-agent system where agents can both observe each other's behavior and receive explicit communications faces a version of this problem: how should the agent weight self-observed evidence against communicated claims, given that communicated claims are intentional and potentially more forward-looking but also potentially strategic or unreliable? The paper's solution — separate processing branches with explicit merge conditioning — is a template for MLLM-based multi-agent reasoning that has not been previously articulated in the autonomous driving literature.

Innovation 3: Graph-of-Thoughts as Attention Guidance, Not Just Logical Chaining

The paper makes an implicit but important conceptual contribution about what graph-of-thoughts reasoning actually provides in multimodal systems. The standard framing of chain-of-thoughts and graph-of-thoughts — inherited from the NLP literature and adopted by DriveLM — is that they improve reasoning by decomposing logical problems into sub-steps that the LLM can solve more reliably, with intermediate answers providing factual scaffolding for downstream steps. This is a text-level reasoning benefit: the model produces better answers because it reasons step-by-step.

The V2V-GoT results suggest an additional, multimodal-specific benefit: intermediate text answers guide cross-modal attention. When Q2's answer identifies "a large truck 15 meters ahead in the left lane" as an occluding object, this text is not just factual context for Q3 — it is a spatial attention cue that tells the MLLM where to look in the cooperating CAVs' LiDAR feature maps. The MLLM's cross-attention between text tokens and visual tokens can use the textual mention of the truck's location to up-weight visual features in that spatial region from other CAVs' feature maps, making the invisible-object search more targeted. This mechanism is fundamentally different from pure text-based chain-of-thoughts: the intermediate answers are not just carrying logical conclusions forward but are modulating visual information processing in downstream nodes.

This framing explains why the graph structure matters even when all nodes have access to the same visual features. If the benefit were purely logical — "first identify occluding objects, then look for invisible objects" — the model could potentially learn this internal reasoning without explicit graph nodes. But if intermediate answers serve as attention-modulation signals that change where the model looks in the visual input, then separating the nodes is essential: each node's specific question focuses the MLLM's visual attention on a subset of the feature maps relevant to that sub-task, and the parent answer provides the spatial coordinates for that focus. The ablation results, where removing nodes degrades performance despite identical input data, are consistent with this attention-guidance interpretation and harder to explain under a pure logical-chaining model.

This is a reframing of what graph-of-thoughts contributes to multimodal systems, and it has design implications: if intermediate answers guide visual attention, then the text format of those answers matters — they should include spatially-localizing information (object positions, categories, relationships) that can serve as effective attention cues. The paper's QA design implicitly follows this principle (answers include object identifiers and locations), but does not articulate it explicitly. The insight also suggests that graph-of-thoughts may be more impactful for multimodal tasks than for pure-text tasks because of this additional attention-guidance channel.

Innovation 4: Establishing That Structured Reasoning Improves Cooperative Planning Even When Communication Cost Is Held Constant

The paper makes a pragmatic but important empirical contribution by demonstrating that adding structured reasoning does not require additional communication between vehicles — the graph execution happens entirely within the MLLM, reusing already-transmitted perception features. This is not a theoretical advance, but it resolves a practical concern that could otherwise limit adoption of graph-of-thoughts approaches in bandwidth-constrained V2V settings.

The dominant concern with adding reasoning steps to cooperative systems is that each step might require new information from cooperating vehicles, increasing the communication burden. The paper explicitly addresses this in Section VI: the perception features are transmitted once and cached for reuse across graph nodes; the intermediate QA text stays within the MLLM; only the final trajectory is sent back. The overall communication cost equals that of V2V-LLM, which already established that MLLM-based fusion is communication-efficient compared to early fusion (raw point cloud sharing). The performance gains in Table I — the full V2V-GoT achieves the best collision rate (0.34%) and lowest L2 error (1.42m at 3s prediction horizon) across all baselines including V2V-LLM's 1.66m L2 — are therefore achieved without a communication cost penalty.

This finding matters for practical deployment because it separates the reasoning architecture from the communication architecture. System designers can adopt graph-of-thoughts reasoning to improve planning quality without renegotiating the communication protocol between vehicles. The graph structure is a software-level decision — how the central MLLM processes the information it already receives — not a hardware or protocol decision. This makes the approach incrementally deployable: the same V2V communication infrastructure that supports V2V-LLM can support V2V-GoT with only the onboard MLLM software changing. This is an incremental but practically significant insight that positions graph-of-thoughts reasoning as a cost-free upgrade to MLLM-based cooperative driving systems, rather than a tradeoff between reasoning quality and communication overhead.

5. Experimental Analysis

Evaluation Methodology

• Dataset. The V2V-GoT-QA dataset is curated on top of V2V4Real (Xu et al., 2023), a real-world cooperative driving dataset with 7,105 training frames and 1,993 testing frames. For each driving sequence, QA pairs are generated only for the frame that is 3 seconds before the end of the sequence, yielding 110,610 training and 31,014 testing QA pairs across 9 QA types (Section III-B).

• Base model(s). The V2V-GoT model uses LLaVA (Liu et al., 2023) as the base MLLM architecture, with a frozen PointPillars (Lang et al., 2019) LiDAR backbone extracting perception features from each CAV's point cloud. The language model component is not explicitly named, but follows V2V-LLM and LLaVA conventions (likely Vicuna-7B or 13B). The baseline models are adopted from V2V-LLM and include no fusion, early fusion, intermediate fusion (with CoBEVT, V2X-ViT, and AttFuse cooperative detectors), and V2V-LLM itself — all modified to use both current and previous timestep perception features for fair comparison (Section V-A).

• Metrics. Multiple task-specific metrics are used across the 9 QA types. For perception (Q1–Q4): F1 score. For prediction (Q5, Q7): L2 error (Euclidean distance between predicted and ground-truth waypoints). For Q6: binary classification accuracy on whether other CAVs are notable objects. For Q8: L1 error between output and ground-truth action category indices (speed and steering). For Q9 (the final planning task used for all baseline comparisons): L2 error and collision rate, where collision rate is the percentage of predicted trajectories that result in a geometric collision with ground-truth object positions (Section III-C through III-F).

• Baselines. The paper compares against five baseline methods adopted from V2V-LLM (Chiu et al., 2025): No Fusion (single CAV's perception features only — the non-cooperative case), Early Fusion (union of raw point clouds from all CAVs before PointPillars extraction), Intermediate Fusion with three cooperative detector architectures — CoBEVT (Xu et al., 2022), V2X-ViT (Xu et al., 2022), and AttFuse (Xu et al., 2022) — and V2V-LLM itself (MLLM-based fusion of scene-level and object-level features). All baselines are modified from their original implementations to use perception features from both current and previous timesteps, matching V2V-GoT's temporal input (Section V-A, Table I).

• Generation budget / compute accounting. The paper does not measure compute in FLOPs or generation counts. Instead, the primary resource accounting is communication cost (bandwidth required to share perception features between CAVs and the MLLM, reported in arbitrary but comparable units in Tables I and II). The paper argues that V2V-GoT incurs the same communication cost as V2V-LLM because each perception feature map is transmitted once and cached, and intermediate QA text remains within the MLLM (Section VI). Computational cost (MLLM forward passes, latency) is not quantified beyond the qualitative observation that the graph executes 9 sequential decoding calls.

• Cross-validation / statistical protocol. No cross-validation or statistical significance testing is reported. The test set is the fixed 1,993-frame V2V4Real test split, with QA pairs generated identically to the training set. Results in Tables I and II are single-point estimates on this fixed test set, without confidence intervals or error bars. The ablation study on graph structures (Section V-C) tests alternative inference graphs using the same trained model and test set — it does not involve retraining or hyperparameter search over graph configurations.

Main Quantitative Results

Final Planning Performance (Q9 — Suggested Trajectory)

Table I presents the headline results: V2V-GoT achieves the lowest collision rate (0.34%) and lowest L2 error (1.42m) among all compared methods on the final planning task. The side-by-side comparison against the strongest baseline, V2V-LLM, shows a reduction in collision rate from 2.86% to 0.34% (an ~8.4× improvement) and a reduction in L2 error from 1.66m to 1.42m (a ~14.5% reduction). These are the only metrics directly comparable across all methods, since the baselines only perform the planning task.

The baseline ranking on collision rate is: V2V-GoT (0.34%) ≪ AttFuse (2.19%) < CoBEVT (2.27%) < V2X-ViT (2.29%) < V2V-LLM (2.86%) < Early Fusion (3.87%) < No Fusion (4.02%). On L2 error: V2V-GoT (1.42m) < V2V-LLM (1.66m) < AttFuse (1.74m) < V2X-ViT (1.75m) < CoBEVT (1.79m) < No Fusion (1.81m) < Early Fusion (3.24m). A notable anomaly: Early Fusion achieves the second-worst collision rate (3.87%) and the worst L2 error (3.24m) despite having access to the complete merged point cloud — worse than No Fusion (single-vehicle, L2 = 1.81m) and substantially worse than all intermediate fusion methods. The paper does not discuss this anomaly, but it suggests that raw point cloud aggregation introduces geometric misalignment or density artifacts that degrade the MLLM's planning performance, and that feature-level fusion (intermediate or MLLM-based) is better suited to multimodal reasoning.

Communication cost context (Table I, Comm column). V2V-GoT and V2V-LLM share the same communication cost of 0.248 (the paper's unspecified units). The intermediate fusion methods (CoBEVT, V2X-ViT, AttFuse) have higher costs (0.291–0.612), and Early Fusion has the highest (20.369 — consistent with transmitting raw point clouds). V2V-GoT therefore achieves the best planning performance at the lowest communication cost among all cooperative methods. The No Fusion baseline has zero communication cost (0.000) since it uses only ego-vehicle data, but its performance is substantially worse (4.02% collision rate vs. 0.34%), quantifying the value of cooperation.

Perception Performance (Q1–Q4) — Ablation Study Context

The full-graph perception results are reported in Table II alongside the ablation graphs, not in Table I. For the full V2V-GoT graph: Q4 (overall notable objects) achieves F1 = 72.01. The occlusion-aware decomposition metrics (Q1–Q3 individually) are also reported: Q1 F1 = 54.50, Q2 F1 = 65.58, Q3 F1 = 8.66. The steep drop from Q1 (visible objects, F1 = 54.50) to Q3 (invisible objects, F1 = 8.66) is expected — identifying objects the ego cannot see, relying on cooperating CAVs' features in occluded regions, is a fundamentally harder task. The Q4 merge achieves F1 = 72.01, which is higher than both Q1 and Q3 individually, because Q4's ground truth is the union of visible and invisible objects and the merge combines complementary detection sets.

Prediction Performance (Q5–Q7) — Ablation Study Context

Full-graph prediction metrics (Table II): Q5 (prediction by perception) L2 = 1.08m, Q6 (prediction by planning) accuracy = 96.28, Q7 (overall prediction) L2 = 0.96m. The Q6 accuracy of 96.28% indicates that the model is highly reliable at determining whether other CAVs are notable objects — a prerequisite for the planning-aware merge at Q7 to function correctly. The Q7 L2 error (0.96m) is lower than Q5's L2 error (1.08m), confirming that the merge step improves prediction accuracy — when Q6 correctly identifies a CAV as notable, Q7 uses that CAV's communicated planned trajectory (which is ground-truth intent), producing a more accurate prediction than perceptual extrapolation alone.

Planning Intermediate Performance (Q8) — Ablation Study Context

Full-graph Q8 (suggested action classification) achieves L1 error = 2.68 on the speed + steering classification task. With 5 categories each for speed and steering, a random baseline would have an expected L1 error of approximately 4.0 (the expected absolute difference between two uniformly random integers from 0–4), so the model's 2.68 represents meaningful action discrimination. The Q8 output serves as the conditioning context for Q9 trajectory generation.

Ablation Studies and Robustness Checks

Occlusion-aware perception decomposition (Q1–Q2–Q3 vs. direct Q4): Table II compares the full graph (Figure 4a) against the simplified perception graph (Figure 4b), which removes Q1, Q2, and Q3 and asks Q4 directly without context. The simplified graph degrades Q4's F1 score from 72.01 → 67.48 (a 4.53-point drop), confirming that decomposing perception by occlusion status improves notable-object identification. The downstream impact is larger: Q7 L2 error degrades from 0.96m → 1.08m, and Q9's collision rate increases from 0.34% → 0.84% (a ~2.5× increase). The final L2 error also increases from 1.42m → 1.55m. This pattern — a moderate drop in perception F1 cascading into larger prediction and planning degradations — demonstrates error propagation through the graph and the cumulative benefit of getting the early perception steps right.

Planning-aware prediction decomposition (Q5–Q6–Q7 vs. direct Q7): Table II compares the full graph against the simplified prediction graph (Figure 4c), which uses the same trained V2V-GoT model but runs inference without the separate Q5 and Q6 branches (Q7 is asked directly with Q4 context, bypassing the split). The simplified graph degrades Q7 L2 error from 0.96m → 1.19m (a 24% increase), and the downstream Q9 collision rate increases from 0.34% → 0.84% matching the degradation from removing occlusion-aware perception. Q9 L2 error increases from 1.42m → 1.58m. This ablation is particularly informative because the model weights are identical — only the inference graph structure changes. This rules out the possibility that the benefit comes from having more training data (the full graph and simplified graph use the same trained model) and isolates the benefit to the structural decomposition itself. The fact that the Q5 (1.08m) and Q6 (96.28%) intermediate outputs are not used in the simplified graph means the model loses the explicit conditional merge logic that Q7 implements.

Both simplified graphs outperform V2V-LLM: Comparing Table II's simplified graph collision rates (both 0.84%) against Table I's V2V-LLM collision rate (2.86%) shows that even the ablated graphs — which remove either the occlusion-aware perception decomposition or the planning-aware prediction decomposition — substantially outperform the prior state-of-the-art V2V-LLM, which uses no graph-of-thoughts at all. This implies that the multi-timestep feature input and the overall graph structure (perception → prediction → planning chaining) provide benefits even without the specific occlusion and planning decompositions. The additional ~2.5× collision rate reduction (from ~0.84% to 0.34%) is attributable specifically to the occlusion-aware and planning-aware innovations.

Q8 (action classification) shows small degradation under simplified graphs: Q8 L1 error is 2.68 for the full graph, increasing to 2.72 (simplified perception graph) and 2.78 (simplified prediction graph) — relatively small changes compared to the larger degradations in Q7 and Q9. This suggests Q8 is partially robust to upstream prediction errors, though the downstream Q9 does not share this robustness — the trajectory generation step amplifies prediction quality differences that the discrete action classification smooths over.

Q1, Q2, Q3 not directly ablated individually: The paper does not report ablations that remove individual perception sub-questions (e.g., removing only Q2 while keeping Q1 and Q3, or removing Q1 context from Q3). The ablation study treats the occlusion-aware perception as a block — either the full decomposition (Q1, Q2 with Q3 context, Q3, Q4 merge) or none of it. This leaves open the question of which specific edges in the perception subgraph are most important. For example, does Q3 benefit more from Q1 context (knowing what's already visible), Q2 context (knowing what's occluding), or both equally?

No ablation on the Q8 → Q9 planning decomposition: The paper does not test whether removing Q8 (asking Q9 directly without discrete action classification context) degrades planning performance. This leaves open whether the action-before-trajectory decomposition provides value in the cooperative setting, or whether it is simply inherited from DriveLM without verification.

No depth ablation on temporal context: The paper uses current + previous timestep features and notes this as an improvement over V2V-LLM's current-timestep-only design, but does not ablate the number of temporal frames (e.g., 1 frame vs. 2 frames vs. 3 frames). The marginal benefit of the second timestep — and whether additional history would help further — is not quantified.

No model scale ablation: All experiments use a single MLLM scale (the unspecified Vicuna variant). The paper does not test whether a smaller (e.g., 1B or 3B) MLLM with graph-of-thoughts can match a larger MLLM without structured reasoning, which would provide evidence about whether graph-based reasoning compensates for model capacity.

No robustness analysis on perception feature quality: The paper uses a fixed, frozen PointPillars backbone. It does not test how V2V-GoT's performance degrades when the perception features are noisier (e.g., from a weaker detector, or under adverse weather/lighting conditions that affect LiDAR quality). This is a practical concern for real deployment where perception quality varies.

Critical Assessment

Does V2V-GoT actually outperform baselines in cooperative planning, or does it demonstrate a narrower result? The experiments in Table I genuinely show that the full V2V-GoT system achieves better final planning metrics (collision rate, L2 error) than all listed baselines on the V2V4Real test set. However, this demonstration is narrower than a general claim of superiority in several respects. First, all results are on a single dataset (V2V4Real) with a specific configuration (two CAVs, 3-second prediction horizon, highway scenarios). The paper does not test on other cooperative driving datasets, simulated environments with different traffic densities, or urban intersection scenarios where occlusion patterns differ. Second, the baseline methods are all variants of the V2V-LLM framework — the paper does not compare against non-LLM cooperative planning methods (e.g., optimization-based planners that use cooperative perception outputs, or imitation learning approaches trained directly on V2V4Real trajectories without MLLM reasoning). This leaves open whether MLLM-based planning with graph-of-thoughts is competitive with non-LLM approaches — the paper only shows it is the best MLLM-based method.

Does the ablation study genuinely demonstrate that occlusion-aware perception and planning-aware prediction are beneficial, or does it conflate correlation with mechanism? The ablation results in Table II are internally consistent and show performance degradation when either decomposition is removed. However, there are interpretive challenges:

1. The simplified perception graph requires additional training data — the paper states (Section V-C1) that they "create additional training data samples of Q4 but without context" and "train another model" for this ablation. This means the simplified graph ablation confounds the graph structure change with a change in the model being evaluated (different training data mixture, different training run). The degradation could partly result from suboptimal training of the ablated model rather than the absence of the decomposition itself. The simplified prediction graph ablation does not suffer from this confound — it uses the identical trained model and only changes the inference graph — so its results are more directly attributable to the structural decomposition.

2. The graph structure is not the only difference between the full and simplified graphs. The full graph provides parent-node answers as text context to child nodes — this is additional textual information that the simplified graphs lack. The degradation could be partly due to having less contextual information, not necessarily due to the decomposition logic per se. A stronger ablation would add the same factual information (list of visible objects, list of occluding objects) to a simplified Q4 question as an inline text prefix, without the separate QA node structure, to disentangle the effect of information from the effect of structured reasoning steps.

3. The ablation does not test alternative decompositions. Would any structured decomposition improve performance, or is the specific occlusion-aware + planning-aware split important? The paper cannot distinguish between "graph-of-thoughts reasoning helps in general" and "these specific QA types help because they align with the cooperative driving structure." Testing a graph with the same number of nodes but semantically different QA decompositions (e.g., decomposing perception by object category rather than occlusion status, or decomposing prediction by distance rather than information source) would clarify whether the benefit is from the specific design or from added reasoning depth.

Does the paper demonstrate that graph-of-thoughts is more important for cooperative driving than for single-vehicle driving? The paper cannot support this claim from its experiments because it never tests V2V-GoT in a single-vehicle setting. The No Fusion baseline is the only single-vehicle comparison point, but it lacks graph-of-thoughts reasoning, so the single-vehicle + graph design space is unexplored. Adapting the graph to single-vehicle driving (where Q2, Q3, and Q6 would have diminished relevance since there is no cooperating CAV input) and comparing against a no-graph single-vehicle baseline would clarify whether the graph structure's benefit is specifically tied to cooperative information processing or generalizes to structured driving reasoning.

Genuine weaknesses in experimental design:

• The test set is small relative to the complexity of the system. With 1,993 testing frames — generating approximately 31,014 QA pairs across 9 types, averaging ~3,446 QA pairs per type — the final planning evaluation (Q9) has roughly 3,400–3,500 test samples. A collision rate of 0.34% corresponds to approximately 11–12 collision trajectories out of ~3,400. The difference between 0.34% (V2V-GoT) and 0.84% (simplified graphs) is approximately 17 additional collision events — meaningful but potentially sensitive to a small number of challenging test scenes. Without confidence intervals, the statistical reliability of these low collision rates is uncertain.

• The collision rate metric is not defined in sufficient detail. The paper states that collision rate is computed on Q9 but does not specify the geometric collision checking procedure: whether collisions are checked at the 6 discrete waypoints or continuously along the interpolated trajectory, what constitutes a collision (bounding box overlap? distance threshold?), or how ground-truth object positions are defined for collision checking. The extremely low absolute collision rates (0.34–4.02%) suggest either a relatively safe driving environment in V2V4Real or a lenient collision definition.

• Communication cost is reported without units or absolute bandwidth estimates. The Comm column in Tables I and II uses unspecified units (e.g., 0.248 for V2V-GoT). Without knowing whether these are megabytes, relative ratios, or some derived quantity, the practical significance of the reported equality between V2V-GoT and V2V-LLM is unclear. The argument that "overall communication cost is the same" (Section VI) is qualitative — no empirical measurement of actual bytes transmitted is reported.

• Q3 (invisible notable objects) F1 = 8.66 is extremely low. This metric indicates the model correctly identifies invisible objects only ~8.66% of the time by F1 score. Given that Q4 achieves F1 = 72.01 by merging Q1 (F1 = 54.50) and Q3 (F1 = 8.66), the contribution of invisible object detection to overall perception is minimal — the model's overall perception is dominated by visible objects. This raises the question of whether the occlusion-aware decomposition is actually providing meaningful invisible-object detection or primarily restructuring the visible-object identification. The simplified graph's Q4 F1 = 67.48 is not dramatically lower than 72.01, suggesting that most notable objects in V2V4Real are visible and the invisible-object QA contributes little to the aggregate metric.

• No ablation on the number of "notable objects" (at most 3 in ground truth). The paper limits ground-truth notable objects to at most 3 per QA type. This cap may artificially simplify the perception task — scenes with more than 3 notable objects near the ego's trajectory are common in dense traffic, and the model trained with a cap of 3 may systematically miss objects in crowded scenarios. The paper does not report what fraction of V2V4Real scenes have more than 3 notable objects, or whether performance degrades in those scenes.

• The 3-second planning horizon is relatively short for real deployment. While standard in the literature, a 3-second trajectory at highway speeds (~30 m/s) covers only ~90 meters — insufficient for emergency maneuvers. The paper does not discuss horizon sensitivity or test whether the graph structure's benefits persist at longer horizons.

Missing experiments that would strengthen the paper:

• Varying the number of cooperating CAVs. V2V4Real uses two CAVs. Testing with 1, 2, 3, and 4 CAVs would characterize how the graph structure's benefits scale with the number of perceptual perspectives — a key question for dense urban deployments.
• Testing with a non-MLLM planning module that takes the graph's intermediate outputs. The paper claims the graph structure improves planning, but the planner is the same MLLM that generates the intermediate outputs. A cleaner test of whether intermediate reasoning steps are valuable would feed the graph's Q4 perception output and Q7 prediction output to a separate, non-LLM planner (e.g., a trajectory optimizer or learned policy) and compare against that same planner using V2V-LLM's simpler outputs.
• Error propagation analysis by QA node. The paper's inference procedure feeds model-generated (potentially erroneous) parent answers as context to child nodes. A per-node error analysis — how often does a Q1/Q3 error cause a Q4 error, which causes a Q7 error, etc. — would characterize the robustness of the graph to upstream errors and identify which nodes are most critical.
• Latency measurements. Running 9 sequential MLLM decoding passes likely incurs significant wall-clock latency compared to V2V-LLM's single-pass inference. Without latency numbers, the practical deployability of the approach is unclear — a collision rate improvement from 2.86% to 0.34% may not justify a 9× inference time increase if the system must operate at real-time rates (typically 10 Hz or faster for autonomous driving).

6. Limitations and Trade-offs

The Invisible-Object Perception Task Is Nearly Unsolved by the Current System

The paper's central conceptual contribution — occlusion-aware perception — hinges on the belief that decomposing perception by visibility status enables the MLLM to identify objects hidden from the ego vehicle by attending to cooperating CAVs' feature maps. However, the quantitative results reveal a stark gap between the design ambition and the model's capability. Q3 (invisible notable objects) achieves an F1 score of only 8.66 (Table II), meaning the system correctly identifies objects the ego vehicle cannot see at a rate that is barely above chance for a structured detection task. The paper treats this as a baseline for the occlusion-aware decomposition, but the number itself constitutes a failure mode: the "invisible object detection" pathway that the entire Q1–Q2–Q3–Q4 sub-graph is designed around contributes almost nothing to the final Q4 perception result (F1 = 72.01), which is dominated by Q1's visible-object detection (F1 = 54.50).

Consequence: The occlusion-aware perception decomposition is architecturally sound but empirically hollow for its stated purpose. In practice, Q4's F1 score of 72.01 vs. the simplified graph's 67.48 (Table II) likely comes from the Q1–Q2 scaffolding improving visible object identification — Q2 may help Q1 by providing occlusion context even for objects the ego can already see — rather than from successfully detecting objects the ego cannot see. The Q3 node, which is the cooperative perception step the paper motivates as essential for safety-critical occlusion scenarios (Section II-A: "situations where vehicles and other potential obstacles are occluded by other large nearby objects"), is not functioning effectively. A practitioner deploying this system cannot rely on it to identify pedestrians or cyclists hidden behind trucks, which is precisely the safety-critical use case that motivates V2V cooperation. The system's value proposition collapses to "it identifies visible objects better than baselines," which is a significantly narrower contribution.

Evidence in the paper: Q3 F1 = 8.66 is reported in Table II alongside the other perception metrics. The paper does not flag this as a limitation or discuss its implications. The dramatic gap between Q1 (F1 = 54.50) and Q3 (F1 = 8.66) is never addressed — the Discussion section does not exist, and the Conclusion makes no mention of the invisible-object detection failure.

Mitigation status: The paper does not acknowledge, diagnose, or attempt to mitigate this limitation. No ablation study investigates why Q3 performance is so low — whether the Q2 context (occluding object identification) is providing incorrect or unhelpful information, whether Q3's training data is too sparse or noisy, whether the MLLM's cross-modal attention mechanism is poorly suited to the task of searching other CAVs' feature maps for objects in specific spatial regions, or whether the at-most-3-objects cap during data curation systematically excludes scenes where Q3 could demonstrate value. Future work on improving invisible-object detection quality — through better context construction, architectural modifications to the cross-attention mechanism, or training data augmentation — is not proposed.

---

The Graph-of-Thoughts Inference Latency Is Unaccounted for and Likely Prohibitive for Real-Time Deployment

The paper's graph-of-thoughts execution requires 9 sequential MLLM decoding passes per driving decision — Q1 and Q2 in parallel, then Q3, Q4, Q5 and Q6 in parallel, Q7, Q8, Q9 sequentially. Each pass generates a multi-token natural language answer autoregressively through a large language model (Vicuna-7B or 13B). The paper does not report inference latency, throughput, or the number of tokens generated per QA node. This is a critical omission because autonomous driving operates under strict real-time constraints — typical planning modules run at 10 Hz (100ms per cycle) or faster, and a system that takes multiple seconds to produce a trajectory is unsuitable for vehicle control.

Consequence: Even if each QA decoding pass takes a relatively fast 500ms (optimistic for a 7B+ parameter model generating tens of tokens), the sequential depth of the graph (Q1/Q2 → Q3 → Q4 → Q5/Q6 → Q7 → Q8 → Q9) requires at least 6 serialized passes (since Q1/Q2 and Q5/Q6 can run in parallel, the critical path length is 6). This yields ~3 seconds of inference latency, matching the entire 3-second planning horizon — meaning by the time the model produces a trajectory, the planning window has already elapsed. In practice, individual decoding passes may take longer, especially if answers are verbose (Q5 and Q7 involve generating multiple object trajectories). A 9× increase in inference time over V2V-LLM's single-pass approach (which itself has unstated latency) represents a fundamental tradeoff between reasoning quality and temporal responsiveness that the paper does not address.

Evidence in the paper: Section IV-B describes the inference execution but provides no timing measurements. Section VI discusses communication cost at length but does not mention computational latency. The Conclusion makes no mention of real-time performance as a limitation or design consideration.

Mitigation status: Not addressed. The paper does not propose caching strategies (e.g., reusing Q1/Q2/Q4 answers across multiple timesteps when the scene changes slowly), model distillation (training a smaller, faster MLLM to execute the graph), parallelization beyond what the DAG structure allows, or any other latency-reduction technique. There is no suggestion that latency should be measured or optimized in future work. If the approach requires a model that is 9× slower than the already-slow V2V-LLM baseline, its deployability in real autonomous driving systems is questionable regardless of its collision rate improvements.

---

The Ablation Study Confounds Graph Structure with Training Data and Model Identity

The simplified perception graph ablation (Figure 4b, Table II) — which the paper uses to support its central claim that occlusion-aware perception decomposition is beneficial — requires training a different model with different training data. Section V-C1 states: "we first create additional training data samples of Q4 but without context. Then we train another model with newly generated data samples and the existing training dataset." This means the performance comparison between the full graph (F1 = 72.01, collision rate = 0.34%) and the simplified perception graph (F1 = 67.48, collision rate = 0.84%) is not a controlled ablation of the graph structure — it is a comparison of two different models trained on different data distributions, where the performance difference could arise from training stochasticity, data mixture effects, or hyperparameter sensitivity rather than the structural decomposition being tested.

Consequence: The paper's headline ablation result — that removing occlusion-aware perception degrades performance — is not cleanly attributable to the graph-of-thoughts structure. The simplified perception graph model was trained with additional Q4-without-context data samples that the full-graph model never saw. If the newly generated data samples are of different quality, difficulty, or distribution than the original Q4-with-context data, the simplified graph model may simply be a worse model overall, independent of the graph structure. The fact that the simplified graph model also performs worse on downstream tasks (Q7, Q9) is consistent with either explanation: (a) the occlusion decomposition genuinely helps, or (b) the model trained for the simplified graph is undertrained or suboptimally configured for the data it received. The paper cannot distinguish these.

The simplified prediction graph ablation (Figure 4c, Section V-C2) does not suffer from this confound — it uses the same trained V2V-GoT model and only changes the inference graph. Its results (collision rate increase from 0.34% to 0.84%) are therefore more trustworthy evidence for the planning-aware prediction decomposition. However, both simplified graphs produce identical collision rates (0.84%), which is suspicious and suggests either a coincidence or a shared underlying degradation mechanism rather than independent failure modes from removing two conceptually different decompositions.

Evidence in the paper: Section V-C1 explicitly describes the additional data generation and separate model training. Table II presents the results side-by-side without flagging the confound. The paper never discusses the interpretive limitation this creates.

Mitigation status: Not addressed. The paper could have avoided the confound by using the same trained full-graph model for both inference graphs — the full graph model was trained on Q4-with-context data, but during inference, Q4 could be called without context, allowing a fair comparison between the full graph and a simplified perception graph using the identical model checkpoint. The decision to train a separate model and introduce a confound is not explained or defended.

---

Evaluation Is Limited to a Single Real-World Dataset with Two-Vehicle Scenarios and a Short Prediction Horizon

All quantitative results are on the V2V4Real test set (1,993 frames, two CAVs, highway scenarios, 3-second planning horizon). The paper does not evaluate on any other cooperative driving dataset (e.g., OPV2V, V2X-Sim, or simulated urban intersection environments), any multi-vehicle configuration (3+ CAVs), any weather or lighting condition variation, or any longer planning horizon. This narrow evaluation limits the generality of every claim the paper makes about the effectiveness of occlusion-aware perception and planning-aware prediction.

Consequence: The paper cannot support the claim that its graph-of-thoughts design is generally effective for cooperative autonomous driving. The specific occlusion patterns in V2V4Real — which objects typically occlude which other objects, at what distances, in what traffic configurations — may make the decomposition beneficial in ways that do not transfer to urban intersections (where occlusions are more complex and multi-directional), dense multi-vehicle platoons (where more than two perspectives are available), or adverse weather (where LiDAR quality degrades and the frozen PointPillars backbone may produce noisier features). The single-model-family evaluation (LLaVA with Vicuna) further limits generality — a different MLLM architecture (e.g., LLaMA-3-based, or a model with different cross-modal attention mechanisms) might show different sensitivity to graph structure.

The 3-second planning horizon is sufficient for the V2V4Real evaluation but does not test whether the graph-of-thoughts benefits hold at longer horizons (5–10 seconds) where prediction uncertainty is higher and the planning-aware merge at Q7 must decide whether to trust communicated plans that extend further into the future.

Evidence in the paper: The evaluation methodology (Section V) uses only V2V4Real. No other datasets or simulation environments are mentioned. The model architecture and training data are specific to V2V4Real.

Mitigation status: The paper does not claim generalizability beyond V2V4Real and does not discuss dataset limitations in the Conclusion. The paper positions the V2V-GoT-QA dataset as "the benchmark and baseline method for future comparative research" (Section I), implicitly acknowledging that evaluation is currently single-dataset and inviting others to extend it. However, the paper's claims of outperformance are stated in absolute terms ("our proposed method outperforms all other baseline methods" in the abstract) rather than scoped to V2V4Real.

---

Error Propagation Through the Graph Is Not Quantified, and the Exposure Bias Between Training and Inference Is Unaddressed

The graph-of-thoughts execution feeds model-generated parent-node answers as context to child-node questions at inference time, but the model was trained with ground-truth context (Section III-C: "For training data, we use the ground-truth answer to generate the input context of the child node QA. During inference, we use the model inference output of the parent node QA"). This creates exposure bias: the child nodes are trained to expect clean, correct context, but at test time they receive potentially erroneous parent outputs, creating a mismatch that can cause cascading errors.

Consequence: If Q1 misses a notable object, Q4 will not include it, and Q5/Q7 will not predict its trajectory even if the object is clearly visible in the cooperating CAVs' feature maps. If Q2 misidentifies an occluding object, Q3 may search the wrong spatial region in other CAVs' features and miss invisible objects. If Q8 classifies the action as "straight" when the ground-truth maneuver is "turn right," Q9 will generate waypoints consistent with straight motion that may not avoid a collision. The paper provides no analysis of how often such cascading errors occur, which nodes are most vulnerable to upstream errors, or whether the graph structure amplifies or dampens initial perception mistakes.

The extremely low Q3 F1 (8.66) is likely exacerbated by this exposure bias: Q3 depends on Q1 and Q2 context, and if those parent answers are noisy at inference time, Q3's already-difficult task becomes yet harder. The simplified prediction graph ablation (Table II, Q7 L2 = 1.19m vs. full graph Q7 L2 = 0.96m) suggests that removing the Q5/Q6 intermediate steps — and thus removing one layer of error propagation — improves prediction accuracy, which is the opposite of what the structural decomposition is supposed to achieve.

Evidence in the paper: Section III-C describes the training-inference context difference. The ablation study in Table II provides indirect evidence of error propagation — when the simplified graphs bypass intermediate nodes, downstream metrics change — but does not decompose which upstream errors cause which downstream failures. The paper does not report per-node accuracy conditioned on correct vs. incorrect parent context.

Mitigation status: Not addressed. The paper does not discuss exposure bias, does not propose mitigation strategies (e.g., scheduled sampling where model-generated context is gradually introduced during training, or confidence-based context gating where low-confidence parent answers trigger re-querying), and does not flag this as a direction for future work. The inference protocol described in Section IV-B simply feeds parent outputs forward without any error detection or correction mechanism.

---

The Computational Cost of the Graph-of-Thoughts Reasoning Is Not Accounted for in the Efficiency Comparison

The paper's comparison against baseline methods in Table I is structured to emphasize that V2V-GoT achieves the best planning metrics at the same communication cost as V2V-LLM (Section VI). However, communication cost is not the only — or even the primary — resource constraint for an onboard MLLM-based driving system. The computational cost of executing 9 sequential MLLM decoding passes (versus 1 pass for V2V-LLM and most baselines) is entirely unaccounted for. This includes GPU compute time, energy consumption, and memory bandwidth for storing and processing intermediate text outputs across graph nodes.

Consequence: The paper's efficiency narrative — "same communication cost, better performance" — is incomplete and potentially misleading. A deployment engineer choosing between V2V-LLM and V2V-GoT would need to know that the latter achieves a collision rate reduction from 2.86% to 0.34% (Table I) but at the cost of roughly 9× the inference compute (plus the additional compute from multi-timestep features). For an onboard system with limited GPU budget shared across perception, prediction, and planning modules, this compute increase may be infeasible regardless of communication cost parity. The paper's abstraction of cost to communication alone obscures a fundamental accuracy-vs-compute tradeoff that practitioners must navigate.

The training cost is also not compared: V2V-GoT requires training on 9 QA types (110,610 QA pairs) versus V2V-LLM's single-planning-question training, and the simplified perception graph ablation requires training an entirely separate model with additional data — doubling the training cost for the ablation study alone. The LoRA-based training is parameter-efficient, but the multi-task data volume and multi-model training regimen still represent a non-trivial compute investment.

Evidence in the paper: Table I and II include a "Comm" column but no "Compute" or "Latency" column. Section VI discusses communication cost exclusively. Training hyperparameters (10 epochs, batch size 32, H100 GPUs) are provided in Section IV-B, but training time or FLOPs are not reported. The number of tokens generated per QA type at inference is not reported.

Mitigation status: Not addressed. The paper frames its contribution as improving cooperative driving performance without communication cost penalty, implicitly treating computation as free or irrelevant. No compute-efficiency analysis, latency measurement, or discussion of the accuracy-vs-compute tradeoff is provided. If the method's practical value depends on the assumption that onboard GPU compute is abundant relative to V2V communication bandwidth, this assumption should be stated and its validity should be discussed for realistic deployment scenarios (e.g., current-generation autonomous vehicle compute platforms).

7. Implications and Future Directions

How This Work Changes the Landscape

This paper introduces a new design dimension to MLLM-based autonomous driving research: the question-answering graph structure is not just a reasoning scaffold for the language model — it is a mechanism for controlling where the model directs its cross-modal visual attention. Prior work in this space, particularly V2V-LLM and DriveLM, treated the sequence of questions as a logical decomposition: break a hard question into easier sub-questions, answer them in order, and use the answers as factual context. The implicit assumption was that the primary benefit comes from the logical scaffolding — intermediate conclusions reduce the complexity of downstream reasoning steps.

V2V-GoT provides evidence for a qualitatively different mechanism. The ablation study shows that removing the occlusion-aware perception decomposition degrades performance (Q4 F1 drops from 72.01 to 67.48, Q9 collision rate increases from 0.34% to 0.84% in Table II) even though the simplified graph has access to identical multi-CAV perception features. The Q1–Q2–Q3 scaffolding does not provide new information — the same LiDAR feature maps are present regardless of whether the graph includes separate visible/occluding/invisible sub-questions. The scaffolding provides direction about where in those feature maps the MLLM should attend. When Q2's answer identifies "a large truck 15 meters ahead in the left lane," that text becomes an attention-modulating signal during Q3's cross-modal processing, directing the MLLM to search cooperating CAVs' feature maps specifically in the spatial region occluded by that truck. When the decomposition is removed and Q4 is asked directly, the model must simultaneously locate visible objects, reason about occlusion geometry, identify invisible objects in other CAVs' features, and merge the results — all within a single forward pass where the cross-attention weights must cover the full spatial extent of all feature maps.

This reframes graph-of-thoughts from a purely logical-chaining tool to an attention-management architecture for multimodal systems. It is not simply "break problems into sub-problems" — it is "each sub-problem in the graph provides a different attention focal point over the same perceptual input." The design implication is that QA nodes should be designed around distinct attention requirements, not just distinct logical conclusions. A QA node that asks about occluding objects (Q2) forces the model to attend to the ego CAV's feature maps and reason about occlusion boundaries; a QA node that asks about invisible objects (Q3) forces the model to attend to other CAVs' feature maps in the regions identified by Q2's answer. The graph edges are not just information pipelines — they are attention-directing pathways.

Relationship to prompt engineering and in-context learning. This insight has broader implications for how researchers design multimodal reasoning systems. The dominant paradigm in MLLM research has been to improve reasoning through better prompts, chain-of-thought templates, or demonstration examples — all text-level interventions. V2V-GoT suggests that the structure of the task decomposition itself shapes visual processing in ways that text-level prompting alone cannot replicate. A prompt that says "first think about what objects are occluding your view, then look for hidden objects" may not produce the same attention patterns as physically separating those steps into distinct forward passes with different question formulations and explicit context injection. This opens a new axis for MLLM system design: the sequencing and decomposition of queries as a mechanism for visual attention control, distinct from the content of the queries themselves.

Where the field stands after this work. The paper does not establish a new paradigm — it does not fundamentally change how cooperative perception or MLLM-based planning is done. It is an incremental refinement of the V2V-LLM framework that adds structured reasoning and shows quantitative improvements on a single benchmark. However, the nature of the improvement — replicable across ablation conditions, attributable to structural decomposition rather than additional information or model capacity — establishes that graph structure matters for multimodal reasoning quality, not just for logical completeness. This is a diagnostic contribution: it identifies a factor (QA graph topology) that subsequent MLLM-based driving systems should treat as a first-class design variable rather than an afterthought.

The work also partially reconciles a tension in the literature. DriveLM demonstrated that graph-of-thoughts improves single-vehicle MLLM driving, but it was unclear whether the benefit was domain-specific (to the nuScenes scenarios and QA types used) or general. V2V-LLM demonstrated that MLLMs can fuse multi-vehicle perception features effectively, but without structured reasoning. V2V-GoT connects these: the graph-of-thoughts benefit transfers to cooperative driving and is specifically amplified when the graph structure is designed around the domain's information asymmetries (occlusion, shared plans). This suggests that graph-of-thoughts is a general tool for MLLM-based driving, not a single-dataset artifact, and that the specific topology of the graph should be co-designed with the domain's information structure.

Research directions this work makes more attractive:

• Attention-aware graph design for multimodal systems. The paper's implicit hypothesis — that intermediate text answers modulate visual attention — could be tested directly with attention map visualization. A natural experiment: compare the cross-attention weights in Q3 (with Q2 context) vs. Q3 (without Q2 context) and measure whether the model's attention over cooperating CAVs' feature maps concentrates in the occluded spatial regions identified by Q2. This would provide direct mechanistic evidence for the attention-guidance interpretation and would inform how to design graph nodes to maximize this effect.

• Domain-specific reasoning graphs for other driving scenarios. The paper designs a graph around occlusion and shared plans, which are specific to cooperative highway driving. Urban intersection cooperation, multi-vehicle platooning, and mixed-autonomy scenarios (some vehicles cooperative, some not) introduce different information asymmetries — different vehicles have different views of intersection cross-traffic, platoon members have different following distances, cooperating vehicles must reason about non-cooperating vehicles' likely behavior. Each of these domains might benefit from a graph whose nodes are designed around its specific information structure, and the V2V-GoT framework provides a template for how to design such graphs.

Research directions this work makes less attractive:

• Monolithic MLLM driving without structured reasoning. The consistent gap between V2V-GoT and the no-graph baselines (Table I) suggests that asking a single planning question and expecting the MLLM to implicitly perform all necessary perception, prediction, and reasoning in one forward pass is suboptimal. Future MLLM driving systems should seriously consider some form of structured decomposition — the paper's evidence suggests that even a simple perception → prediction → planning chain (the simplified graphs in Table II, which outperform V2V-LLM's 2.86% collision rate with 0.84%) is substantially better than no decomposition at all.

• Pure language-based V2V cooperation without multimodal fusion. The paper explicitly critiques CoDrivingLLM and CoLMDriver for using LLMs as text-only negotiators (Section II-C), and the results in Table I demonstrate that the multimodally-aware V2V-GoT (and even V2V-LLM) substantially outperform the single-vehicle No Fusion baseline (0.34% vs. 4.02% collision rate). While text-based negotiation may have a role in discrete conflict resolution (who goes first at a stop sign), the evidence suggests that for continuous trajectory planning under occlusion, multimodal fusion of perception features is essential and language-only coordination is insufficient. This directs research effort away from pure negotiation frameworks and toward multimodal cooperative reasoning.

---

Follow-Up Research This Work Enables

Each of the following directions addresses a specific gap left open by the paper and is made tractable by the V2V-GoT-QA dataset and baseline model the paper has established.

Characterize and mitigate the exposure bias between training-time ground-truth context and inference-time model-generated context. The paper acknowledges (Section III-C) that training uses ground-truth parent answers as child-node context while inference uses model-generated answers, but provides no analysis of resulting error cascades. A direct follow-up would measure per-node accuracy conditioned on correct vs. incorrect parent context: for Q3, what is the F1 score when Q1 and Q2 are correct vs. when they contain errors? For Q7, what is the conditional L2 error given perfect vs. imperfect Q5 and Q6 outputs? This would quantify which graph edges are most vulnerable to error propagation and would inform mitigation strategies such as scheduled sampling (gradually introducing model-generated context during training), confidence-based gating (skipping or re-running child nodes when parent outputs have low confidence), or ensemble approaches (running multiple Q1/Q2 samples and feeding the most consistent answers to Q3). A strong experiment would compare these mitigation strategies on the full V2V-GoT-QA test set, measuring both final Q9 metrics and per-node robustness to upstream noise. The V2V-GoT-QA dataset already contains ground-truth answers for every node, making it straightforward to simulate varying levels of parent-node noise and measure downstream sensitivity.

Diagnose and improve the near-zero invisible-object detection performance (Q3 F1 = 8.66 in Table II). The paper's central cooperative perception use case — identifying objects hidden from the ego vehicle behind large occluders — is failing in practice, but the paper provides no diagnostic analysis of why. Is Q3 failing because Q2's occluding-object context is incorrect or spatially imprecise (so Q3 looks in the wrong regions of cooperating CAVs' features)? Is Q3 failing because the MLLM's cross-modal attention mechanism cannot effectively search a specific spatial region of another CAV's feature map given only a textual location description? Is Q3 failing because V2V4Real simply has very few scenes where notable objects are invisible to one CAV but visible to another (so the training signal is too sparse)? A diagnostic study would measure each: (a) compare Q3 performance when given ground-truth Q2 context vs. model-generated Q2 context to isolate Q2 error propagation; (b) replace the textual Q2 context with explicit spatial coordinates (bounding box of the occluding object in BEV coordinates) to test whether the bottleneck is text-to-spatial attention mapping; (c) compute the fraction of V2V4Real scenes that actually contain invisible notable objects to assess whether the dataset supports the task. If the bottleneck is attention localization, a promising architectural fix would be to provide explicit spatial region masks (derived from Q2's occluding object bounding boxes) as additional visual input to Q3, rather than relying on the MLLM to infer spatial attention targets from text alone. If the bottleneck is data sparsity, the follow-up could curate a synthetically augmented version of V2V-GoT-QA with simulated occlusion scenarios to provide denser training signal for Q3.

Test whether the graph-of-thoughts benefit generalizes to MLLMs with fundamentally different visual encoding architectures. V2V-GoT uses a frozen PointPillars backbone with trainable projection layers — a specific choice of LiDAR encoder and visual tokenizer. The paper's attention-guidance hypothesis predicts that the graph structure's benefit should depend on the MLLM's ability to spatially localize its cross-modal attention based on textual cues. Different visual encoding architectures (e.g., a learnable BEV feature extractor fine-tuned jointly with the MLLM, a transformer-based detector with explicit object queries, or a camera-based encoder with different spatial resolution and field of view) would produce differently-structured visual tokens with different spatial correspondence to text tokens. If the graph benefit persists across diverse visual encoders, the attention-guidance mechanism is robust. If it disappears with certain encoders (e.g., those that produce spatially-compressed or orderless visual tokens), that would clarify the architectural requirements for graph-of-thoughts to be effective. A clean experiment: replicate V2V-GoT's full graph vs. simplified graph comparison using (a) a jointly-trained learnable BEV encoder replacing frozen PointPillars, (b) a camera-only visual encoder (useful for vehicles without LiDAR), and (c) a flat tokenization scheme that strips spatial structure from the visual features. Measure whether the full-graph advantage is preserved or attenuated in each case. This would transform the paper's single-architecture result into a general statement about when graph-of-thoughts helps.

Measure the graph depth vs. planning quality tradeoff curve, including latency. The paper's graph has a critical path depth of 6 sequential MLLM decoding passes (Q1/Q2 → Q3 → Q4 → Q5/Q6 → Q7 → Q8 → Q9), and provides no latency measurements. A follow-up latency-accuracy tradeoff study would measure wall-clock inference time per graph node (including token generation time) and then sweep alternative graph topologies with different critical path depths: a fully sequential chain (perception → prediction → planning in 3 steps), the full 6-step graph, and a hypothetical 2-step graph (Q4 directly, then Q9 directly, using the same trained model). For each topology, measure both Q9 planning metrics (L2 error, collision rate) and end-to-end latency on the target hardware (H100 or an automotive-grade GPU like NVIDIA Orin). This would produce a latency-vs-safety curve that tells practitioners exactly how much safety improvement each additional graph depth buys, and whether the 9× compute increase from V2V-LLM's single-pass inference to V2V-GoT's 9-pass graph is justified by the collision rate reduction. A strong version of this study would also test whether intermediate caching (reusing Q1/Q2/Q4 outputs across multiple timesteps when the scene has not changed significantly) can reduce amortized latency without degrading planning quality, since cooperative driving scenes often evolve slowly between frames.

Evaluate the graph-of-thoughts approach on a dense urban intersection dataset with 3+ cooperating vehicles. V2V4Real provides highway scenarios with two CAVs — a specific and relatively simple cooperation topology. Urban intersections introduce qualitatively different challenges: occlusions are multi-directional (buildings, other vehicles block views from all angles), the number of cooperating vehicles is larger (3–6 approaching an intersection), and the decision space is more complex (unprotected left turns, cross-traffic coordination). Does the occlusion-aware perception decomposition generalize to multi-directional occlusion? Can the planning-aware prediction decomposition handle 5 cooperating CAVs all sharing their planned trajectories, where the merge logic at Q7 must decide which of many vehicles to prioritize? A follow-up study could port the V2V-GoT graph to a simulated intersection dataset (e.g., extending V2X-Sim with intersection scenarios) or to an existing real-world intersection dataset if available, curating a multi-CAV QA dataset following the same methodology as V2V-GoT-QA. The key measurements would be: does the full graph maintain its advantage over simplified graphs when occlusion patterns are more diverse and the number of CAVs is larger? Does performance degrade gracefully or catastrophically as the number of cooperating vehicles increases (due to longer context windows, more objects to track, more complex merge decisions)? This would test the paper's implicit claim that the graph design is domain-general rather than V2V4Real-specific.

Replace the MLLM-based planner with a non-LLM trajectory optimizer that consumes the graph's intermediate perception and prediction outputs, isolating the value of structured reasoning from the value of MLLM-based planning. The paper's central claim is that the graph-of-thoughts structure improves planning, but the planner and the reasoner are the same neural network — the MLLM that produces Q1–Q8 also produces Q9. This means it is impossible to tell whether the planning improvement comes from better intermediate reasoning (the graph structure providing better context) or from architectural properties of having the MLLM generate trajectories step-by-step. A clean separation experiment would: (1) run the full V2V-GoT graph to produce Q4 (perception) and Q7 (prediction) outputs; (2) feed those structured outputs (list of notable objects with predicted trajectories, including whether each is a CAV with a communicated plan) as input to a separate, non-LLM trajectory planner — e.g., a model predictive control (MPC) optimizer, a learned policy network trained on V2V4Real trajectories, or an off-the-shelf motion planner like a lattice planner; (3) compare this system's Q9-equivalent performance against the same non-LLM planner using perception and prediction outputs from the simplified graphs (which provide less structured intermediate outputs). If the full-graph intermediate outputs improve the non-LLM planner's performance, the benefit is genuinely from better reasoning about perception and prediction, not from MLLM-specific planning properties. If the benefit disappears, the graph structure's value is specific to the MLLM planning architecture. This experiment addresses a major interpretive confound in the paper and would clarify whether graph-of-thoughts should be adopted as a general pre-processing step for any cooperative planner, or only for MLLM-based planners.

---

Practical Applications and Downstream Use Cases

Safety monitoring systems for deployed autonomous vehicle fleets. The 0.34% collision rate achieved by the full V2V-GoT graph (Table I) compared to 4.02% for the single-vehicle No Fusion baseline represents a reduction of collision events by a factor of ~11.8× on the V2V4Real test set. In a fleet deployment context, this translates to a substantial reduction in safety-critical incidents for driving scenarios involving occlusion by large vehicles. A fleet operator equipping vehicles with V2V communication hardware and deploying V2V-GoT (or a production-hardened version) as the cooperative planning module would expect to see this order-of-magnitude collision rate improvement specifically in scenarios where one vehicle's view is blocked by a bus or truck — the exact scenario that motivates V2V cooperation and that single-vehicle systems handle poorly. The key practical caveat is latency: Section 6's analysis suggests the graph's 6-step critical path depth may incur several seconds of inference time, which would limit this application to off-vehicle computation (edge servers at intersections, cloud-based cooperative planning with 5G connectivity) or to next-generation onboard compute platforms with sufficient GPU headroom. If the latency can be brought below ~100ms through model distillation or hardware advances, this becomes a directly deployable safety upgrade for any V2V-equipped autonomous fleet operating in mixed traffic with large vehicles.

Data curation pipelines for training cooperative driving systems. The V2V-GoT-QA dataset construction methodology — extracting 9 structured QA types from a cooperative driving dataset by using ground-truth bounding boxes, trajectories, occlusion geometry, and detector-specific visibility — provides a template for generating training data from any V2V dataset with ground-truth annotations. A team building a cooperative driving system for a new sensor suite or geographic region could take an existing V2V dataset (OPV2V, V2X-Sim, or a proprietary fleet-collected dataset), apply the same QA curation pipeline with their own detector's visibility characteristics and appropriate distance/occlusion thresholds, and generate a graph-of-thoughts training corpus. The 110,610 training QA pairs produced from only 7,105 V2V4Real frames (approximately 15–16 QAs per frame per CAV) demonstrates the data efficiency of the approach: a modest number of annotated cooperative driving scenes can generate a large structured reasoning dataset. This is practically important because collecting and annotating real-world cooperative driving data is expensive — the methodology amplifies the value of each annotated frame. A practical deployment would involve: (1) collecting LiDAR data from a small fleet of V2V-equipped vehicles over a few weeks; (2) annotating bounding boxes and trajectories on a subset of frames; (3) running the V2V-GoT curation pipeline to generate QA pairs; (4) fine-tuning an MLLM with LoRA on the generated QAs. The paper's open-source release of the dataset and model would enable this pipeline.

Interpretable debugging and failure analysis for autonomous driving systems. A side benefit of graph-of-thoughts reasoning — not explored in the paper but implicit in the architecture — is that intermediate QA outputs provide human-readable visibility into the system's reasoning process. When a collision occurs, an engineer can inspect the full chain of Q1 through Q9 answers to determine where the reasoning failed: Did Q2 misidentify the occluding object, causing Q3 to search in the wrong region? Did Q5 correctly predict a pedestrian's trajectory, but Q7's merge step incorrectly overrode it with a CAV's plan? Did Q8 correctly classify the action as "stop" but Q9 generate a trajectory that didn't decelerate fast enough? This is a substantial practical advantage over end-to-end black-box planners (whether MLLM-based or not) that produce only a final trajectory with no intermediate reasoning trace. In safety-critical system development, the ability to attribute failures to specific reasoning steps accelerates debugging, enables targeted data augmentation (if Q3 consistently fails, curate more occlusion training examples), and supports regulatory compliance by providing an auditable decision trail. A production system could log the full QA chain for every planning cycle and automatically flag cycles where intermediate outputs are inconsistent (e.g., Q8 says "stop" but Q9's waypoints imply continued motion), enabling real-time anomaly detection. The paper's per-node evaluation metrics (Q1–Q9 each have defined accuracy measures in Table II) provide the monitoring infrastructure: each node's performance can be tracked independently in deployment, and degradations in specific nodes can trigger maintenance (model retraining, sensor recalibration).

Low-communication-bandwidth cooperative driving for edge-deployed systems. The paper's communication cost analysis (Section VI) — establishing that V2V-GoT achieves the same communication footprint as V2V-LLM despite its more sophisticated reasoning — matters for deployments where V2V bandwidth is severely constrained. Scenarios include: military convoys operating in radio-silent or jammed environments, agricultural robot swarms using low-power short-range communication, or underground mining vehicles where wireless bandwidth is limited by rock attenuation. In these settings, the communication channel can carry only compressed feature maps (the 0.248-unit cost reported in Tables I/II is substantially lower than early fusion's 20.369-unit cost of transmitting raw point clouds), and the system cannot afford additional communication overhead for reasoning. V2V-GoT's property of achieving graph-of-thoughts reasoning entirely within the onboard or edge MLLM, reusing the same cached feature maps for all 9 QA nodes, means these bandwidth-constrained deployments get the safety benefits of structured cooperative reasoning without increased communication load. The practical deployment architecture would be: a small edge GPU (e.g., NVIDIA Jetson) running the MLLM at each intersection or on each vehicle, receiving compressed PointPillars features from nearby CAVs over a low-bandwidth V2V link, executing the full graph-of-thoughts locally, and transmitting only the final trajectory back to the relevant vehicles. The communication savings from intermediate fusion (vs. early fusion) are well-established in the cooperative perception literature; V2V-GoT adds that the reasoning itself doesn't erode those savings.