At the ITS America 2026 exhibition and on a roadshow visiting local ITS chapters, Commsignia ran a live demo built on fused sensor data at a real intersection. The data showed something a road operator can't ignore: a high number of near-miss events, the kind that turn into real crashes if nothing changes. But the number by itself didn't say why. It just said something was wrong, over and over, at the same intersection.

Read on to learn more about

• fixing near-miss events in traffic

• how to obtain trusted data

• managing incidents instead of alert volumes

How can you fix near-misses

A raw count of near-misses shows what's the problem, but doesn't tell an operator how to fix it. A pedestrian-behavior problem and drivers failure to yield can both cause 'near-misses', and they call for completely different countermeasures. So we went looking for the 'why', using Trust Engine.

By fusing signal-phase data, pedestrian walk/don't-walk data, and detection data together, instead of reading any one of them alone, the pattern traced back to a single root cause: a permissive left turn with a 46% failure-to-yield rate. That's the shift ground truth makes possible.

From 'here's what happened' to 'here's what to fix before someone gets hurt.'

What 'ground truth' actually means

Commsignia's Trust Engine is built around a specific definition of that reconciled picture: not what one camera, radar, LiDAR, V2X message, signal controller, or third-party feed says on its own, but the ground truth calculated by checking independent sources against each other. Two sources agreeing is evidence; two disagreeing tells the system exactly where to look closer.

Every sensor has blind spots.

• Cameras can lose a pedestrian in shadow

• Radars can miss stationary objects

• Human observers may miss what happens off to the side

Any system built on a single data source will occasionally be confidently wrong. What's worse: it can't tell you when.

This gap matters more and more, because agencies are asking infrastructure to do more than record what happened. Preemption, driver alerts, and eventually connected and automated vehicles all act on the data automatically. You can't automate a decision built on data you can't trust.

Two extremes, same root problem

Even if a sensor is right about an event, there's a time dimension to get wrong. Any system that only checks in at intervals might see a stalled vehicle, log it, and check back 30 minutes later to find the road clear. But nothing tells it when the vehicle actually left, or what happened at that spot in between. A snapshot confirms a moment, not a timeline, and a lot can happen on a road in 30 minutes.

The other extreme floods the system with false volume instead. Sensors may see the very same vehicle stalled on the shoulder every five minutes and log the event multiple times, as if they were different vehicles involved in the same type of incident, because nothing tells the systems they're looking at the same thing. Multiply that across a corridor, and operators end up managing alert volume instead of actual incidents.

Because Trust Engine fuses cameras, LiDAR, radar, V2X messages, and third-party feeds into one reconciled object model rather than one alert stream per sensor, three detections of the same stalled vehicle collapse into a single verified event.

Built for what your already have

Trust Engine is vendor-agnostic, plugging into legacy cameras, existing RSUs, and third-party feeds. No rip-and-replace required, and that's deliberate: the fastest way to lose an agency's trust is to ask them to tear out infrastructure they just paid for.

It's also API-first, piping trusted insights directly into traffic management software, BI tools, and existing workflows.

One engine, four suites

For teams who want a turnkey interface for Trust Engine, Commsignia offers single sign-on access to modules tailored to a specific role. Road operators get the Roadway Intelligence Suite; fire districts and emergency responders get the Emergency Safety Suite; transit agencies get the Fleet Suite. All three run on the same Trust Engine and extend it as new use cases come up.

The fourth package, the Automotive Suite, is used by automakers and is already being widely implemented in mass-produced vehicle programs. On one hand, it serves as a source of information for operators of roadside V2X infrastructure; on the other hand, it also functions as an end user, as it receives real-time data provided by the Trust Engine.

FAQ

What is root-cause traffic safety analytics? It's analysis that explains why a safety pattern is happening by fusing signal, pedestrian, and detection data together, rather than only counting how often it happens.

How is this different from a standard crash-data dashboard? Crash dashboards are built on reported crashes, which happen after the fact and undercount near-misses. Root-cause analytics works from live sensor and signal data to flag patterns before a crash occurs.

Does this require new sensors at the intersection? Not necessarily. Root-cause analytics can run on data from cameras, radar, and signal controllers an agency already has, fused into one reconciled model.

What's the difference between a live view and a historical dashboard? A live view shows current conditions at an intersection; a historical dashboard shows the trend over time, which is what supports a funding or design decision.

How does this reduce alert fatigue from duplicate detections? By reconciling multiple sensors' reports of the same real-world event into one confirmed incident instead of logging each sensor's detection separately, so a single stalled car doesn't turn into three separate safety event for an operator.