When several AI agents must act at the same moment, there is often more than one sensible joint outcome. Two self-driving cars at an unmarked intersection can agree that either one goes first, but if both pick "I go first" they collide. Game theorists call this the equilibrium selection problem: a situation has several stable outcomes, and independent agents may aim for incompatible ones. In real-time settings a second fact gets little attention. Thinking takes time. An agent that deliberates longer acts later, and an agent that acts later can see what the other already did. Latency therefore does more than add cost. It quietly turns a simultaneous game into a sequential one, where the first mover is a leader and everyone else responds. In game theory this sequential form is called a Stackelberg game, and in it the leader commits and the follower simply best-responds.
This note proposes to use that effect deliberately. We would build a lightweight "deadline mediator" that coordinates black-box language-model agents by deciding who must commit first and how much thinking time each agent gets. It does not inject persuasive text into their prompts. Our main claim is that assigning commitment order and deliberation budgets can resolve coordination failures in games where message-based mediation is known to fail, especially the game of Chicken. It can also do this within real-time deadlines. A secondary claim concerns reasoning transfer. Once commitment is sequential, the follower's task becomes a single-agent optimization problem, and that is exactly the kind of skill that reinforcement learning on math is known to transfer. So we predict that math-trained reasoning helps agents much more as followers than as simultaneous guessers.
Core Claim and Why It Is Not Already Done
The closest prior system is Learning to Mediate Equilibrium Selection in LLM Games. It trains a small reinforcement-learning controller that watches action histories in TextArena social dilemmas and decides when to insert pre-written game-theoretic advice into agents' prompts. That controller raised cooperation for Granite-4.1-30B by +23.7 percentage points in Stag Hunt and +10.8 points in the Iterated Prisoner's Dilemma. In Chicken, however, the authors report that "no amount of mediation helped," because advice that binds no one is ignored when exploiting a cooperator pays so well. The same work never measures time, and every intervention lengthens the prompt. Our proposal keeps its black-box, learned, selective-intervention design. We change what the mediator is allowed to do: it controls a clock instead of writing a message. A commitment that is visible before the follower acts is binding by construction. This addresses the specific failure that paper documents.
Leader-follower structure is itself an old idea for breaking symmetry. Bi-Level Actor-Critic (by Haifeng Zhang) and the STEP single-step hierarchy method (by Bin Zhang et al.) build leader-follower asymmetry into multi-agent reinforcement-learning training. Joshua Letchford et al. showed how to approximate commitment policies efficiently. These works supply the idea that commitment removes ambiguity. They differ from ours in three ways: they fix the hierarchy inside trained policies, they assume unlimited decision time, and they need access to the agents' learning. We impose the hierarchy at inference time on frozen language-model agents, choose the leader afresh each round from the observed state, and let the deadline itself enforce the hierarchy.
Payment-based steering, such as sublinear-budget mediation in Steering No-Regret Learners to a Desired Equilibrium and strategic taxation by David C. Hyland et al., changes the payoffs themselves. It needs a transfer channel and knowledge of the payoffs, and neither exists between cars at an intersection. Our mediator uses no payments.
The Setting, Stated Precisely
Each round, agent $i$ receives an observation, deliberates, and emits an action $a_i$ at wall-clock time $t_i$. If $t_i > T$, where $T$ is the round deadline, the agent's action is replaced by a fixed fallback: brake or hold for vehicles, and the previous action for text games. The mediator chooses a leader $\ell$ and budgets $b_\ell$ and $b_f$ for the leader and the followers. The leader must commit within $b_\ell$. Followers see the leader's action and must respond within $b_f$, subject to $b_\ell + b_f \le T$.
The mediator is trained with the same black-box observations used in the prior mediation work: past actions, round index, and scores, plus measured latencies. Its reward is
$$ R = W(a) - \lambda \, \mathbb{1}[\text{crash or deadlock}] - \mu \, \mathbb{1}[\max_i t_i > T], $$
where $W$ is total welfare, $\lambda$ penalizes mutually destructive outcomes, and $\mu$ penalizes deadline misses. Choosing "no leader" is always allowed, and in that case all agents play simultaneously. This lets the mediator learn to stay out of the way, as the text mediator learned to do.
The design choice that makes the problem non-trivial is that the right leader must vary from round to round. In our game variants, payoffs are randomly asymmetric each round. Some examples: one vehicle has an emergency, one firm has lower cost, or one player's information is more precise. Welfare is highest when the agent with the larger stake or better information leads. A fixed turn order or a coin flip therefore cannot be optimal, and the mediator must read the state.
Research Program
The first component is a timed version of TextArena, built on TextArena, covering the four games used in the prior mediation study: Iterated Prisoner's Dilemma, Stag Hunt, Chicken, and Bertrand price competition. Real wall-clock deadlines are enforced on a fixed GPU. Deadlines are swept from generous (where the result should approach the untimed prior setting) down to tight (where only short reasoning fits).
The second component is a physical coordination task. We use multi-drone intersection deconfliction in Microsoft AirSim, as run in When Replanning Becomes the Bottleneck: Budgeted Replanning for Embodied Agents. We make it non-cooperative by giving each drone its own time-to-goal reward. We also use unsignalized intersections and ramp merges in LimSim++, which AgentsCoMerge used for merging. AgentsCoMerge resolved merge priority through free-form "self-committing" messages but needed seconds per cycle, and LimSim++ reports 15.97 seconds per GPT-4 decision. We treat those systems as evidence that language-level negotiation is too slow at 10Hz. Our mediator replaces that negotiation with a single leader assignment.
The third component is the transfer study. The agents are the models from the prior mediation paper (Llama-3.3-70B, Granite-4.1-30B, DeepSeek-R1-Distill-Qwen-7B). We add matched pairs that differ only in math-trained reasoning:
- a Qwen2.5 base model with and without the GRPO-derived reasoning vector from Reasoning Vectors, which adds weight differences from math RL to a base model;
- models trained with Self-Braking Tuning, which learn to stop reasoning early and carry that behavior to science benchmarks;
- where feasible, a CPL plan-level model, which learns abstract planning steps through tree search and transfers them to code and science.
The hypothesis, which the prior literature motivates but has not tested, is that these transferred skills help with "best-respond to a known commitment" and "stop thinking once the answer is settled." They should not help much with guessing what a peer will do simultaneously. Self-braking matters in a specific way here: an agent that stops early commits early, and so becomes the de facto leader even without a mediator.
Baselines
The naive reference point is unassisted simultaneous play under the same deadline, with every agent given the full budget $T$. This reproduces the prior paper's never-intervene condition but adds time pressure, which should make results worse because agents will now miss deadlines.
The strongest existing method is the PPO text mediator from Learning to Mediate Equilibrium Selection in LLM Games. We reimplement it with the same observation features, the same training episodes, and the same hyperparameter-search budget as our deadline mediator. We run it under the same wall-clock deadline, so the tokens its interventions add count against the agents' time. We also run it untimed to check that our reimplementation recovers the reported gains of +23.7 points in Stag Hunt and +10.8 points in the Iterated Prisoner's Dilemma for Granite-4.1-30B. The prior paper reports no positive result in Chicken, so beating it there only requires a clear welfare gain over never-intervening. In Stag Hunt and the Prisoner's Dilemma, we must match its untimed gains while also meeting deadlines it misses.
For the physical tasks, the strongest latency baseline is BRACE with E-RECAP from the same replanning paper. BRACE budgets and spaces out replanning calls, and E-RECAP prunes old context. That paper reports that BRACE with E-RECAP cut deadline violations from 85.5–100% down to 4.7–50.0%. On AirSim, we must match its violation rate while lowering the collision-plus-deadlock rate in the competitive variant.
Two cheap structural baselines isolate our key ingredient. The first is a fixed priority rule that always gives the same agent, or the agent approaching from the right, the lead. The second is a fair coin that picks the leader each round. The coin is a correlated signal, in game-theory terms a correlated equilibrium device. Both baselines receive the same budget split as our mediator.
Two further ablations complete the comparison. One learns commitment order but gives equal budgets to all agents, which tests whether budget allocation matters. The other learns budgets with simultaneous play, which tests whether ordering matters. Beating these ablations is what shows that learned, state-dependent leader choice is the source of the gain.
Why not just…?
Why not just impose a fixed turn order, like a right-of-way rule? In symmetric games this is a real threat. It removes collisions at zero learning cost. We would report it honestly, and if it matches our mediator on symmetric games, we will say so. Our claim rests on the asymmetric variants, where welfare depends on which agent leads. There the prediction is that a fixed order leaves welfare unrealized in exactly the rounds where the wrong agent holds priority. The breakdown of welfare by payoff asymmetry settles this directly.
Why not just flip a coin to pick the leader? A shared random signal is the textbook fix for miscoordination and is almost free. It removes crashes as well as any ordering does. Its weakness is the same as the fixed rule's: it ignores state. We therefore expect it to tie with our mediator on crash rate and lose on welfare in the asymmetric games. If it ties on welfare too, our state-dependent mediator adds nothing beyond sequentialization. We would then reframe the contribution as showing that deadline-enforced ordering, not persuasive text, is what defeats Chicken. That claim would still contradict the prior mediation paper's negative result.
Why not just give the text mediator more tokens, or use a stronger model that reasons longer? The prior mediation paper already shows that advice which binds no one fails in Chicken, and that indiscriminate nudging slightly hurt the already cooperative Llama-3.3-70B. More text also costs time. LimSim++ and AgentsCoMerge report multi-second decisions, which are incompatible with 10Hz control. Our deadline sweep measures directly how the text mediator degrades as $T$ shrinks.
Why not just train a fast multi-agent reinforcement-learning policy with no language model? It meets latency easily, but VLMLight shows that such a policy ignores meaning in the scene: its reported dual-branch system cut emergency-vehicle waiting by up to 65% over pure reinforcement learning. That policy also cannot act for heterogeneous, prompted agents it was never trained with. We include a PPO driving policy on LimSim++ as a reference so that readers can see the welfare-versus-semantics trade-off.
Proposed Experiments and Decisive Checks
We report welfare, cooperation rate, crash-plus-deadlock rate, and deadline-violation rate, along with median and 99th-percentile decision latency. Each is averaged over at least five seeds, with confidence intervals. The work stands or falls on four checks.
The first check is Chicken. In timed Chicken, the deadline mediator should lower the mutual-crash rate and raise welfare relative to both never-intervening and the text mediator, where the prior work found no text-mediation gain. This is the sharpest test.
The second check is the latency frontier. As $T$ shrinks, the deadline mediator's deadline violations should stay near zero. The reason is that followers need only a short budget to best-respond, while the text mediator's violations should rise.
The third check is the transfer asymmetry. For each matched pair with and without the reasoning vector, and with and without self-braking, we measure the accuracy gain in the follower role and in the simultaneous role. We predict a larger gain in the follower role. A null result would itself be informative: it would mean that math-trained reasoning does not carry over to strategic best-response. We also test whether self-braking models become leaders more often when there is no mediator, which would show that learned stopping behavior changes who leads.
The fourth check is state-dependence. On the asymmetric variants, our mediator must beat both the fixed-order and coin-flip baselines on welfare while matching them on crash rate. If it does not, we narrow the claim as described above.
The expected contribution is a direct test of whether inference latency can serve as a coordination tool rather than only a cost. We would also deliver a timed version of the TextArena games and competitive AirSim and LimSim++ tasks on which future real-time coordination methods can be compared.
References
- Learning to Mediate Equilibrium Selection in LLM Games
- Steering No-Regret Learners to a Desired Equilibrium
- TextArena
- When Replanning Becomes the Bottleneck: Budgeted Replanning for Embodied Agents
- LimSim++: A Closed-Loop Platform for Deploying Multimodal LLMs in Autonomous Driving
- AgentsCoMerge: Large Language Model Empowered Collaborative Decision Making for Ramp Merging
- Reasoning Vectors: Transferring Chain-of-Thought Capabilities via Task Arithmetic
- Let LRMs Break Free from Overthinking via Self-Braking Tuning
- CPL: Critical Plan Step Learning Boosts LLM Generalization in Reasoning Tasks
- VLMLight: Safety-Critical Traffic Signal Control via Vision-Language Meta-Control and Dual-Branch Reasoning Architecture