Blog
LLM game NPCsRAON-1 Nanoon-device NPC model

Can a Tiny 1.5B LLM Power Game NPCs? RAON-1 Nano Explained

Krafton built RAON-1 Nano, a 1.5B on-device model, for characters like PUBG Ally. Here is what NPCs need, what it does well, and where it falls short.

Portrait of Luis Chavez-Mattos
Edited by Luis Chavez-Mattos, Director, Product··RSS

For Engineering, Product Management and IT

A young woman in a track jacket pushes a hand truck carrying a sharp, tall stack of server blades while her body blurs into a streak.

Can a tiny local LLM like RAON-1 Nano power believable game NPCs?

Possibly, for a narrow job. RAON-1 Nano is an open 1.5 billion parameter model from Krafton, the company behind PUBG. It was built to run on a player's own machine next to the game, not in the cloud. It is not meant to know much about the world. It is meant to follow instructions, stay in character, and use the game state it is handed. That is most of what an NPC needs. It is the wrong tool for general knowledge, coding, or long independent reasoning.

TL;DR

  • RAON-1 Nano is a small, open model (1.5 billion parameters, Apache 2.0 family) from Krafton, built as a base for on-device characters.
  • NPCs need a short list of skills: follow instructions, remember what the player said, hold a tone, and read game state. Broad world knowledge is mostly wasted space.
  • Nano was made by converting a larger model. Krafton turned its 29B-parameter RAON-1 Mini into a plain 1.5B model, then trained it further.
  • The parent model's scores fit the plan. Mini ranks last of five on a general knowledge test but first on instruction following.
  • Krafton has not said PUBG Ally runs on Nano. The link is a reasonable inference, not a stated fact.
  • You can test this yourself with a small set of dialogue, JSON, and decision prompts, and the same approach works for any small local model.

Why would a games company build its own model?

Cost and fit. Krafton already ships AI characters. In one of its recent games, a life-simulation title, NPCs called Smart Zoi are driven by an on-device model. It also has PUBG Ally, an AI teammate that talks to you and follows your calls. Nvidia showed an early version at the start of 2025, and it has since shipped in the game.

Running a large language model in the cloud for every player, for every line of dialogue, gets expensive fast. Running a small model on the player's own GPU moves that cost to hardware the player already owns. The tradeoff is that the model must be small, because it shares the GPU with the game itself.

Krafton also has a broader family of open RAON models. It started with speech models, then text-to-speech, then a vision encoder, and now a language model. This is a program, not a one-off experiment.

What does a game NPC actually need from a language model?

Think about an AI teammate in a match. The list is short, and it looks different from a general chatbot's.

NPC needExampleWhy a small model can cope
Follow instructions"Stay quiet until I call it."Instruction following is a skill, not a knowledge store
Remember the session"I hate that weapon." Twenty minutes later it should not suggest it.Facts go into the context window (the text the model reads each turn)
Hold a toneA sarcastic squadmate stays sarcasticStyle is cheap to learn and cheap to prompt
Use game stateInventory, current zone, squad positionsThe game supplies it as text, so the model reads rather than recalls
Output usable actionsA structured command the game can executeFormat discipline, not world knowledge

What is missing from that table is trivia. An NPC does not need to know the capital of a country or when a historical figure died. That knowledge takes up parameters, and parameters cost memory and speed.

How was RAON-1 Nano made?

Nano did not come from a normal training run. It came from a larger model Krafton trained itself.

The parent: RAON-1 Mini. Mini was released as a preview on October 21. It is a mixture of experts model with about 29 billion parameters in total, but only about 4.3 billion are active for any one token. It has 128 experts, routes each token through six of them, and adds one shared expert. Krafton trained it from scratch. It is not a fine-tune of Qwen or anyone else's model. It is released under Apache 2.0, which is a permissive open license. It was briefly gated under a different license and then opened up the next day after feedback.

The conversion. Distilling a big model into a small one is common. Converting a mixture of experts model into a plain "dense" model is less common. Krafton's paper (an oral presentation at NeurIPS, a top AI research conference) describes the recipe:

  1. Score every expert to see which ones matter.
  2. Select experts and group them.
  3. Merge each group into one ordinary dense layer.
  4. Distill from the original so the new model learns to match its parent.

The team tried 350 configurations. What mattered most was how the experts were scored. Their "diversity aware" scoring, which tries to keep experts that do different jobs, beat pruning a dense model to the same size by 6.3 points on average, and trained 1.6 times faster.

The extra work. The paper's best conversions still fell short of a comparable existing small model. So Nano then got another 3 trillion tokens of training, supervised fine-tuning, on-policy distillation from Mini, and reinforcement learning. No outside base model sits anywhere in the family tree.

The drop from 29B to 1.5B looks like a 20x squeeze. But since only about 4.3B parameters fire per token in Mini, the compute gap is smaller than it appears.

What do the benchmark numbers say about NPC fit?

The numbers below are for the parent, Mini, not for Nano.

  • On MMLU Pro, a broad general-knowledge test, Mini scored 76.5. It came last of the five models in Krafton's table. The top score listed was 85.9 for a Qwen model.
  • On an instruction-following benchmark, Mini came first.
  • On the Artificial Analysis Omniscience benchmark, which penalizes wrong answers and rewards saying "I don't know", Mini came first.
  • On Terminal Bench, an agentic coding test, it did poorly. It was not built to be a coding agent.

