Route-Time Conflict Maps for Cooperative End-to-End Autonomous Driving

arXiv:2611.13494 · cs.RO · Submitted 2026-11-10 · Read on arXiv

Listen

Radio episode about this paper

Transcript

Introduction to the show: ident: Robotics Radio. Generated commentary on the latest robotics and control papers.

Rosa: I'm Rosa.

Dev: And I'm Dev, here with Taro.

Rosa: We're looking at the paper: "Route-Time Conflict Maps for Cooperative End-to-End Autonomous Driving".

Title and authors: Rosa: So we're diving into this paper called Route-Time Conflict Maps for Cooperative End-to-End Autonomous Driving by Liu and the team. It looks like they’re trying to figure out how a vehicle can decide when to proceed when it has multiple other vehicles around it, specifically using intent sharing under a certain driving class.

Dev: Yeah, I saw the title and authors in front of me. It sounds like they're tackling that tricky decision-making part where you have to anticipate what everyone else is going to do so you can make a safe move.

Rosa: Exactly. The core idea seems to be building this route-time conflict map by fusing everything—the stuff the ego vehicle sees, what it predicts other vehicles will do, and the plans those partners broadcast—into one picture of where things might get blocked along its future path.

Dev: That’s what page two talks about when they describe how they start with the observation that this decision is just one dimension along the vehicle’s own route: is the stretch ahead clear at the time the vehicle would be there >

Taro: But isn't it hard to actually make sense of all that incoming data, especially when you have different vehicles broadcasting their plans, and how does a planner use that fused map to score a speed profile?

Rosa: That’s where they introduce this route-time conflict map as the main tool. It lets the planner see if the path ahead will be clear when it actually gets there, and it’s supervised by an expert that handles those stops beyond its planning horizon >

Dev: I wonder about that expert part. If you're relying on an expert to relabel what a vehicle can’t see within its own planning window, how robust is that system when the real world throws something totally unexpected at it?

Rosa: That’s a huge question. The paper says they address this asymmetry in time by relabeling expert stops that When2Go cannot explain within its two second planning horizon >

Title and authors: Taro: So, if the system can’t see a stop soon, it just labels it differently based on what we already know about that area or those ground truth boxes >

Dev: And then they build an order gate on top of all these broadcasts to settle conflicts when two intended trajectories clash, using an antisymmetric precedence network to make sure both vehicles reach the same order without needing a message round >

Rosa: That sounds like they’re trying to move away from what we see in other systems where you need a full class C agreement just for simple conflicts >

Taro: So, when two vehicles want the same space, instead of waiting for a complex negotiation, this order gate uses shared messages to decide who goes first based on right-of-way rules >

Dev: And they draw that agreed-upon order directly onto that conflict map as occupancy, which feeds back into the planner scoring candidate speed profiles >

Rosa: The results are pretty high too. They report a driving score of ninety-seven point eight on InterDrive without traffic and ninety point seven with traffic, plus gains on lane changes > <ref:2611.13494#pg1>

Taro: That’s impressive when you look at how it performs compared to other methods they tested, like CoLMIN or even published results that might be lower >

Dev: I noticed the performance analysis shows the largest margin over the strongest cooperative rerun happening in lane changes, hitting ninety-eight point two five against sixty-seven point two zero and sixty-seven point four five in one comparison table > <ref:2611.13494#pg1>

Rosa: It really shows that this map approach is doing something different when vehicles are trying to change lanes, suggesting it’s better at those complex maneuvers >

Taro: But we have to look at the trade-offs they mention too, because there are always costs involved in these kinds of systems >

Dev: Right. They do say that modifying the benchmark’s default controller to steer by network waypoints instead of a route point can give you a gain of four point six points on V2Xverse, but it actually reduces the MDrive success rate by three point two points > <ref:2611.13494#pg1>

Title and authors: Rosa: So it’s not just about making the map better; it’s sensitive to how you configure the controller too, which is something I think we need to watch closely in real trials >

