Latent Neighbor Messages for Language-Model Traffic Controllers

Small language models that have been specialized for one job can now run individual traffic intersections. They beat much larger general models at it, and they explain their choices in words. The hard part is getting neighboring intersections to cooperate. A traffic light must pick a phase every few seconds, which is far less time than a language model needs to write and read paragraphs about what the next intersection is doing. The current best system works around this by having each intersection reason in text in the background and cache short written directives for its neighbors. Text is slow to produce, has no notion of how out of date it is, and discards the structure that graph neural networks exploit. A graph neural network is a model that updates each node by combining learned messages from its neighbors, regardless of how many neighbors there are or how they are numbered.

We propose that each intersection's specialized controller emit a small vector "message" taken from its own hidden state instead of a written note. A lightweight graph attention layer combines the messages arriving from neighbors, weights each one by how relevant and how fresh it is, and feeds the result into the local model as a few soft input vectors at decision time. We first train these vector messages to imitate the slow written cooperation, then refine the whole system with reinforcement learning while messages are randomly delayed and dropped. The central claim is that latent graph messages can keep the language-grounded transfer of specialized controllers and recover the cooperation benefit of text, at a small fraction of the cost and latency, while degrading more gracefully than either text caching or classical vector policies when communication is unreliable.

What exists and where this sits

The specialized-controller line motivates the work. LLMLight turned a compact model into a traffic controller (LightGPT-0.5B) through imitation of GPT-4 trajectories, critic filtering, and ranking-based refinement, and reported that it outperformed Llama2-70B and classical reinforcement learning. Each of its intersections acts alone. CoLLMLight adds network-level cooperation through a "think-ahead, act-now" split. A background module reasons in text about adjacent intersections and caches directives, and a real-time module reads the cached text alongside local observations. Trained on a synthetic 4×4 grid, it transferred zero-shot to real networks of up to 1,176 intersections. CoLLMLight is the system we must beat. We keep its asynchronous split and its training data. We change what travels along each road link: a fixed-size vector instead of verbal summaries.

The classical graph line supplies the aggregation method. CoLight used graph attention over incoming road links so that intersections weigh upstream queues without a fixed ordering. HAMA showed that attention-based aggregation produces fixed-size embeddings that transfer across very different agent counts. Both assume every node updates in lockstep, which is the assumption we remove. The Holy Grail of Multi-Robot Planning supplies the training recipe. It distilled a centralized expert into decentralized graph policies by training the message function jointly with the policy under DAgger, a method that keeps relabeling the student's own visited states with the expert's actions. In our case the "expert" is CoLLMLight's slow text cooperation, and the students are fast latent messages.

The latent-communication line supplies the injection mechanism and also sets a constraint. LatentMAS passes hidden states and key-value caches between agents and reports 70.8%–83.7% fewer tokens. Thought Communication in Multiagent Collaboration extracts shared "thoughts" with a sparse autoencoder and injects them as prefix vectors. Both target static reasoning benchmarks over small, fully connected or sequential groups of agents. Neither uses topology-aware routing, a notion of message age, or physical deadlines. Shipping full key-value caches between hundreds of intersections every few seconds is also not plausible bandwidth. We borrow their prefix injection but compress each message to a few hundred numbers. Text-based graph systems such as Graph-of-Agents and AgentConductor build graphs of language-model agents but communicate in generated text on turn-based benchmarks. They show that structure matters, but they leave real-time physical coordination open.

Core Claim

At each tick, intersection $i$ holds the most recent message $h_j$ received from each neighbor $j$ in its road-network neighborhood $N(i)$, together with that message's age $\tau_{ij}$ in seconds. It forms

$$ m_i = \sum_{j \in N(i)} \alpha_{ij}\, W h_j, \qquad \alpha_{ij} = \mathrm{softmax}_j\big(a(h_i, h_j, \phi(\tau_{ij}))\big), $$

where $W$ is a learned projection, $a$ is a small attention scorer, and $\phi$ encodes message age. The vector $m_i$ is mapped to $k$ soft prefix vectors for the local controller. Each $h_j$ is a pooled projection of neighbor $j$'s hidden state from its most recent background pass. That pass runs on its own schedule, so stale or missing messages are the normal case and not an exception.

The claim is falsifiable in three parts. Under ideal communication, the latent system should match CoLLMLight's travel time while using far fewer generated tokens per decision. Under injected delay and message loss, its travel time should degrade less than CoLLMLight's. In zero-shot transfer from the synthetic grid to real cities, it should beat a classical vector graph policy trained under the same conditions.

Research Program

We start from a specialized LightGPT-style controller trained with the LLMLight pipeline. We reproduce CoLLMLight's background cooperative reasoner on the synthetic 4×4 CityFlow grid and log its text directives together with the hidden states of the corresponding local controllers. We add three small parts: a message head that pools hidden states into $h_j$, the age-aware attention aggregator above, and a prefix adapter.

