PUBG Ally Shows Why AI Teammates Need Two Brains: Fast Reflexes and Slow Reasoning

A language model can talk about a firefight, but it should not be responsible for every movement, aim adjustment and split-second reaction inside one. NVIDIA ACE and KRAFTON's PUBG Ally show why useful AI teammates need more than a single model: fast gameplay control and slower language reasoning are different jobs.

Why one AI model should not run the whole character

A modern game character has to solve several problems at radically different timescales.

It may need to avoid an obstacle in milliseconds, react to nearby gunfire, follow a player command, decide whether to loot, explain a plan in natural language and remember what the player asked earlier.

Trying to force all of that through one language-model loop creates a timing mismatch. The model is good at semantic reasoning and planning, but real-time control often needs deterministic logic that can react every game tick.

PUBG Ally uses a two-speed architecture

KRAFTON describes PUBG Ally as a co-playable AI teammate powered by NVIDIA ACE. The system combines player voice, live match state, a small language model and game-side control logic.

According to NVIDIA's technical deep dive, the architecture separates a System 1 behavior tree from a System 2 language model. The behavior tree handles fast reactive gameplay such as movement and combat, while the language model handles deliberate reasoning, communication and coordination.

That split is one of the most important design patterns in real-time game AI because it gives each subsystem authority over the work it is actually suited to perform.

The Two-Speed Game Agent model

Live game state is what makes the model useful

The PUBG Ally model does not reason from dialogue alone. NVIDIA says the game engine exposes live match state to the agent through observation tools represented as textual descriptions.

That matters because a teammate needs to know what is happening now: what the player said, what items exist nearby, where danger is coming from and whether the previous plan is still valid.

This is the same reliability principle that applies to any game assistant: general game knowledge is not enough when the correct action depends on current session state.

The Action Authority Boundary

A useful real-time game agent needs a clear boundary between what the model may decide and what the game engine may actually execute.

The model can choose a goal such as “move to cover,” “loot ammunition,” “follow the player” or “engage that enemy.” The game-side controller should then translate that intent into legal, bounded actions that obey navigation, animation, cooldowns, physics and game rules.

Why event-driven reasoning beats constant language-model polling

PUBG Ally's model loop is described as event-driven. It can be triggered by the player speaking or by relevant in-game events.

That is more efficient than asking the model to rethink the entire world on every frame. Most frames do not require a strategic decision.

A good trigger system calls the language model when semantics matter: a new order arrives, a threat changes the plan, an objective is completed, an item becomes relevant or the current plan fails.

The Decision Trigger Filter

On-device inference changes the design space

NVIDIA ACE is designed around on-device inference as well as cloud options. For PUBG Ally, NVIDIA says the small language model runs locally on the player's GPU.

The published architecture uses a 2B-parameter Mistral-NeMo-Minitron model designed to fit into the VRAM headroom remaining after PUBG itself is running.

That is a non-trivial constraint. Game AI cannot simply consume all available GPU memory or compute because the graphics workload still has priority.

AI inference now competes with rendering

This creates a new resource problem for games: graphics and AI inference may share the same GPU.

NVIDIA's In-Game Inferencing SDK is designed to schedule local AI models alongside graphics workloads. Its purpose is not only to run models, but to do so without destroying the game's frame-time budget.

That means future performance reviews may need to measure not only DLSS, ray tracing and VRAM use, but also the cost of local NPC inference.

The Game AI Resource Budget

Why small models make sense inside games

A game agent does not need to know everything on the internet. It needs to understand the game's vocabulary, current state, action tools and a limited set of relevant knowledge.

That is why NVIDIA ACE emphasizes small models optimized for gaming hardware. KRAFTON also describes domain adaptation for PUBG Ally: the model was constrained to the Sanhok map and AI Duo context and trained around PUBG-specific concepts and tool use.

A smaller specialized model can be more useful than a much larger general model if its world, tools and action boundaries are well defined.

RAG and tools solve different problems

NVIDIA's ACE Game Agent SDK exposes Agent, Chat and RAG APIs. Those are separate capabilities because knowledge retrieval and action execution are not the same thing.

RAG can provide grounded game knowledge such as item rules, faction data or mechanics. Tools expose what the agent can observe or do in the live game.

An agent can retrieve the correct fact and still fail if it has the wrong live state or invokes the wrong action. Knowledge, state and action authority all need separate validation.

What traditional NPCs still do better

Language-model agents are not automatically better at every NPC task.

Scripted logic is cheaper, easier to test and more predictable when the desired behavior is already known. A door guard who has three fixed states does not need an agentic reasoning loop.

The strongest use cases are situations where natural language, broad planning, contextual adaptation or player-specific coordination create value that static logic struggles to provide.

The Agent Reliability Loop

Why natural speech makes errors more convincing

ACE can combine automatic speech recognition, language reasoning and text-to-speech so a teammate can hear, act and speak naturally.

That improves immersion, but it also increases the need for grounding. A confident spoken sentence such as “I picked up the med kit” sounds authoritative even if the item interaction failed.

Speech should therefore report confirmed state wherever possible, not merely the model's intended action.

Multilingual game agents are becoming practical

NVIDIA expanded ACE in 2026 with multilingual on-device models for language, speech recognition and speech synthesis.

NVIDIA's May 2026 developer update describes Qwen 3.5 4B support across 201 languages and dialects, Riva Parakeet TDT 600M speech recognition for 25 languages and Chatterbox Multilingual 500M voices across 24 languages.

That broadens the design space for AI companions beyond English-only demos and makes local language interaction a realistic product feature.

What would change this answer?

The architecture could become more unified if future models achieve deterministic sub-frame action latency while remaining small enough to run continuously beside graphics workloads. Today, separating reflex control from semantic reasoning remains the more practical design.

Specialized neural control policies may also replace some traditional behavior-tree functions, but the need for explicit action authority, state validation and fast execution will remain.

Limitations

PUBG Ally is one implementation, not proof that every game should adopt the same architecture. Different genres have different latency, determinism, hardware and gameplay requirements.

The public architecture details are also primarily provided by NVIDIA and KRAFTON. They are useful for understanding the implemented system but should not be treated as independent performance benchmarking.

Conclusion

The future of game agents is unlikely to be one giant model replacing the game AI stack.

PUBG Ally points toward a hybrid architecture instead: language models interpret intent and make high-level decisions; deterministic controllers execute fast gameplay; live state keeps the model grounded; and the game engine retains authority over what can actually happen.

The winning design is not the agent that thinks about everything. It is the agent that knows what it should think about—and what should stay in the game loop.

FAQ

Glossary

Primary sources