Taro: And they also flag some limitations, like the planner only following the given route without doing independent lane changes or incorporating traffic lights and stop signs >

Dev: That makes sense. It’s currently focused on cooperative end-to-end planning within a closed loop, so it doesn't handle those external fixed rules yet >

Rosa: So, to wrap up on this paper, the Route-Time Conflict Maps for Cooperative End-to-End Autonomous Driving gives us a way to fuse detections and partner plans into a route map that lets planners score speed profiles based on future clearance >

Taro: It’s cool that it mimics expert behavior by relabeling stops it can't see, but the limitation is definitely when things get messy in dense traffic or when the system doesn't have enough information to make those expert labels accurate >

Dev: And the order gate mechanism for agreement from shared messages is a clever way to get a cycle-free order without needing those more complex class C negotiation rounds >

Rosa: So, this work pushes cooperative driving forward by focusing on what’s ahead along the route and using an antisymmetric network to manage immediate conflicts >

Taro: For me, the real implication is how much more safely we can expect vehicles to navigate merges and intersections when they are relying on these shared predictions rather than just reacting to what’s immediately in front of them >

Dev: Agreed. It moves the problem from a purely local reaction to a more global look at the route-time conflict map, which is essential for safety at higher driving classes >

Rosa: So that’s where we are on this paper, with its focus on building that map and using the order gate to enforce shared movement orders >

Taro: It’s a solid piece of work showing how intent sharing can lead to better cooperative behavior in real-world scenarios, even if there are still some things it doesn't handle yet >

The paper's summary: Rosa: It fuses three things together. You got the sensors detecting what’s around you, the forecasts predicting where those other cars will go, and their planned routes all layered onto your own path >

Taro: So it's not just a static map of obstacles; it's dynamic information about future occupancy along your exact route, which lets a planner figure out if the path ahead will be clear when you actually get there >

Dev: That sounds like a massive leap because normally planners only look at immediate surroundings, but here they can score candidate speed profiles based on that future clearance >

Rosa: Exactly. And to make that work, they use this expert system to handle those stops that the car can't see within its own two second planning horizon by relabeling them based on what we already know about those ground truth boxes >

Taro: But when you’re actually driving outside the lab, Rosa, how does this system handle situations where it’s misinterpreting the world or when there’s unexpected traffic that doesn't match the labels?

Dev: That’s where I get cautious. The paper mentions they train their order gate using four hundred thousand counterfactual pairs derived from training town paths to make sure the agreement on who goes first is solid, even if things get messy >

Rosa: And when two intended paths conflict, this order gate uses an antisymmetric precedence network on those broadcast trajectories to decide the sequence of movement without needing a full class C message exchange just for that one conflict >

Taro: That sounds like a way to cut down on the communication overhead, which is huge for real-world latency issues >

Dev: It does, but there are trade-offs. The paper shows that they can achieve very high driving scores on tests like InterDrive without traffic and V2Xverse repetition three, but they also admit the system struggles when it’s not following a fixed route or if it doesn't have those stop sign inputs >

Rosa: Right, so the win is high cooperative behavior where vehicles can cross first at a junction without crashing, but the caveat is that it’s still heavily reliant on having good labels and rules for training >

Taro: So while the experimental results look fantastic for cooperative driving scores, we have to keep an eye on those limitations when we push this out into complex urban environments where the rules aren't perfectly clear >

Dev: The performance analysis actually showed that the biggest gains over other methods came specifically in lane changes, which suggests this map approach is really focused on managing those complex merging situations well >

Rosa: It’s a lot of data, but fundamentally, they’re moving from just reacting to what's right in front of you to having a global view of your path and future conflicts along the whole route >

Taro: So that global view is what makes it different from simpler local planners; it’s about anticipating the entire journey ahead >