Read together, that is a model that is weaker at stored facts, better at doing what it is told, and more honest about what it does not know. That matches an NPC with game knowledge supplied in context. One caveat: this is an interpretation of the numbers. Krafton has not framed it this way, and no one should present it as the company's claim.

The conversion method may also help explain the profile. Much of a model's factual knowledge is thought to sit in its feed-forward layers, which is where the experts live. Most experts get discarded in the conversion, while the attention layers carry over. That could shed facts more easily than reasoning ability. Krafton does not claim this, and the paper does not test it, so treat it as a plausible idea only.

It also echoes Andrej Karpathy's "cognitive core" idea: a model of around a billion parameters that reasons well and looks up facts when it needs them, rather than memorizing everything.

Where does a tiny NPC model fall short?

Be realistic about the edges.

  • World knowledge is thin by design. If a player asks an NPC about real-world history, expect weak or evasive answers. For many games, that is fine, even desirable.
  • Long, complicated planning is risky. A 1.5B model can pick the next move in a life sim. It is far less likely to run a multi-step scheme coherently.
  • Memory is only as good as your context. The model does not remember a session on its own. The game has to feed it the right summary each turn, and context length is limited.
  • Hardware is shared. Every bit of GPU the model uses is taken from the game's graphics.
  • Official claims are limited. Krafton called Nano a better base model for its edge AI applications. It did not say PUBG Ally runs on it.

How can you test a small model for NPC work?

A comparison of Nano against Mini covers three kinds of task: NPC dialogue, JSON action output, and next-action decisions in a life-sim setting. This article does not report scores from that comparison, so run the checks yourself on any small local model. Keep each test short and score it by hand.

Use a prompt shaped like this and vary the character, state, and player message:

You are Mara, a gruff but loyal squadmate. Stay in character.
Never mention being an AI.

Game state:
- Zone: north village, circle closing in 90 seconds
- Inventory: 2 bandages, 1 smoke grenade, no ammo for rifle
- Squad: Jin is 40 meters east, hurt

Player said earlier: "I hate shotguns. Don't suggest them."
Player now says: "What should we do?"

Reply in one or two sentences, then output JSON only on a new line:
{"action": "move|heal|throw_smoke|hold", "target": "<string>"}

Then check:

  1. Tone: does Mara stay in character across five different player messages?
  2. Memory: does she avoid suggesting a shotgun?
  3. State use: does the reply mention the real zone, inventory, or squad member?
  4. JSON validity: does the JSON parse every time, with only allowed actions? Run it 50 times and count failures.
  5. Decision sense: for a life-sim version ("hunger low, work in 2 hours, friend is calling"), is the chosen action reasonable?

If JSON fails more than a few times in 50, you need a stricter prompt, constrained output, or a retry step in the game code.

What does this mean for you?

If you work in games or interactive products: the lesson is the NPC list above. Decide which of those skills you need, supply knowledge through context, and measure latency and memory on real player hardware before you pick a model.

If you build internal tools or customer-facing assistants: the same constraints apply to a kiosk bot, a laptop-only assistant, or a help widget. Tight latency, limited memory, long sessions, and key facts that must fit in context. A small model that follows instructions and says "I don't know" may serve you better than a large one that sounds confident.

If you are just watching AI: expect more companies to train their own small models for specific jobs, rather than renting a general one. The interesting question is no longer only "how big," but "how little does this job need to know."

Could you build your own model-testing tool instead of using spreadsheets?

If you run comparisons like the one above, the pain is usually bookkeeping: prompts in one file, outputs in another, scores in a spreadsheet. With Remy, you can describe a small internal app in plain English, such as a test-case tracker where you store each prompt, run it against several models from Remy's catalog, record whether the JSON parsed, and rate tone and memory on a simple scale. Remy builds the app with a database and sign-in, and deploys it to a live URL, so a team can share one scorecard instead of passing files around.

Frequently Asked Questions

5 questions

What is RAON-1 Nano?

It is a 1.5 billion parameter open language model from Krafton, the company behind PUBG. It was converted from its larger RAON-1 Mini model and then trained further. Krafton positions it as a base model for on-device (edge) AI applications.

Does PUBG Ally run on RAON-1 Nano?

Krafton has not said so. PUBG Ally is an AI teammate that talks to you and follows your calls, and its needs match what Nano is built for. But that connection is an inference, not a confirmed fact.

Why is a small model good for NPCs?

NPCs mostly need instruction following, tone, memory within a session, and the ability to read game state. They rarely need real-world trivia. A small model can handle those jobs, runs locally, and avoids per-line cloud costs.

Can RAON-1 Nano write code or act as a general assistant?

That is not what it is designed for. Its parent, Mini, scored poorly on an agentic coding benchmark and last of five on a broad knowledge test. For general questions or coding, a larger model is the better choice.

How do I know if a small model is good enough for my use case?

Write a realistic prompt with character, game or business state, and a required output format. Run it many times and score tone, memory, state use, and whether the structured output parses. Measure speed on the actual hardware too.

How we source, write, and correct our articles. Editorial standards

Related articles

Straight to your inbox.
New pieces as they publish. No noise.