Habr AI Demonstrates How Reflex Architecture for LLM-Agents Eliminates Lag Down to 60 FPS

Habr AI published a breakdown of an architecture that adds LLM-agents a "spinal cord" — a fast reflex layer on top of slow reasoning. The idea is to eliminate the familiar 1–3 second pause and make game NPCs, voice assistants, and robots respond almost instantly.

Where speed breaks down

The problem is familiar to anyone who has tried to embed a large language model into an interactive environment. While the agent receives audio, gathers context, sends a request, waits for the model's response, and converts it into animation or action, too much time passes. For chat, such a delay is tolerable, but for a game, robot, or live interface, it's already a UX failure: the user sees not intelligence, but a freeze.

That's why even a powerful model often feels "smart, but slow." The authors compare such integration to trying to put a shuttle engine on a cart: computational power exists, but translating it into real behavior doesn't work. In their prototype, public attention shifted to the visual shell, not the engine itself.

Instead of discussing inference, the team heard complaints about raw debug output and frame quality. That is, the debate was about the picture, when the real news was that the system was already trying to maintain real-time rhythm.

"It's too early to demonstrate 'honest 60 FPS'.

You've just got a kaleidoscope of chaotic frames, blur and crooked fingers."

System 1 and System 2

The solution became Dual-Process Architecture — splitting the agent into fast and slow loops. The first layer works like a reflex system: monitors events, triggers instant reactions without waiting for the model's full reasoning. The second layer stays with the LLM and handles more expensive tasks: interpreting complex context, planning, choosing responses, reshaping behavior. This way, the agent can react first and then "think," as humans do in the real world.

In this approach, it's critical not to force the LLM to be the only execution center. Slow reasoning is good where depth is needed, but ill-suited for movements, micro-gestures, fast camera turns, collision response, or short voice responses. Two-speed architecture resolves this conflict: the interface and body of the agent live in milliseconds, while meaning and strategy operate in a longer cycle.

This decoupling allows you not to drop frames and not to make the user wait for each next gesture or response. According to the authors' description, this scheme also provides two bonuses that are hard to get in a monolithic pipeline: personality can be changed on the fly, and new behavior patterns can be adopted right during operation. This is especially important for NPCs, assistants, and robotics, where the agent must not just respond but continuously adapt to the environment.

In a standard scheme, such changes require a new request to the model and again hit the delay wall.

Practical effect of the approach

If you extract reflexes from the heavy LLM loop, it changes not only the delay but also the feeling of "aliveness" of the system. The user stops waiting for intelligence to complete a full pass through the chain and starts seeing continuous behavior. For product teams, this is an important shift: agent quality is now evaluated not by the beauty of a demo frame but by how naturally it maintains the rhythm of interaction. In an interactive product, this is often more important than perfect text, because the sense of presence breaks down before the user even has time to assess the depth of the response.

• Instant reactions to events, sound, obstacles and commands
• Smooth connection between generation, animation and control
• Quick switching of role, character or response style
• Learning and behavior correction without full agent restart

Essentially, the team proposes viewing the LLM not as the only brain of the system, but as one of its layers. This changes the engineering perspective: instead of an endless battle with network delay and heavy inference, the opportunity emerges to design a separate engine for real-time performance. Yes, the prototype's visualization may be raw. But if the reflex layer is already maintaining the pace, polishing graphics, hands, and frames can be done in the next iteration.

What this means

The story illustrates well where AI-agents are headed: toward hybrid systems where fast reflexes are separated from slow reasoning. For those making games, voice assistants, and embodied AI, this is almost a mandatory step — without it, even the best LLM will seem slow and clumsy.