The paper's improvements: Taro: So we’ve seen how they build that map and use the order gate for simple conflict resolution, but now let's talk about what they suggest they should do next to make it even better >

Rosa: They are looking at a few areas for improvement. First, they want to improve the route-time conflict map itself by making sure it really fuses those detections and partner plans into that occupancy along the ego’s future route more effectively >

Dev: That means getting the prediction of where things will be even tighter when we project it onto your actual path, so you can learn much better whether that stretch ahead will be clear upon arrival >

Taro: And they also want to refine how the system handles those stops that are beyond its two second planning horizon, moving away from just relabeling them toward a more robust labeling scheme based on the ground truth reasons and recorded futures >

Rosa: So instead of just guessing what’s happening in the blind spots, they want a smarter way to infer waiting behavior using the actual history of what happened >

Dev: That sounds like they’re trying to build in some kind of predictive model for those longer waits, so it doesn't just rely on immediate rules >

Taro: And on the order gate side, they are exploring ways to make that agreement mechanism even more reliable when things get really dense in traffic situations, maybe reducing the number of times a full message round is needed >

Rosa: It’s about making the decision-making process for who goes first less dependent on perfect communication and more on strong local consensus >

Dev: That speaks to my concern about real-time loops. If we can reduce that reliance on slow, complex agreements, the loop rate might stay much higher and safer for critical decisions >

Taro: It’s about graceful recovery when the world misbehaves in a dense scenario, instead of just stalling because the order gate couldn't settle quickly enough >

Rosa: And ultimately, it seems like they are trying to move this system closer to something that can handle more chaotic, unpredictable real-world traffic without needing constant manual tuning of the rules >

Dev: So the next step is making sure that when things go wrong in the field—when sensor noise messes up or latency spikes—this entire framework doesn't just fail completely, but degrades predictably rather than breaking down entirely >

Conclusion: Rosa: So we’re wrapping up on "Route-Time Conflict Maps for Cooperative End-to-End Autonomous Driving" by Liu and team by looking at the big picture implications >

Dev: Basically, this paper shows how fusing all that detection data with partner plans into one conflict map lets a planner actually score speed profiles based on whether the path ahead is clear when you arrive >

Taro: It’s about moving beyond just reacting to what's right in front of you to having a global look at the entire route and anticipating future conflicts >

Rosa: And they do this by using an order gate on broadcast trajectories to enforce a shared movement order without needing those slow, complex communication rounds for every minor clash >

Dev: That’s a real reduction in latency for safety decisions, which is something I care about when we talk about real-time loops and failure modes >

Taro: It really changes how we think about cooperative driving, moving it from local reaction to a more global view of the route time conflict map >

Rosa: The results show they hit high scores on benchmarks like InterDrive without traffic and MDrive, suggesting this method is quite effective in controlled environments >

Dev: But we have to remember the caveats. They flag that the system still struggles when it’s not following a fixed route or if it doesn't have those stop sign inputs, which means there are still real limitations to deployment >

Taro: So, while the cooperative behavior looks excellent in tests like allowing vehicle three to cross first at a junction without collisions, we have to keep an eye on what happens when the world throws something totally unexpected at it >

Rosa: Exactly. It’s not just about getting a high score; it’s about seeing how well that system handles the messy, unpredictable stuff outside of perfect training conditions >

Dev: This work lays a solid foundation for end-to-end planning under cooperative constraints, but we'll need to see those improvements they suggested to really know if this scales to complex urban driving >

Taro: I think the next step is testing those suggested improvements against scenarios that are intentionally designed to confuse the system’s reliance on its learned expert labels >

Rosa: We'll keep an eye on how these route-time conflict maps evolve as we push for more robust, real-world cooperative driving systems >

Haohua Que Mingkai Liu, Tianle Zhu, Zhipeng Bao, Yiping Li, Handong Yao

University of Georgia

cs.RO

Submitted: 2026-11-10

Updated: 2026-11-10

Code: https://github.com/cxliu0314/CoLMDriver