Stage one is distillation. With the backbone frozen, the new modules learn to make the real-time controller's action distribution match the distribution it produces when it reads CoLLMLight's text directive. Matching on the controller's own visited states follows the DAgger recipe. Stage two applies PPO refinement on travel time, as in CoLLMLight, with the backbone unfrozen through low-rank adapters. During this stage message delays are drawn from a heavy-tailed distribution, a fraction of edges is dropped each tick, and the update rate varies across nodes.

We will analyze what the messages encode. We probe whether $h_j$ linearly predicts the neighbor's queue lengths and expected spillback, and we check whether attention weights fall toward zero as message age grows. We also preserve interpretability: the local controller still explains its decision in words, and we can decode $m_i$ into text through the frozen model to audit what was communicated.

Baselines

The naive reference point is isolated LLMLight controllers with no communication at all. This measures how much cooperation is worth on each network. If our method barely beats it, the coordination question is moot there.

The strongest existing method is CoLLMLight, run with its released or reproduced pipeline on the same synthetic training grid and the same backbone size. It gets the same PPO budget and the same delay and drop conditions applied to its cached text. Its paper reports that it "achieved the best performance across all metrics" on the 1,176-intersection network but gives no absolute value. Accordingly, no reported result found on Lacuna for CoLLMLight's absolute average travel time, and we will rerun it. Beating it means equal or lower average travel time under ideal communication with at least several-fold fewer generated tokens and lower decision latency, and significantly lower travel time under 30% or more message loss.

The strongest classical competitor is CoLight, which reported an 11.69% improvement in average travel time over the next-best method on the 196-intersection Manhattan network (CoLight). We train it on the same synthetic grid and evaluate it zero-shot on Jinan, Hangzhou, Manhattan, and the 1,176-intersection network. We give it the same delay and drop augmentation and its own tuning budget, so that robustness training is not something only our method receives. Beating it means lower zero-shot travel time on the real networks and under 4× demand surges.

The cheap prompt baseline writes neighbors' raw queue counts directly into the local prompt as a short number string, with no reasoning step. A latent ablation sequence then isolates the key ingredients. Mean pooling replaces attention; the age encoding is removed; delay augmentation is removed; message dimension is swept from 16 to 1,024. A variant passes full key-value caches in the style of LatentMAS on a small grid to bound the upside of richer messages.

Why not just…?

Why not just use CoLight with delay augmentation? This is the most serious threat. A vector policy is faster, cheaper, and could absorb staleness if trained for it. The case against it rests on LLMLight's and CoLLMLight's evidence that language-grounded controllers transfer better across cities and extreme traffic. That evidence is reported mostly qualitatively in the file. We therefore treat it as an open question and test it with equal-budget, robustness-trained CoLight in zero-shot transfer. If CoLight matches us there, the honest conclusion is that language models are not needed for this kind of coordination, and we will report it that way.

Why not just keep CoLLMLight's text cache and add timestamps? Text with timestamps does address staleness. It still requires generating and reading tokens on every edge, and it cannot be blended smoothly across neighbors in a way that is independent of their order. The token-cost and latency measurements under identical delay schedules, including a timestamped-text variant, settle whether latent messages buy anything beyond freshness labels.

Why not just paste neighbors' queue counts into the prompt? If raw one-hop numbers are enough, the learned messages are unnecessary. The expected advantage of latent messages is that they carry the neighbor's own forecast, such as anticipated spillback, which the neighbor's numbers do not contain, and that this forecast propagates over multiple hops through repeated background passes. If the numeric-prompt baseline ties our method at moderate demand but loses under surges and on large networks, that supports the claim. A tie everywhere would refute it.

Why not just pass full hidden states or caches as LatentMAS does? The bandwidth grows with sequence length and model width across every road link, every few seconds. Without aggregation over the graph, it also has no way to combine many neighbors. The message-dimension sweep and the small-grid cache-transfer variant show how much accuracy compression costs.

Proposed Experiments

All experiments run in CityFlow. Training uses the synthetic 4×4 grid, following CoLLMLight's protocol. Evaluation runs zero-shot on Jinan, Hangzhou, the 196-intersection Manhattan network, and the 1,176-intersection network, at normal and 4× demand. Metrics are average travel time, queue length, and throughput, plus decision latency, generated tokens per decision, and bytes per message. Communication stress grids cross message-loss rates from 0% to 50% with median delays from zero to several decision intervals, and include scheduled link outages.

The decisive checks are three. First, the latent system must sit within noise of CoLLMLight on travel time under ideal communication, at substantially lower token cost. Second, as message loss rises, the latent system must show a flatter curve of travel time against loss than CoLLMLight. Third, in zero-shot transfer to the real networks, it must beat delay-augmented CoLight. The ablations should show that removing the age encoding hurts mainly under high delay, and that mean pooling hurts mainly at irregular, high-degree junctions. Results reported over five seeds with confidence intervals will tell us whether vector messages between specialized language controllers are a real improvement or an unnecessary detour.