Who Caused the Brake? Blame-Aware Prediction of Trust Recovery in Multi-Agent Driving

When an automated car brakes hard, the person supervising it may lose trust for half a minute or longer, or may take the wheel and not give it back. Existing models of this "trust recovery latency" (the time it takes trust to return to its pre-failure level after an error) treat the interaction as a pair: one human, one machine, and a stream of outcomes the machine is fully responsible for. Real traffic is not like that. The same hard brake can be the car's own mistake, such as braking for an obstacle that isn't there, or a correct defensive reaction to another driver who cut in. Our hypothesis is that people recover trust at very different rates in these two cases. If so, a trust model that sees only the car's own outcomes will systematically mispredict recovery in exactly the multi-agent situations where it matters most.

We propose to test this hypothesis directly and to build a trust predictor that can tell the cases apart. The predictor uses a multi-agent motion forecaster, a model that predicts how surrounding road users will move given the car's own actions, to compute a counterfactual blame signal: would the car's planned path have led to a conflict, given what the other agents actually did? This signal is attached to automatically segmented interaction events, and the events are organized in a three-level history of ticks, events, and session. In short, we turn the open problem of multi-agent blame in trust research into a measurable quantity and ask whether it explains recovery latency that ego-only models cannot.

Core Claim

Trust recovery latency after a safety-relevant maneuver depends on who was responsible for the maneuver, not only on whether it happened. A forecaster's counterfactual estimate of that responsibility predicts human recovery and takeover persistence better than models that see only the automated vehicle's own performance. The new parts are the blame signal, a human study that varies blame while holding the vehicle's maneuver fixed, and an evaluation of recovery latency per event rather than of aggregate trust. The hierarchical history encoder is a supporting design choice that we test by ablation. We do not assume it is needed.

Grounding in Prior Work

Three findings from the trust literature motivate the work. Recovery is slow and asymmetric. A Case Study of Trust on Autonomous Driving used a motion simulator with real-time Likert buttons and found that trust needed roughly 30 seconds of error-free driving before it rose at all, that reaction latency to trust drops ranged from 1.0 to 9.5 seconds, and that missed alarms hurt trust more than false alarms. A Diachronic Perspective on User Trust in AI under Uncertainty showed in a betting game that five confidently incorrect answers depressed trust permanently despite 45 later correct ones. A flat recurrent network (a GRU) matched human decisions with 89.7% agreement. Blending Participatory Design and Artificial Awareness for Trustworthy Autonomous Vehicles fit Markov chains to 1,236 autonomy-level choices and found manual takeover to be close to an absorbing state, persisting with 75–100% probability. All three studies treat the machine as the sole author of each outcome. Tanevska et al. did include externally caused events (cut-ins and slowing vehicles), but their memoryless chain cannot represent why an event happened. That gap is the one we target.

Two papers supply the methods we reuse. Improving Trust Estimation in Human-Robot Collaboration Using Beta Reputation at Fine-grained Timescales tracks trust within a task using an asymmetric Beta update with forgetting. It reduced estimation error from 18.17% to 0.18% compared with post-task binary updates, and it is our strongest classical baseline. Prediction by Anticipation predicts how surrounding vehicles react to a proposed ego action, for example how followers decelerate when the ego brakes hard. That kind of conditional prediction is exactly what a counterfactual blame computation requires.

Trust-Aware Motion Planning under Distribution Temporal Logic Specifications constrains the design. It plans against a latent trust belief in CARLA and raises specification satisfaction from 77.5% to 85%. Its trust dynamics, however, are a fixed prior from a crowdsourced study and are blind to other agents. We deliberately do not build a closed-loop trust-aware planner. A planner is only as good as its trust model, and the trust model is the piece that is currently wrong for multi-agent scenes.

On hierarchy, XG-Guard showed that pairing a sentence-level stream with a token-level stream catches anomalies in multi-agent LLM dialogue that either stream misses alone, reaching 99.56% AUROC on InjecAgent. It works on pre-segmented text, though. The file also flags fixed segment boundaries as a general limit of hierarchical encoders. Our hierarchy must instead find its own event boundaries in a continuous driving stream.

Research Program

The model has three levels. At the tick level (10 Hz), it encodes ego and surrounding-agent kinematics. At the event level, the stream is cut into interaction events wherever the multi-agent forecaster's prediction error, or "surprise," spikes. Each event receives a short embedding plus a blame score. At the session level, a recurrent model runs over event embeddings. It carries long memory, so it can represent "this car once braked for nothing" across many quiet minutes, which is what the absorbing-state and confidently-incorrect findings demand.

The blame score is the key ingredient. Let $\pi_0$ be the ego vehicle's plan just before the event, and let $Y_{-e}$ be the trajectories the other agents actually followed. The forecaster gives $c = P(\text{conflict} \mid \pi_0, Y_{-e})$. This is the probability that the car would have collided or nearly collided had it continued as planned. A high $c$ means the maneuver was forced by another agent. A low $c$ with a hard maneuver means the car acted on its own. A second, mirrored score measures how strongly other agents had to evade the ego, which captures cases where the car caused someone else's emergency without itself failing. We compute both scores with an action-conditional forecaster in the style of Prediction by Anticipation, trained on public trajectory data (NGSIM I-80, Argoverse) and fine-tuned on simulator logs.

