AgileThinker Tackles Real-Time Reasoning by Running Reactive and Planning Minds at Once

AgileThinker Tackles Real-Time Reasoning by Running Reactive and Planning Minds at Once

Most AI agent benchmarks grant their subjects a quiet superpower: the world holds still while the model thinks. The browser page does not change, the simulated robot does not drift, the game board waits patiently for the next move. That is convenient for scoring and faintly absurd for deployment. A new paper from researchers at Tsinghua University, Shanghai Jiao Tong University, Georgia Tech, and Stanford takes that privilege away — and argues that doing so exposes a failure mode hiding underneath nearly every "real-time" agent shipped today.

The work, titled "Real-Time Reasoning Agents in Evolving Environments" (arXiv:2511.04898), introduces a problem formulation the authors call real-time reasoning, a benchmark called the Real-Time Reasoning Gym, and an agent architecture named AgileThinker that, by their measurements, is the only approach that does not collapse as time pressure climbs. The authors are Yule Wen, Yixin Ye, Yanzhe Zhang, Diyi Yang, and Hao Zhu, with Wen and Ye listed as co-leading authors.

What "real-time reasoning under time pressure" actually means

The core idea is to make time part of the environment rather than a courtesy extended to the agent. In the Real-Time Reasoning Gym, the environment advances at a fixed rate whether or not the agent has finished reasoning. If the agent has not produced an action in time, a default action is applied for it. That single change converts inference latency from an engineering nuisance into part of the task itself. As the authors put it, "Agents in the real world must make not only logical but also timely judgments... hazards emerge, opportunities arise, and other agents act, while the agent's reasoning is still unfolding."

The Gym uses three real-time games, each isolating a different kind of pressure. Freeway tests hazard avoidance — crossing lanes of moving cars. Snake tests opportunity capture — grabbing transient food without trapping yourself. Overcooked tests coordination — cooperating with an independently acting teammate. The researchers turn two dials independently: cognitive load (longer paths, more obstacles, larger kitchens) and time pressure, measured as the number of output tokens an agent may generate before the world advances. Using token count as a hardware-agnostic stand-in for elapsed inference time is a deliberate choice; it lets the benchmark compare reasoning styles without entangling the result in GPU speed or API throughput.

Against that clock, the paper studies two familiar deployment paradigms and finds both wanting. Reactive agents use bounded computation for fast responses; they stay inside the update cycle but reason shallowly. Planning agents reason deeply across multiple steps but act on stale observations — solving, as one analysis put it, yesterday's problem beautifully. The paper's blunt conclusion is that even state-of-the-art models "struggle with making logical and timely judgments in either paradigm."

Two minds, running at the same time

AgileThinker's answer is to refuse the choice. It runs two LLM threads concurrently, borrowing the well-worn dual-process metaphor: a planning thread acts like deliberate "System 2" reasoning over a frozen snapshot of the game state, while a reactive thread acts like fast "System 1," producing a timely action within the environment's update window.

The mechanism worth dwelling on is not "fast model plus slow model." It is that the reactive thread can reference the planning thread's partial, still-streaming reasoning trace before that reasoning is complete. The fast component does not wait for the grand plan; it treats unfinished thought as strategic guidance, then reconciles it against the latest observation. In a world that keeps moving, incomplete-but-timely guidance can beat complete-but-late analysis. The prompts even frame the planning output explicitly as guidance that may no longer perfectly match the current situation — the system does not pretend old reasoning is automatically current.

The numbers track the architecture. In the cognitive-load experiments, with time pressure fixed at 8,000 tokens per step, a reactive agent built on DeepSeek-V3 degraded from an average score of 0.89 down to 0.15 as tasks grew harder; AgileThinker fell only from 0.88 to 0.50. Under the opposite stress test — cognitive load fixed, time pressure tightened — planning agents cratered from 0.92 to 0.05, while AgileThinker slid gently from 0.90 to 0.58. The single-paradigm agents do not merely degrade; under enough pressure the planner effectively disappears.

The effect survives a harder test, too. In a wall-clock experiment using DeepSeek's official API under real elapsed time (rather than simulated token budgets), AgileThinker scored 0.88 on Freeway versus 0.24 reactive and 0.12 planning; 0.45 on Snake versus 0.37 and 0.04; and 0.89 on Overcooked versus 0.57 and 0.00 — that last zero meaning a planning-only agent completed essentially nothing as a teammate moved around it.

Why this matters for agentic and robotic AI

The unglamorous lesson is that "real-time AI" is not a synonym for "use a faster model." A faster monologue is still a monologue. Real deployments — autonomous vehicles, robotic manipulation, algorithmic trading, industrial control, incident response, dispatch, live customer escalation — share a property that frozen benchmarks erase: the state changes independently of the model while it thinks. An agent that reasons as though its input snapshot stays valid until completion is making a silent temporal bet, and in live operations that bet is an unpriced risk.

AgileThinker reframes the problem as resource allocation between fast action and slow reasoning rather than a model-size contest wearing a latency badge. The paper's budget-allocation analysis reinforces the point: performance peaks when the reactive thread gets roughly enough tokens to match the reactive model's natural usage — around 5,000 on Freeway, closer to 2,000 on Snake and Overcooked — and AgileThinker stays ahead of single-paradigm baselines across a broad range of those settings. Latency budgets, in other words, are design parameters, not arbitrary API limits.

There are honest boundaries. The environments are controlled games, not messy enterprise workflows with ambiguous goals and compliance constraints. And the strongest results lean on DeepSeek models precisely because AgileThinker needs access to transparent intermediate reasoning traces — many commercial providers do not expose them, which would force the architecture to approximate the trick through summaries or external scratchpads.

What to watch: whether the concurrent reactive-plus-planning pattern generalizes beyond models that stream their reasoning, and whether it migrates from the Gym's three games into the physical-world domains the authors invoke. The benchmark, dataset, and a `realtimegym` Python package are public, which lowers the bar for others to push on it. The provocation underneath the work is almost anti-academic, and it lands: sometimes the best agent is the one that knows when to stop thinking and act.