License: http://creativecommons.org/licenses/by-nc-sa/4.0/

Importance score: 90/100

The gist: When2Go is a cooperative end-to-end driving system that determines when to proceed by sharing intent under CDA Class B or higher…

Key concepts

Route-Time Conflict Map
This map combines sensor data (detections), predictions (forecasts), and other vehicles' intended paths as occupancy along the ego vehicle's future route. It helps the planner predict if a path will be clear when the ego vehicle arrives at a specific point, enabling proactive planning.
Order Gate
This mechanism uses an antisymmetric precedence network built from right-of-way rules applied to broadcast trajectories. It determines the sequence of movement for conflicting vehicles based on shared messages, ensuring both vehicles agree on a single, cycle-free order without needing complex message rounds.
Relabeling Stops
When a stop sign cannot be observed within the vehicle's short planning horizon (2 seconds), When2Go mimics an expert by relabeling that stop. This means it treats the unobserved stop as if it were a known condition based on learned reasons and future ground-truth data, allowing for continued planning.

Terminology

Summary

When2Go is a cooperative end-to-end driving system that determines when to proceed by sharing intent under CDA Class B or higher, broadcasting LiDAR detections with forecast motion as instance tokens, along with its plan and intended trajectory. p. 0

Where the paper says it

We present When2Go, a cooperative end-to-end driving system that learns when to go by sharing intent under CDA Class B or higher. Each vehicle broadcasts its LiDAR detections with forecast motion as instance tokens, together with its plan and intended trajectory.

The receiver fuses these detections, forecasts, and partner plans into a route-time conflict map. p. 0
Where the paper says it

Each vehicle broadcasts its LiDAR detections with forecast motion as instance tokens, together with its plan and intended trajectory. The receiver draws the fused detections, forecasts and partner plans into a route-time conflict map, the occupancy along its route over the planning horizon, on which a planner scores candidate speed profiles.

A planner then scores candidate speed profiles on this map. p. 0
Where the paper says it

Each vehicle broadcasts its LiDAR detections with forecast motion as instance tokens, together with its plan and intended trajectory. The receiver draws the fused detections, forecasts and partner plans into a route-time conflict map, the occupancy along its route over the planning horizon, on which a planner scores candidate speed profiles.

When two intended trajectories conflict, an order gate—an antisymmetric precedence network distilled from right-of-way rules—decides the sequence of movement for both vehicles based on shared messages, ensuring they reach the same order. p. 0
Where the paper says it

Where two intended trajectories conflict, an order gate, a precedence network distilled from a right-of-way rule, decides who goes first; both vehicles evaluate it on the same messages and so reach the same order. When2Go imitates the rule-based expert of V2Xverse, which sees the simulator’s ground truth; stops that When2Go cannot observe within its 2 s planning horizon are relabelled, so that it does not learn to wait without an observable cause.

When2Go mimics rule-based experts by relabeling stops that cannot be observed within its 2s planning horizon. p. 2
Where the paper says it

Imitating a privileged rule-based expert [12, 49] brings covariate shift [18, 59, 90], causal confusion [2, 16, 20, 77] and a dependence on the expert’s style [92]; rule-based experts score candidates [47], and imitation adapts to what the learner cannot observe [55, 73, 76]. We address the same asymmetry in time: expert stops that When2Go cannot explain within its 2 s planning horizon are relabelled.