Data must come from a new study, since no dataset in the file pairs continuous trust traces with varied multi-agent blame. In CARLA, about 60 participants supervise an automated car across sessions. The design uses matched scenarios in which the ego maneuver (deceleration profile and timing) is identical, while its cause varies. The cause is either an aggressive cut-in that forces the brake, a phantom brake with no external cause, or a car-initiated merge that forces another agent to evade. Trust is recorded continuously with a handheld slider, following Sheng et al.'s button protocol. Takeovers are logged, and skin conductance is recorded as a secondary channel because Sheng et al. found physiology and self-report can diverge. Background traffic is scripted. If ProSim is available, its promptable closed-loop agents (0.28 m ADE over 8 s under full prompting) could generate varied but controllable cut-ins. This is optional, and we do not depend on it.

Baselines

The naive reference is a no-memory, ego-only predictor. It holds each participant's pre-event trust constant, or decays the drop toward baseline at the population-average rate. For recovery latency, it predicts the population mean, which Sheng et al.'s 30-second floor suggests will be long. Any useful model must clearly beat this.

The strongest classical competitor is Dagdanov et al.'s fine-grained asymmetric Beta reputation with forgetting. It already encodes the asymmetry that the trust literature identifies, and it updates within a task. We fit its success and failure weights and its forgetting factor per participant on training sessions, using the same ego-performance signal our model receives. Its reported result is 0.18% absolute error versus 18.17% for binary updates on their robotic tiling task. No reported result found on Lacuna for it on driving or multi-agent data.

The strongest learned competitor is a flat GRU over tick-level ego features, as in Dhuliawala et al. It reported 89.7% agreement with human betting decisions. No reported result found on Lacuna for driving trust or takeover prediction. We also include Tanevska et al.'s absorbing-state Markov chain for takeover persistence.

All learned models get the same participant splits, the same input streams except for the blame features under test, and the same hyperparameter search budget, matched by trial count. Evaluation uses held-out participants.

Two ablations isolate the proposal's ingredients. The first gives the flat GRU and the Beta model the blame score as an extra input, which separates the value of blame from the value of hierarchy. The second replaces surprise-based segmentation with fixed windows. Beating the field means lower error in predicting recovery latency on held-out participants, and higher AUROC for whether a takeover persists, with the gain concentrated on externally caused events. The comparison should also show that the gain survives giving the baselines the blame feature, or, if it does not, that it is attributable to blame rather than to architecture.

Why not just…?

Why not just use asymmetric Beta reputation, which already captures fast loss and slow recovery? It captures asymmetry with respect to the car's own outcomes. It has no input that distinguishes a forced brake from a phantom brake when the two have identical kinematics, and our matched-scenario design produces exactly that case. If participants do not recover differently across these cases, Beta reputation is sufficient and we will say so. The manipulation check below settles this first.

Why not just add a "nearby aggressive agent" proximity heuristic instead of a counterfactual forecaster? This is a real threat. In clean scripted cut-ins, proximity may correlate almost perfectly with blame. It breaks in the third scenario family, where the car causes another agent's evasion while its own kinematics look smooth, and in cases where an agent is close but irrelevant. We run proximity-based blame as an explicit ablation. If it matches the forecaster on all scenario families, we recommend the heuristic.

Why not just a flat GRU over the whole stream, as in Dhuliawala et al.? Their 89.7% agreement shows that flat recurrence captures history in a dyadic task. Our hierarchy is justified only if session-scale memory across many quiet minutes, together with per-event attribution, matters. The flat-plus-blame ablation tests this directly. If it ties the hierarchical model, we drop the hierarchy and report blame as the contribution.

Proposed Experiments and Decisive Checks

The first check is behavioral and comes before any modeling. It asks whether, holding the maneuver fixed, the cause changes recovery latency, measured as seconds to regain pre-event slider trust, and takeover persistence, compared with Tanevska et al.'s 75–100% figure. We preregister a mixed-effects analysis with participant random effects. A null result here is publishable on its own, because it would mean dyadic trust models are adequate for traffic.

The second check is predictive. On held-out participants, we compare models by error in predicting recovery latency, slider-trajectory error over the 60 seconds after an event, and takeover-persistence AUROC, reported separately by scenario family. The proposal succeeds if blame-aware models beat both the Beta and GRU baselines on forced and car-caused events without losing on phantom events.

The third check validates the blame score itself. After each session, participants rate who was responsible for each event. We correlate these ratings with $c$, and we test whether the model's errors shrink when $c$ agrees with human attribution and grow when it disagrees. That pattern would indicate the signal tracks perceived rather than physical blame. Physiological channels are analyzed separately, to see whether skin-conductance recovery follows the same blame dependence as self-reported trust or, as Sheng et al.'s weather result hints, diverges from it.