The primary contributions are:

  1. A route-time conflict map for cooperative end-to-end planning: This map incorporates fused detections, forecasts, and partner plans as occupancy along the ego's future route, allowing a planner to learn if the path ahead will be clear upon arrival. This is supervised by an expert that relabels stops beyond the 2s horizon. p. 1

    Where the paper says it

    1 and collides with another vehicle in 6 of 100 runs, against 38 to 69 for the cooperative reruns. Our contributions are: • A route-time conflict map for cooperative end-to-end planning: fused detections, forecasts and partner plans as occupancy along the ego’s future route, from which a planner learns whether the route ahead will be clear on arrival, supervised by an expert that sees more, whose stops beyond the 2 s horizon are relabelled; to our knowledge, the first CDA Class B-or-higher end-to-end planner.

    The authors claim this is the first CDA Class B-or-higher end-to-end planner of its kind. p. 1
    Where the paper says it

    1 and collides with another vehicle in 6 of 100 runs, against 38 to 69 for the cooperative reruns. Our contributions are: • A route-time conflict map for cooperative end-to-end planning: fused detections, forecasts and partner plans as occupancy along the ego’s future route, from which a planner learns whether the route ahead will be clear on arrival, supervised by an expert that sees more, whose stops beyond the 2 s horizon are relabelled; to our knowledge, the first CDA Class B-or-higher end-to-end planner.

  2. An order gate for agreement from shared messages: This mechanism uses an antisymmetric precedence network on broadcast intended trajectories to yield a cycle-free order, which is then drawn into the conflict map as occupancy.

  3. State-of-the-art closed-loop results: The model achieved high driving scores across three benchmarks: 97.8 and 90.7 on InterDrive without traffic, 88. p. 0

    Where the paper says it

    With one model, When2Go sets the state of the art on three closedloop CARLA benchmarks: 97. 7 driving score on InterDrive without and with traffic (best published 90.

    2 on MDrive (best rerun 85. p. 0
    Where the paper says it

    0 on the public V2Xverse protocol (best of sixteen rerun methods 59. 2 on MDrive (best rerun 85.

    1), and 70.0 on V2Xverse, with paired confidence intervals provided for comparison against other methods like CoLMIN [34]. p. 1
    Where the paper says it

    • An order gate for agreement from shared messages: an antisymmetric precedence network on the broadcast intended trajectories yields a cycle-free order, drawn into the conflict map as occupancy. • State-of-the-art closed-loop results on three benchmarks with one end-to-end model, with reruns of sixteen methods and two variants on the public V2Xverse protocol and paired 95 % confidence intervals for the differences.

Performance analysis shows When2Go reaches a driving score of 97. p. 1

Where the paper says it

On InterDrive [48], When2Go reaches 97. 7 driving score without and with background traffic (best published 90.

79, 98.25 on V2Xverse repetition 3, and 88. p. 4
Where the paper says it

Repetition r seeds the simulator with 2000+r. Design choices used repetitions 0 to 2 of the same routes; we report unseen repetitions: 3 to 8 on V2Xverse (510 runs) and 3 to 5 on InterDrive with traffic and on MDrive.

p. 4
Where the paper says it

Repetition r seeds the simulator with 2000+r. Design choices used repetitions 0 to 2 of the same routes; we report unseen repetitions: 3 to 8 on V2Xverse (510 runs) and 3 to 5 on InterDrive with traffic and on MDrive.

16 on MDrive repetition 3 with three seeds. p. 4
Where the paper says it

We report the driving score (DS: route completion times the product of the infraction penalties), averaged as each benchmark’s script does, and the success rate (SR: the share of runs, tests or, on MDrive, vehicles with a perfect score); details in Sec. Repetition r seeds the simulator with 2000+r.

The average driving score across benchmarks is high, with the largest margin over the strongest cooperative rerun occurring in lane changes (e. p. 5
Where the paper says it

38); the difference lies in its language-model negotiation, whose sampling the release does not fix (Sec. The largest margin is in lane changes (98.

g., 98.25 and 96.84 against 67. p. 0
Where the paper says it

Top right: the same instant in CARLA; all eight vehicles arrive without a collision. Bottom right: When2Go against the best other method on each axis.

20 and 67.45 in Tab. 4).

The model is trained on labels from Section 3. p. 4

Where the paper says it

0 over the first five), 3 epochs with the route taken from the global plan, and 2 epochs with the map modules. These are added through zero-initialised layers and trained on the labels of Sec.

6 and degraded samples (sensor, delay, loss, pose). p. 4
Where the paper says it

These are added through zero-initialised layers and trained on the labels of Sec. 6 and on degraded samples (sensor, delay, loss, pose).

The loss function is L = L det + L aux + 0. p. 3
Where the paper says it

The executed plan is the regressed profile, capped by the fastest candidate that the risk head accepts (the envelope). With [·]+ = max(·, 0), the running maximum cummaxk and the logistic function sig, sˆk = mincummaxk[ν]+, vmaxtk , a ⋆ = arg max a: sig(ρa)<θ s a T + δ a T , s ⋆ k = minsˆk, cummaxk[s a ⋆ + δ a ⋆ ]+ , (6) with vmax=7.

2L rel + L cls + L reg + 0.5L lat + 0.5L risk + L nom. p. 3
Where the paper says it

trained fixed Cooperative fusion · · · ego queries · · · partner tokens Reliability Self-Attn with bias FFN ×3 attention bias: distance + reliability r · · · fused instances Order gate who goes first intended traj. Precedence network g antisymmetric Acyclic decoding no cycles pass order 1 2 3 ego first: cut plan partner first: zone reserved Route-time conflict map & planner Footprint test occupancy along the route 1 2 s 0 10 20 m time t route position s occupied plan shading: occupancy vehicles pedestrians cyclists partner plans curves: 64 speed profiles low risk high risk 64 candidates + nominal · · · Self-Attn Cross-Attn instances, plans FFN ×3 Heads collision risk per candidate, nominal speed profile Envelope plan = min(nominal profile, fastest low-risk candidate) plan, 10 waypoints Closed loop: left turn (InterDrive) 1 partner 3 partner 2 ego meeting zone reserved for 1 plan messages PID benchmark V2Xverse 1 car + RSU town traffic InterDrive 2–8 cars junctions, merges MDrive 1–8 cars, incl.

At inference, only the envelope, gate geometry, decoding, partner selection, supersede rule, route continuation past its end, rescaling by the configuration's speed factor (Sec. 8), and benchmark PID controller are manually written. p. 1
Where the paper says it

A planner scores candidate speed profiles on this map and learns how far to drive in the next two seconds, from standing still to full speed (Fig. 2); the benchmarks’ PID controller tracks its waypoints, and no hand-written rule overrides them.

The order gate is trained on 400,000 counterfactual pairs derived from training town paths and labeled by the right-of-way rule of Sec. p. 3

Where the paper says it

For vehicles u, u ′ with trajectories y u , y u ′ , a convolutional network g over frame-independent features of all point pairs gives the logit ηuu′ = g(y u , y u ′ ) − g(y u ′ , y u ) = −ηu′u, (7) and u goes first if ηuu′ > 0: for any weights, two vehicles that evaluate the same two messages cannot both claim precedence. g is trained on 400,000 counterfactual pairs labelled by the right-of-way rule of Sec.

3.6, using a tie window of 0. p. 3
Where the paper says it

g is trained on 400,000 counterfactual pairs labelled by the right-of-way rule of Sec. 6 (with a window of 0.

6s and spacing of intended points against 0. p. 5
Where the paper says it

84 against 67. 4), where a vehicle must enter a gap that another controlled vehicle is leaving; there the order comes from the broadcast intended trajectories instead of a negotiation in language [34, 48].

4s on the planner's labels. The precedence network is trained separately on rule-labeled pairs and merged into the checkpoint, yielding an order without cycles where vehicles hearing the same entities decode it identically. p. 5
Where the paper says it

The precedence network of its order gate (0. 27 M parameters) is trained separately on rulelabelled counterfactual pairs (Sec.

The final recipe, trained with three seeds (with seed 0's order gate shared), scores 97.79 on InterDrive without traffic, 98. p. 0

Where the paper says it

With one model, When2Go sets the state of the art on three closedloop CARLA benchmarks: 97. 7 driving score on InterDrive without and with traffic (best published 90.

25 on V2Xverse repetition 3, and 88.16 on MDrive repetition 3. p. 4
Where the paper says it

We report the driving score (DS: route completion times the product of the infraction penalties), averaged as each benchmark’s script does, and the success rate (SR: the share of runs, tests or, on MDrive, vehicles with a perfect score); details in Sec. Repetition r seeds the simulator with 2000+r.

The full recipe scores are reported as 97. p. 1
Where the paper says it

When2Go draws everything that can block this stretch, the fused detections with their forecast motion and the plans that partner vehicles broadcast, as occupancy over route position and future time: a route-time conflict map. A planner scores candidate speed profiles on this map and learns how far to drive in the next two seconds, from standing still to full speed (Fig.

79, 95.78 and 94.89 with seeds 0 to 2; the variant without the map scores are lower with seeds 1 and 2, while the BEV variant scores are also compared across seeds against published methods (best published method: 90. p. 5
Where the paper says it

8 points above the best published method, CoLMIN [34]. Our rerun of CoLMDriver scores below its reported values, while the same harness reproduces those of CoDriving (74.

12). The full recipe leads the variant without the map when averaged over three seeds. p. 7
Where the paper says it

3 over three training seeds, Sec. Without traffic, removing the partner plans from the map costs 6.

Qualitative results demonstrate superior cooperative behavior; for instance, When2Go allows vehicle 3 to cross first at a junction, resulting in all four vehicles arriving without collision (DS 100), contrasting with CoDriving [49], which resulted in collisions and time-outs (DS 2. p. 3

Where the paper says it

trained fixed Cooperative fusion · · · ego queries · · · partner tokens Reliability Self-Attn with bias FFN ×3 attention bias: distance + reliability r · · · fused instances Order gate who goes first intended traj. Precedence network g antisymmetric Acyclic decoding no cycles pass order 1 2 3 ego first: cut plan partner first: zone reserved Route-time conflict map & planner Footprint test occupancy along the route 1 2 s 0 10 20 m time t route position s occupied plan shading: occupancy vehicles pedestrians cyclists partner plans curves: 64 speed profiles low risk high risk 64 candidates + nominal · · · Self-Attn Cross-Attn instances, plans FFN ×3 Heads collision risk per candidate, nominal speed profile Envelope plan = min(nominal profile, fastest low-risk candidate) plan, 10 waypoints Closed loop: left turn (InterDrive) 1 partner 3 partner 2 ego meeting zone reserved for 1 plan messages PID benchmark V2Xverse 1 car + RSU town traffic InterDrive 2–8 cars junctions, merges MDrive 1–8 cars, incl.

71).

The model's performance is sensitive to controller modifications; modifying the benchmark's default controller to steer by network waypoints instead of the route point, while turning off the forced push, yields a gain of 4.6 points on V2Xverse ([+1. p. 1

Where the paper says it

Cooperative perception fuses raw points [11], features [10, 72, 81, 82] or objects, selects what to send [31] and copes with latency [43, 75], pose error [52] and lossy links [44, 58]. Cooperative end-to-end planners build on it, in closed loop on V2Xverse [33, 45, 49], on logged data [15, 42, 56, 65, 83, 85, 86] and on real vehicles [57].

8, +7.6], paired), though this modification reduces MDrive success rate by 3. p. 6
Where the paper says it

6 points on V2Xverse ([+1. 6], paired) and is within noise elsewhere, although the success rate on MDrive is 3.

2 points (77. p. 1
Where the paper says it

Related Work Cooperative perception and end-to-end driving. Cooperative perception fuses raw points [11], features [10, 72, 81, 82] or objects, selects what to send [31] and copes with latency [43, 75], pose error [52] and lossy links [44, 58].

1 against 80. p. 0
Where the paper says it

Top right: the same instant in CARLA; all eight vehicles arrive without a collision. Bottom right: When2Go against the best other method on each axis.

3). Switching off the forced push trades blocked runs for collisions; in one test, 102 of 132 vehicle collisions followed a push within 5s, while the driving score changed within noise. p. 7
Where the paper says it

trades blocked runs for collisions (Tab. 5): 102 of the 132 vehicle collisions of When2Go then follow a push within 5 s, while the driving score changes within noise.

Limitations include the planner following the given route without independent lane changes or incorporating traffic-light/stop-sign inputs. p. 7

Where the paper says it

Limitations. The planner follows the given route without lane changes of its own and has no traffic-light or stop-sign input; the network senses with LiDAR only; its labels and those of the order gate come from privileged simulator state and rules; the order gate chooses 8

The system senses only via LiDAR and relies on privileged simulator state and rules for its labels and order gate training. p. 7
Where the paper says it

Limitations. The planner follows the given route without lane changes of its own and has no traffic-light or stop-sign input; the network senses with LiDAR only; its labels and those of the order gate come from privileged simulator state and rules; the order gate chooses 8

Furthermore, the order gate selects between two fixed plans, leading to stalls in 24 of 138 runs with traffic. p. 8
Where the paper says it

between two fixed plans; pairs stall in 24 of 138 runs with traffic; and all results are in simulation. Acknowledgments We thank the Georgia Advanced Computing Resource Center (GACRC) for computing resources and the TRAVELS project for its support.

Green — the paper says it, and the page is printed. Red — no passage carries it, so treat that sentence as unverified. The same check runs on your own text: check a summary against its source, $5.

Improvements for AI systems

  1. Route-Time Conflict Map for Cooperative End-to-End Planning: The system can generate a route-time conflict map by fusing fused detections, forecasts and partner plans as occupancy along the ego’s future route, allowing a planner to learn whether the route ahead will be clear on arrival.

  2. Order Gate for Agreement from Shared Messages: The system implements an order gate that uses an antisymmetric precedence network on the broadcast intended trajectories to decide who goes first, ensuring both vehicles reach the same order without message rounds of Class C.

  3. Imitating Expert Behavior via Relabeling: The system learns when to wait by stopping stops that it cannot observe within its planning horizon and instead relabeling them based on the logged reasons and the recorded futures of the ground-truth boxes.

Abstract

Existing cooperative end-to-end driving works at Class A (status-sharing) of the SAE J3216 classes of cooperative driving automation (CDA): vehicles exchange what they perceive, not what they intend, so each plans alone when to go, which limits cooperation and leads to deadlock when both vehicles yield or to collisions when both go. We present When2Go, a cooperative end-to-end driving system that learns when to go by sharing intent under CDA Class B or higher. Each vehicle broadcasts its LiDAR detections with forecast motion as instance tokens, together with its plan and intended trajectory. The receiver draws the fused detections, forecasts and partner plans into a route-time conflict map, the occupancy along its route over the planning horizon, on which a planner scores candidate speed profiles. Where two intended trajectories conflict, an order gate, a precedence network distilled from a right-of-way rule, decides who goes first; both vehicles evaluate it on the same messages and so reach the same order. When2Go imitates the rule-based expert of V2Xverse, which sees the simulator's ground truth; stops that When2Go cannot observe within its 2 s planning horizon are relabelled, so that it does not learn to wait without an observable cause. For our runs only, the benchmarks' PID controller steers by When2Go's waypoints instead of the route, and its forced push of long-waiting vehicles is off. With one model, When2Go sets the state of the art on three closed-loop CARLA benchmarks: 97.8 and 90.7 driving score on InterDrive without and with traffic (best published 90.1 and 78.9), 70.0 on the public V2Xverse protocol (best of sixteen rerun methods 59.1) and 88.2 on MDrive (best rerun 85.1), with 95.0% of its vehicles collision-free (87.7%).

Sources

Related papers