Language Models Are Changing the Gameplay Interface

Disclosure: These views are my own and do not represent any current or former employer. This paper uses public research, public software documentation and public model metadata. It does not describe non-public game systems or product plans. The source review is evidence-led but is not a systematic review.

Demonstration status: This draft defines two reproducible demonstration protocols. Their implementation and measured results are not yet included. No result is claimed for either demonstration.

Executive summary

Gameplay-time language models have moved beyond laboratory demonstrations. Commercial releases now use them for persuasion, interrogation, narration, intent interpretation and companion interaction. A live service provides generated game-mastering. A paid Early Access simulation includes an experimental on-device character system. PUBG ran a limited public beta with an on-device language-model teammate, and Fortnite creators can publish islands containing LLM-powered conversational characters.[25][26][27][28][29][30][31][32]

These examples do not show that generative characters are routine across the game industry. Most current deployments are indie releases, live services, experimental features, creator tools or limited tests. Their value is more specific: they show which roles already work with real players and within real hardware limits. They also show where service dependencies require a fallback.

Current systems can interpret varied language, generate dialogue from supplied context, select from declared tools or actions, summarise events and maintain bounded conversational memory. Local inference is practical for narrow tasks on qualifying hardware. Cloud inference supports larger models and broader device access, while introducing regional capacity, cold starts, provider changes, outages and continuing service cost. Neither route removes the need for an authoritative game state.

The research evidence is consistent with this mixed commercial picture. Studies report greater input flexibility, naturalness and engagement for some players, alongside latency, frustration and unpredictable side effects.[2][3][4] Structured state improves grounded dialogue,[8] authored goals can accept varied phrasing,[9] and bounded model recommendations can improve perceived responsiveness without establishing superior objective play.[17] A controlled game benchmark shows that strategic autonomy remains unreliable across complex environments.[15] A preprint text-game study attributes model advantage to persuasion rather than consistently stronger play,[14] while a spoken-dialogue role-play preprint reports early persona and safety drift.[16]

The effect on game design is already visible among teams shipping or prototyping these systems. Writers and narrative designers are defining character histories, motivations, knowledge boundaries, goals and prohibited behaviour that a model can improvise within. Systems designers are exposing selected state, finite action contracts and validation rules. Teams are also designing memory policy, moderation, timeouts, fallback behaviour and response evaluation. Retail Mage's developers describe new problems including blank-page syndrome, information overload and characters that solve too much without leaving enough work for the player.[28] Ubisoft describes writers shaping characters and narrative arcs while technical teams build guardrails around their improvisation.[33]

This changes the unit of authorship. A fixed dialogue tree mainly requires written lines and branching conditions. A generative interaction requires a controlled system around the lines: persona, facts, state projection, disclosure policy, goals, tools, memory, validation, presentation and recovery. The useful design principle is to separate linguistic freedom from mechanical authority. A player may be able to say almost anything, while only a validated subset of interpretations can alter the game.

The likely near-term direction follows this architecture. Small local models are well suited to event-level work such as intent classification, action selection, summarisation, memory extraction and short responses. Hybrid local-cloud routing can reserve remote inference for less frequent or more complex turns. Speech pipelines, structured output and engine middleware are likely to make these systems easier to reuse. Memory systems are likely to become richer, but durable facts and relationships will still need external ownership, provenance and conflict handling.

More ambitious outcomes remain speculative. Current evidence does not support whole open worlds in which most characters reason continuously, remember hundreds of hours reliably and coordinate without authored control. It does not support a language model as the canonical quest or simulation authority, or independent client-side agents that remain synchronised and fair in competitive multiplayer. Larger models may bring some of these outcomes closer, but they do not remove the need for state ownership, replay, safety, localisation or validation.

The paper therefore argues:

Gameplay-time language models are becoming a practical interface between player intent and authoritative game systems. Their near-term influence will come from bounded interpretation, conversation and advice, while game design expands to include state projection, knowledge policy, constrained actions, memory, validation, fallback and evaluation.

Two proposed demonstrations support this argument without defining its full scope. A state-grounded interrogation tests whether a local model can recognise valid phrasings that a deterministic baseline misses while code retains truth and progression. A bounded real-time director tests whether the same contract survives asynchronous deadlines. They are measurement protocols for current feasibility, not forecasts of complete future games.

1. What is practical now

1.1 Scope and status

This paper concerns semantic generation or interpretation while play is under way. It excludes development-only code generation, pre-generated assets, voice synthesis without language generation and classical intent matching that only selects a fixed response.

Status also matters. A shipped game, paid Early Access feature, public demo, limited beta, publicly shown prototype and middleware SDK provide different evidence. The following examples were checked against first-party pages or storefront records on 18 September 2026:

The table establishes availability and intended use. It does not establish equivalent quality, commercial success or permanent service availability. A game that depends on a remote model, account service or provider API therefore has a preservation problem as well as an inference problem.

1.2 What current evidence supports

The current landscape supports a bounded capability inventory rather than a claim of general game intelligence:

1.3 The opportunity is a wider gameplay interface

Most game systems accept inputs from a known vocabulary. A controller button maps to an action, a dialogue choice maps to a branch, and an interaction prompt appears only when the required state permits it.

This design gives the engine an exact contract:

input
validate
apply transition
render result

The contract supports testing, replay and balance because the engine can enumerate reachable states and reject invalid actions before they alter the simulation. Player expression has to fit that interface. A role-playing game may allow the player to threaten, persuade or bribe an NPC, but each approach usually exists because someone authored the option. A parser accepts more varied text, although its vocabulary and grammar still define the available verbs and objects.

Language models are useful at this boundary because they can map several phrasings to one intent, resolve references from recent context and express an authoritative fact in language suited to a character. They can also summarise telemetry that would be cumbersome to encode as a large rule table. None of these capabilities provides a stable transition function. A confident response can contradict hidden state, and a long conversation can move away from an earlier persona or rule.

The design question is where this probabilistic interface adds flexibility without becoming the source of truth.

1.4 Gameplay-time use is separate from game development

Language models are already used to draft code, dialogue, quests, documentation and visual concepts during development. Those uses may affect production cost or iteration speed, but they are outside this paper.

The subject here is runtime behaviour experienced by a player:

• interpreting an action stated in natural language;
• selecting which authored fact or dialogue act is relevant;
• expressing an NPC response using current game context;
• tracking whether an abstract interaction goal has been met;
• recommending a bounded adaptation from recent player behaviour;
• generating a hint from solver-verified information.

Each use occurs after the game has been built and while its systems are operating. Gallotta and colleagues' survey describes language models acting as players, NPCs, player assistants, commentators, analysts, game masters, game mechanics and development assistants.[1] The breadth of that work is one reason this paper uses a narrower systems question.

1.5 Fluency is useful without being authoritative

The value of a language model is often described through the quality of its prose. Gameplay systems can use it without showing the raw output to a player. A model can classify intent, select a fact, rank an authored response or recommend a director action. Structured output makes the proposal machine-readable, while the engine retains the exact transition logic. This arrangement uses the model where language generalisation helps and code where the result must be exact.

2. Dialogue adds value when the game keeps structure

Dynamic NPC dialogue is the most visible gameplay use of language models. The research supports a real player-experience opportunity, but the benefits depend on interaction design and player type.

2.1 Free-form input changes the interaction

Natural-language input gives players more ways to state the same valid intention. In a virtual-reality murder mystery, Christiansen and colleagues found similar social presence with speech and dialogue options. Speech increased immersion, but some participants found it overwhelming, and slow NPC responses caused frustration.[2] The dialogue-option version was also described as more challenging. Opening the input channel altered difficulty as well as presentation.

The flexibility appears valuable to some audiences. Hochreiter, Kriglstein and Wallner surveyed 62 participants who played a bespoke game with generative NPC dialogue. Participants valued input flexibility and natural conversation, while reporting undesired side effects that may be difficult to anticipate or control.[3] A separate pilot study with 64 participants found longer interactions and higher engagement in a fully open-ended condition, with the strongest benefits among casual players.[4]

Emotional responsiveness may add another layer. Marincioni and colleagues reported an association between NPC emotional state and players' self-reported emotional states in an interactive mystery.[5] The available evidence supports further investigation of the mechanism without establishing a retention or commercial outcome.

The results place latency and audience fit inside the design problem. Unpredictable responses add a separate operational risk.

2.2 Free language can remain inside authored goals

Player freedom does not require unrestricted narrative progression. Wevelsiep and colleagues allowed players to paraphrase predefined dialogue options through speech, then used a language model to map the transcription back to an existing option.[6] Their workshop evaluation involved 14 participants, so it establishes feasibility rather than a robust effect.

Goal-Oriented Interactions in Games formalises a broader version of this pattern.[9] A designer defines abstract milestones instead of every accepted sentence. The model examines dialogue history and identifies whether an interaction has reached a transition condition. The hostage-negotiation demonstration supports varied linguistic approaches while the authored state graph still defines progress.

Persuasion, interrogation and negotiation can use this arrangement. The player chooses the phrasing and approach; the game retains the goal and decides whether the state changes.

2.3 Structured state grounds the response

Dialogue history contains only what has been said. It may omit inventory, location, health, quest flags, hidden information and permissions that the engine already knows.

FIREBALL combines Dungeons and Dragons actual-play dialogue with true game state captured through the Avrae bot.[8] The authors show that supplying structured state improves generated turns on automated metrics and human judgements of quality, building on earlier findings that state-aware models outperform models using dialogue history alone. The dataset also supports generation of executable Avrae commands, particularly after fine-tuning.

In a preliminary study with 28 players, Rao and colleagues placed two GPT-4-driven NPCs alongside a human player in a Minecraft quest.[7] Their analysis identified collaborative behaviour and the limits of language-only models without rich visual or game-state understanding.

The response context should therefore be an explicit projection of current state. This creates both grounding and an access boundary: information omitted from an NPC's projection is unavailable for normal disclosure.

3. Mediation has stronger evidence than autonomy

The most convincing gameplay research uses a language model to mediate between player freedom and an authored structure.

CALYPSO gave human Dungeon Masters language-model assistance for encounter understanding, focused brainstorming and open-domain questions during play.[11] Dungeon Masters could present high-fidelity text directly or develop lower-fidelity suggestions while retaining creative authority. The model reduced the effort needed to produce a relevant response while a person remained responsible for the session.

SENNA applies more structure to automated narrative mediation.[10] Its narrative graph tracks story structure and player progress, while six redirection strategies derived from expert game masters guide the system's response. Players preferred diegetic redirection through additional information, in-world consequences or NPC influence over simple denial. The graph gives generation a stable purpose and a reference point for deciding when redirection is needed.

OPEN-THEATRE provides related implementation prior art through director and actor roles with hierarchical memory.[18] It is an open-source toolkit rather than an externally verified gameplay result. Generative Agents provides stronger evidence for believable emergent behaviour: 25 agents used an architecture combining observation, memory, reflection and planning inside a simulated town. Its ablation found that observation, planning and reflection each contributed to believability.[12]

Believability is a valid game outcome, although it does not guarantee faithful simulation or reliable long-horizon state. The architectural lesson is that memory and generation need an external frame that defines what the character knows, what the story permits and which effects the game will accept.

4. Deduction benefits from language while truth remains deterministic

Social games show that models can deceive and persuade, but they also expose the gap between fluent discussion and dependable strategy.

Hoodwinked, an arXiv preprint using GPT-3-era and GPT-4-era models, placed agents in a text game involving a hidden killer, discussion and voting.[14] More advanced models were more effective killers, outperforming smaller models in 18 of 24 pairwise comparisons. Secondary metrics indicated that the advantage came from stronger persuasion in discussion rather than a different action space.

AvalonBench provides a complementary negative result.[13] A ChatGPT-based good-role agent achieved a 22.2 per cent win rate against rule-based evil agents, while a rule-based good agent achieved 38.2 per cent in the same setting. These figures come from a 2023 preprint and should be read as evidence about that evaluation, not as a current capability ceiling.

BALROG broadens the evidence across game environments.[15] Models achieved partial success on easier tasks and struggled with complex environments that required spatial reasoning, long planning horizons and exploration. Several performed worse when visual observations were added. An LLM-as-player demo would therefore become a capability benchmark, which is outside this paper's question.

Deduction still offers a useful gameplay role when code remains the oracle. In Guess Who, an attribute either matches the selected character or it does not. In Mastermind, each guess has an exact score. A mystery can assign every clue a source and a relationship to the event. A language model can translate a free-form question into a predicate, select a solver-derived fact to explain, or ask for clarification. The game should decide whether the predicate is true.

5. Runtime adaptation supports a bounded advisory role

Games already adapt enemy strength, resource availability, assistance and pacing from measured player behaviour. A language model may help when several weak signals are difficult to combine in a fixed rule table.

Tourchi Moghaddam, Santilli and Alipour evaluated this pattern in CubeWars through a within-subject study with 46 participants.[17] The conditions were static play, reinforcement-learning adaptation and language-model-assisted reinforcement learning. The model could recommend one action from a fixed menu, while reinforcement learning retained policy control.

Both adaptive conditions improved absolute progression relative to the static game. The language-model condition did not significantly outperform reinforcement learning alone on normalised objective throughput. Its clearer benefits were higher engagement, stronger absorption and greater awareness of adaptation. An exploratory affective difference did not survive Bonferroni correction.[17]

Perceived responsiveness is the supported result. The model did not optimise objective play in this study. A real-time director should therefore remain a low-rate adviser with a fixed action menu, leaving the simulation loop and adaptation limits under deterministic control.

6. Game design is already changing

The current change is broader than replacing authored dialogue with generated sentences. Teams shipping or prototyping these systems are designing a new layer between player expression and game state. This layer has to explain what a character is, what it knows, which actions are available, how a proposal becomes an effect and what happens when generation fails.

The evidence in this section comes from first-party developer accounts, platform documentation, middleware documentation and a publicly described prototype. It establishes active design practice among these teams rather than an industry-wide survey.

6.1 Authorship moves from lines to interaction contracts

Ubisoft's 2024 NEO NPC prototype gives writers responsibility for character backstory, hopes, motivations, dialogue style and narrative arc. Technical staff then condition and test the model against that authored identity. The characters improvise, but Ubisoft states that they have roles in a story rather than free will. Ubisoft presented NEO NPC as a prototype and announced no shipped game built on it.[33]

Fortnite UEFN gives creators a related division of work. Its Conversations feature allows publishable LLM-powered characters, while the associated tooling keeps personality prompts separate from knowledge prompts and provides bulk response testing.[32] Convai's Unreal documentation represents narrative progression through sections, objectives, decisions and triggers, then sends an explicit contract describing the actions, objects and characters available during a session.[34]

These systems change the work without removing authorship. A designer may write fewer exhaustive branches, but must define:

• the character's purpose and voice;
• current goals and transition conditions;
• facts the character may know or disclose;
• actions it can propose;
• behaviour that should trigger refusal, redirection or escalation;
• recovery when the model is late, unavailable or wrong.

The authored object becomes a space of permissible interaction rather than a single expected conversation.

6.2 Linguistic freedom remains separate from mechanical authority

The player-facing interface can be broad while the mechanical interface stays small. Convai can return speech and named actions, but game-side handlers perform the actions and report completion, failure, cancellation or abort.[34] PUBG Ally used a related separation: fast movement, aiming and combat reactions remained in conventional game logic, while an on-device model handled higher-level interpretation, speech, tool selection and tactical suggestion.[31]

This creates three different time classes:

1. reflex behaviour that must run at simulation or tick rate;
2. event-level reasoning such as selecting a tool, extracting a memory or proposing a strategy;
3. conversational output that can stream or wait behind animation and acknowledgement.

Treating every task as a language-model call produces avoidable latency and makes failure harder to isolate. The design opportunity lies in placing the model at the slow, ambiguous seams while deterministic systems retain continuous control.

6.3 Knowledge and memory become explicit design materials

A character needs more than a persona prompt. It needs a policy for what enters context, what remains hidden, what can be remembered and which source wins when memories conflict with current state.

AI Dungeon surfaces this problem through plot components, Story Cards and player editing tools intended to keep generated adventures coherent.[25] Research systems such as Generative Agents divide experience into observation, reflection and retrieval.[12] The common lesson is that a larger context window is not a complete memory design.

Game designers increasingly need to define:

• canonical facts and their owner;
• character knowledge and disclosure boundaries;
• short-term conversation context;
• relationship and preference state;
• summary, ranking and forgetting rules;
• player access, correction and deletion;
• save, migration and replay behaviour.

These choices affect narrative continuity, privacy, debugging and the ability to preserve a game after a model or service changes.

6.4 Generative interaction creates new player-experience problems

Open input removes familiar cues. Retail Mage's developers observed players searching for a single intended solution even when the system allowed broader answers. They also reported information overload, characters solving their own problems and rational NPC behaviour that reduced adventure or urgency.[28]

These are game-design failures rather than prompt defects. Players need to understand what kinds of action the system recognises, how much freedom they have and whether a response changed anything. Interfaces may need suggested actions, conversation summaries, visible goals, interruption controls and clear feedback when a proposal was rejected or reduced to a fallback.

Generative characters also compete for attention. If every NPC can speak at length, dialogue volume stops signalling importance. Pacing and silence remain design choices.

6.5 Evaluation and operations become part of content production

A fixed line can be reviewed once in context. A generative system defines a distribution of possible responses, tool calls and delays. Content review therefore expands into prompt suites, state fixtures, adversarial inputs, expected action ranges, language matrices and repeated playtests.

Epic provides bulk response testing and engagement analytics for UEFN Conversations.[32] PUBG Ally combined automated protocol checks with playtesting and limited public deployment.[31] The same discipline is needed for smaller games: record the supplied state, raw generation, parsed proposal, validation result, latency, fallback and player-visible output.

Operations also influence design. Whispers from the Star separates core game state from stateless rendering and inference services, then manages regional GPU capacity and model cold starts as product concerns.[29] Vaudeville moved its main English build to local inference, citing the advantages of offline operation and independence from a continuing remote service.[27] The choice between local and cloud execution affects hardware support, privacy, languages, preservation, concurrency and the kinds of fallback a game must provide.

7. What is likely next

The following are architectural forecasts for the next two to five years. They are based on current deployments and tools rather than assumed product schedules.

7.1 High confidence: narrow local models expand at event boundaries

KRAFTON reports a 0.5-billion-parameter on-device model for Smart Zoi action selection and reflection, and a quantised two-billion-parameter model for PUBG Ally's multi-step tool use.[31] These examples run on restricted or high-end hardware and do not establish a universal baseline. They do show that useful gameplay roles need not require a frontier-scale model. The forecast is high confidence because multiple public implementations already perform event-level work locally.

The strongest near-term local uses are likely to be:

• intent classification and clarification;
• selection from a declared action set;
• event and conversation summarisation;
• extraction of candidate memories;
• short character responses and barks;
• hints or explanations grounded in solver output.

These tasks have bounded inputs and outputs, tolerate specialised tuning and can be scheduled away from the frame loop.

7.2 High confidence: local and cloud become routing choices

Local inference offers lower network dependence, privacy and predictable availability on supported devices. Cloud inference offers larger models and access from lower-powered hardware. Vaudeville and KRAFTON's systems demonstrate local deployment,[27][30][31] while Whispers from the Star demonstrates a separate cloud inference tier.[29] KRAFTON also describes switching between cloud and local backends during development.[31] The forecast is high confidence because both deployment models and a common integration path already exist.

A likely production pattern is therefore a tiered path. Common, latency-sensitive or private interactions run locally. Less frequent and more complex work can use a remote service when policy, connectivity and cost allow it. The game still needs one contract for validation and fallback so that changing the inference location does not change authority.

7.3 High confidence: structured tools become the main integration path

Grammar-constrained JSON and schema-guided output are available in local runtimes today.[21][22] Middleware already turns model proposals into named actions handled by engine code.[34] Wider adoption is therefore more likely than a shift towards arbitrary model-generated commands.

This forecast is high confidence because the tooling already ships in local runtimes and current game middleware. The remaining work is semantic validation and authoring support.

Models will increasingly return typed intents, dialogue acts, fact identifiers, emotional annotations, action calls and state-update proposals. Constrained decoding can guarantee form. The game must still check meaning, permissions, targets, timing and current state.

7.4 Moderate confidence: speech and multimodal context become reusable

Several current games accept speech, and middleware packages speech recognition, language inference, speech output and animation into reusable pipelines.[26][27][29][31] The next improvement is likely to come from interruption handling, streamed partial responses, lower local latency and better integration with visible scene context.

The speech direction is supported by several current products. The multimodal direction is moderate confidence because reusable perception and scene-grounding patterns are less mature than speech pipelines.

Multimodal input may help a companion discuss an object, location or recent event without requiring every observation to be hand-written as prose. Authoritative state should still be supplied through explicit tools where the answer affects gameplay. A visual description is evidence for conversation, not a replacement for the engine's object identity or collision state.

7.5 Moderate confidence: adoption expands through bounded roles

Optional advisers, companions, tutorials and creator ecosystems tolerate occasional fallback better than canonical quest logic or competitive authority. They also provide clear value from language interpretation without requiring the model to control every system.

Engine tooling will increasingly expose character definitions, knowledge, action contracts, memory policy, test fixtures, traces and live configuration to writers, designers and QA staff. UEFN Conversations, Convai's narrative and action tooling, and Ubisoft's writer-led prototype already point in this direction.[32][33][34] The direction is moderate confidence because the tools exist, while broad adoption across shipped games has not yet been established.

8. What remains speculative

Several plausible demonstrations should not be presented as near-term production capability:

• open worlds where most NPCs reason continuously and remain useful across hundreds of hours;
• characters that coordinate durable relationships without authored goals, memory policy or conflict resolution;
• a language model acting as canonical quest, inventory, economy or physics state;
• independently generated multiplayer decisions that remain synchronised, replayable, cheat-resistant and fair;
• fully generated main stories that maintain authored pacing and dramatic structure without extensive design constraints;
• automatic safety and localisation parity across every supported language;
• self-evolving characters that update model weights safely from individual players.

Progress in model quality may narrow some of these gaps. Other constraints come from the game around the model. Multiplayer authority, save compatibility, content ratings, actor consent, localisation review, service preservation and debugging still require explicit product decisions.

Forecasts should therefore follow the boundaries formalised in Section 9. Lower latency makes more calls affordable, while structured output reduces parsing failures. Richer speech and perception widen the interface without making authoritative state or validation obsolete.

9. A bounded operating model for gameplay

The research and current implementations point to an operating model in which the language model occupies a narrow seam between player behaviour and an authoritative system.

9.1 Five separate responsibilities

Combining these responsibilities makes failures difficult to diagnose. If a model both interprets a player's sentence and changes the quest state, an incorrect transition can be mistaken for a dialogue-quality issue. The same problem appears when one probabilistic component both selects and verifies its own output.

Moderation also needs a declared deadline and fallback. It may use probabilistic classifiers, but a timeout or uncertain result cannot silently become permission to show or execute the content.

9.2 The state boundary

The game should construct the model context from an explicit projection with a versioned schema, relevant current values, stable identifiers and a clear turn or time boundary. Recording the projection digest with the call makes the input recoverable without placing the complete save state in every receipt. Inventory, health and quest state should come from the engine rather than an inference over dialogue.

9.3 The authority boundary

The model returns a proposal such as:

{
  "action": "ask_about_location",
  "fact_ids": ["fact_witness_arrival"],
  "proposed_transition": "witness_cooperative",
  "confidence": 0.78,
  "fallback": null
}

The schema makes the proposal inspectable without making it correct. A deterministic validator confirms that the action exists, the facts are visible to the role and the transition is permitted from the current state.

9.4 The timing boundary

Every gameplay use needs a deadline. Dialogue may tolerate seconds if animation or authored acknowledgement masks the wait, while intent parsing for a direct action may need an immediate fallback. A director can have a longer budget because it runs outside the frame loop. Receipts should separate queue, context-processing, generation and validation time, then record total time, deadline status and fallback. A rare long stall can be more visible than a modest change in the median, so percentiles and deadline misses matter more than an average alone.

9.5 The evidence boundary

A game using live generation needs receipts that connect the model identifier, runtime, prompt, schema and state projection to the raw output, parsed proposal, validator decision and applied transition. Latency, token counts, random seeds and replay identifiers complete the record. This evidence makes it possible to separate a model failure from stale state, an invalid schema, a validator defect or a late response.

10. Demonstration one: state-grounded interrogation

The first proposed demonstration is a supporting test of present capability. It uses a small mystery combining dynamic NPC dialogue, player-intent interpretation and active deduction.

10.1 Scenario

The player investigates a contained incident. Several characters hold overlapping facts, and one may withhold or distort a fact under declared rules. The engine owns:

• the event that occurred;
• each character's knowledge;
• which facts are public, private or gated;
• relationship and cooperation state;
• clue dependencies;
• the valid final conclusion.

The scenario facts are randomly generated at the start of each run. Names, locations, objects and secret tokens are nonces, so no answer can be recovered from a known story.

10.2 Model contract

The model receives:

• the player's latest utterance;
• a short dialogue window;
• the NPC's current stance;
• permitted dialogue acts;
• identifiers and descriptions for facts currently available to that NPC;
• legal proposed milestones;
• a clarify outcome.

It returns a constrained object:

{
  "player_intent": "ask_about_timeline",
  "dialogue_act": "answer",
  "fact_ids": ["fact_arrival_time"],
  "proposed_milestone": null,
  "needs_clarification": false,
  "response": "I arrived shortly after the workshop bell."
}

The engine checks every identifier and applies any milestone. Gated facts are omitted until their disclosure conditions are met, and code evaluates the player's final conclusion.

10.3 Invariants and empirical questions

Two properties are asserted by design and will be verified by test: the engine applies no transition outside the authored graph, and the model receives no gated nonce fact before its disclosure condition. Those guarantees are the responsibility of the validator and context builder.

The open questions concern the value of the language interface. The demonstration would measure whether it resolves valid intentions that a deterministic keyword baseline rejects. It would also record phrasing coverage and clarification precision. Deadline success would be measured separately. A sampled human review would check whether player-visible responses assert details that cannot be derived from the supplied fact set. The demonstration would not establish that the dialogue is entertaining or production quality.

10.4 Evaluation

The test set should contain:

• direct questions;
• paraphrases;
• references to earlier turns;
• ambiguous requests;
• valid player intentions outside the authored intent set;
• attempts to obtain gated facts;
• statements that contradict known evidence;
• irrelevant or adversarial input;
• long conversations that revisit earlier facts.

Headline measures:

Illegal applied transitions and early gated-fact exposure must remain zero. Expressive coverage tests whether the bounded interface accepts valid phrasing that the deterministic baseline misses while authority remains in code. Baseline-covered regression and spurious intent rate show what that gain costs. All measures are properties of the complete demo configuration rather than rankings of the model. The unserved-valid-intent measure exposes the ceiling imposed by the authored action set.

10.5 Required artifacts

The future repository should publish:

• scenario generator and fixed seed set;
• state graph and fact definitions;
• JSON schema and generated grammar;
• prompt files;
• model and runtime manifest;
• deterministic baseline source and its design brief;
• development and held-out intent fixtures with the split definition;
• independent intent labels, reviewer agreement and adjudication record;
• append-only JSONL call receipts;
• replay command;
• summary script;
• raw and summarised results.

11. Demonstration two: bounded real-time director

The second proposed demonstration moves the test from player expression to timing. It asks whether the same state, authority and evidence boundaries survive a real-time budget when the input is telemetry.

11.1 Scenario

A small arena simulation records a player trace containing movement, damage, resource use, encounter completion, inactivity and repeated failure. The trace comes from a simple interactive session or a deterministic scripted player and is then replayed under three conditions:

1. no adaptive director;
2. a rule-based director;
3. a language-model-assisted director.

Each condition uses the same world seed and input trace.

11.2 Model contract

The model receives a compact telemetry summary:

{
  "window_seconds": 20,
  "damage_taken": 42,
  "encounters_completed": 1,
  "failed_attempts": 2,
  "resource_band": "low",
  "idle_seconds": 0,
  "current_pressure": "high",
  "available_actions": [
    "hold",
    "reduce_pressure",
    "schedule_resource_support",
    "offer_hint"
  ]
}

It returns:

{
  "action": "reduce_pressure",
  "duration_seconds": 15,
  "intent": "relieve",
  "confidence": 0.71,
  "reason": "Recent damage and repeated failure exceed the current pressure target."
}

The validator checks that the action is available, clamps the duration, applies cooldowns and enforces the pacing budget. Spawn coordinates, damage values and random outcomes remain inside the simulation.

11.3 Asynchronous execution

The director runs in another process or worker. The simulation publishes telemetry at a fixed rate, allows only one active request and requires the response to identify the telemetry window it used.

The engine accepts the proposal only if:

• the response arrives before the deadline;
• the window is still current;
• the action remains available;
• the validator accepts the bounded change.

Late responses are recorded and discarded, so the simulation never waits for the model.

11.4 Evaluation

Applied actions outside the menu must remain zero, and inference must never block a simulation update. Clamp rate and deadline misses show how much work the boundary performs. Outcome deltas from a fixed trace show that the director changed the simulation; they do not compare how a player would perform after reacting to that change. A performance comparison would require a reactive scripted player policy or repeated human play.

11.5 Required artifacts

The future repository should publish:

• simulation source;
• recorded input traces;
• separate random seeds for world state and director-influenced events;
• telemetry schema;
• director action policy;
• validator limits and cooldowns;
• per-tick state and proposal logs;
• latency histograms;
• replay comparison output;
• raw results for all three conditions.

12. Why these demonstrations were selected

Small games add value only when their rules expose the boundary being studied.

The selected pair grounds the broader paper in two testable seams. The interrogation tests whether a bounded interface can accept more valid phrasing while authority stays deterministic. The director tests whether the same control model remains safe when decisions are asynchronous and time-bounded. Both test claims about what is practical now. Neither tests the two-to-five-year forecast or attempts to represent the complete future of generative gameplay.

13. How the supporting demonstrations would be measured

The demonstrations use a small output space: classify or clarify an intent, select supplied fact identifiers, propose a legal milestone or choose one director action. A local instruction model around four billion parameters is a reasonable test configuration, but its suitability and latency must be measured.

Headline results should use one declared model, quantisation, runtime, prompt, schema and parameter set. Qwen3-4B-Instruct-2507 provides a permissively licensed starting point, with its source revision and final quantised-file digest pinned.[19] Phi-4-mini-instruct can serve as an optional robustness check.[20]

llama.cpp provides the reproducible path through GBNF grammars and JSON Schema conversion.[21] The schemas should remain flat and explicit because its documentation identifies unsupported or limited schema features. Ollama can provide an easier local path, while an optional remote adapter can help readers who cannot run the model locally.[22] The evidence attached to the paper should come from the pinned local path.

The interrogation control is a frozen deterministic matcher using normalised tokens, aliases and edit-distance fallback. The director controls are no director and a rule-based director. Fixture authors and reviewers should not see implementation outcomes while labelling target intent and validity. Prompts and parameters may change against a development split, then must be frozen before the held-out run.

No headline legality, state or timing measure should depend on another language model as judge. Code can verify state transitions, fact access, schema conformance, deadlines and replay divergence. Two reviewers can assess the bounded language questions, with agreement and adjudication reported.

Hardware records should include CPU, GPU, memory, model quantisation, context size, prompt-processing rate, generation rate, time to first token, total latency and whether graphics and inference shared the GPU. The director should run on at least one CPU-only system and one consumer GPU if practical.

Temperature zero does not guarantee identical behaviour across runtimes or hardware. Fixed seeds, repeated runs and append-only receipts should preserve every accepted, rejected, late and malformed proposal. The rule-based director may be faster, the deterministic intent matcher may cover most valid phrasing and CPU inference may miss the deadline. Those outcomes would still define the useful boundary.

14. Production obligations

A proof of concept can demonstrate boundaries without proving production readiness. Shipping live language generation creates additional obligations.

14.1 Latency and capacity

Latency is part of the game mechanic. A production system needs a deadline for each interaction, bounded queues, cancellation for stale work and an authored or local fallback. Capacity planning must include concurrent players, model loading and cold starts. Cost per player-hour was not found in the sources reviewed for this paper and cannot be inferred from token pricing alone.

14.2 Character and narrative consistency

Memory retrieval is evidence rather than truth. A summary can omit a constraint, a search can return stale material, and a model can contradict the fact it retrieved. Canon and quest state need identifiers, versions and validation outside the model.

RoleBreak's long-horizon role-play benchmark found persona and safety failures emerging early, although it is a spoken-dialogue preprint rather than a game study.[16] RoleKE-Bench, introduced in a separate arXiv preprint, reports that models struggle to detect character-knowledge errors, especially errors involving familiar knowledge.[24]

14.3 Safety and adversarial players

Players will test boundaries by asking an NPC to reveal hidden instructions, ignore its role, generate disallowed content or store hostile text in persistent memory. The game should therefore separate player text from privileged instructions, moderate inputs and outputs for its rating, bound memory writes and retain provenance for remembered facts. Operators also need a way to correct persistent state, investigate incidents and fall back to authored behaviour for sensitive interactions.

Game-specific prompt-injection evidence was not found in the sources reviewed for this paper. That gap does not establish that the surface is safe.

14.4 Save, replay and multiplayer authority

A save file must capture the state that matters to future interactions. Dialogue alone may be insufficient. A replay also needs the model, prompt, schema and state projection behind each accepted proposal. In multiplayer games, an authoritative server should validate every proposal that can affect shared state.

14.5 Localisation and accessibility

Natural-language input may improve accessibility for some players while introducing uneven capability across languages, speech patterns and assistive technologies. The research reviewed here does not establish equivalent quality or safety across locales. Each supported locale needs its own interaction and safety evidence rather than an inference from a multilingual model card. Fortnite UEFN Conversations provides a current production example: its LLM-powered characters responded only in English at the review date despite being available through a global creator platform.[32]

15. The strongest counterargument

The strongest counterargument is a game-design argument. A well-authored dialogue tree is fast, testable, localisable and consistent. A rule-based director is easier to tune. A deterministic parser may already handle the phrases that matter. Open input can create blank-page syndrome, unclear affordances and conversations that distract from the game. Adding a model also introduces latency, operating cost, moderation and a new failure surface.

The current market evidence supports that caution. Generative gameplay exists, yet much of it remains concentrated in indie releases, live services, experimental features and limited tests. Service retirement has already made some earlier examples unavailable. There is no evidence that every genre benefits from open-ended dialogue or that the approach has become a default for large productions.

The same evidence shows that the design problem is already concrete. Players are questioning suspects, persuading characters, directing companions and participating in generated stories. Major tools now let creators publish conversational characters. Teams have responded by authoring goals, knowledge, action contracts, fallbacks and evaluation systems. Those practices can influence game design before generative characters become common across the industry.

The scoping condition remains strict. If a dialogue tree or parser already covers the valid-intention tail, a language model has not earned its place. If timing cannot tolerate inference, every line requires prior approval, or the supported languages cannot be evaluated adequately, the design should remain deterministic.

Where the model is justified, the architecture bounds the added cost. It interprets or proposes, the game validates and applies, and every rejection or fallback is observable. The outcome set may remain authored even when players gain more ways to reach it. This provides a practical path between fixed menus and unrestricted generation.

16. What this paper does not claim

This paper does not claim that the proposed demonstrations already have measured results, that language-model dialogue is generally better than strong authored dialogue, or that every player prefers free-form interaction. It does not establish commercial cost, long-term player retention or equivalent behaviour across locales.

It does not claim that gameplay-time language models are mainstream in AAA games, that limited tests are permanent features, or that prototypes and middleware announcements are shipped products. The two-to-five-year direction is an architecture-led forecast rather than a release schedule.

The paper also does not assign authoritative game state, complete narrative control or safety enforcement to the model. It does not predict the removal of writers, actors, narrative designers or game-AI programmers. Current systems increase the amount of character definition, state design, validation, evaluation and operational work required around generated output.

17. Conclusion

Gameplay-time language models are already part of commercial games, live services, experimental features, creator platforms and public tests. Their current roles are varied but bounded: narration, persuasion, interrogation, intent interpretation, companion interaction and high-level advice. Research reports benefits in flexible NPC interaction, narrative redirection, structured goal recognition and perceived responsiveness, mostly in small studies.[3][4][9][10][17]

The constraints are equally visible. Dialogue history is incomplete state, and strategic fluency does not guarantee correct action. Long interactions create consistency pressure, service dependencies can outlive their providers, and latency remains part of the player experience.

The practical operating rule remains clear:

Let the language model interpret and propose. Let the game decide and apply.

This boundary is already shaping the work of teams that ship or prototype these systems. They are defining personas, knowledge, goals, finite actions, memory policy, validation, fallback and evaluation around generated interaction. The change reaches beyond dialogue writing because a generative interface has to translate free language into an inspectable and recoverable system event.

The likely next stage is wider use of small local models for event-level work, hybrid routing for more demanding turns, reusable speech pipelines and engine-native authoring tools. The more distant vision of continuously reasoning open worlds remains speculative.

The state-grounded interrogation and bounded real-time director provide two ways to test the current boundary. Each would show whether a language model can widen an interaction or advise a simulation while the game retains authoritative truth and explicit timing control.

About the author

Jason Doyle writes about reliable software, observability, incident leadership, applied AI and practical controls for systems that influence human and organisational decisions. He publishes at jasondoyle.ie and can be contacted at [email protected].

References

1. Roberto Gallotta, Graham Todd, Marvin Zammit, Sam Earle, Antonios Liapis, Julian Togelius and Georgios N. Yannakakis, Large Language Models and Games: A Survey and Roadmap, IEEE Transactions on Games, 2024, DOI 10.1109/TG.2024.3461510; preprint arXiv:2402.18659, first submitted 28 February 2024 and last revised 9 December 2024, https://arxiv.org/abs/2402.18659.

2. Frederik Roland Christiansen, Linus Norgaard Hollensberg, Niko Bach Jensen, Kristian Julsgaard, Kristian Nyborg Jespersen and Ivan Nikolov, Exploring Presence in Interactions with LLM-Driven NPCs: A Comparative Study of Speech Recognition and Dialogue Options, 30th ACM Symposium on Virtual Reality Software and Technology, 2024, pages 1-11, DOI 10.1145/3641825.3687716.

3. Manuel Hochreiter, Simone Kriglstein and Gunter Wallner, Beyond Pre-Defined Scripts: Player Perceptions on Generative Non-Player Character Dialogues, Proceedings of the 31st International Conference on Intelligent User Interfaces, 2026, pages 2004-2018, DOI 10.1145/3742413.3789221.

4. Rasmus Ploug, Emil Rimer, Anthon Kristian Skov Petersen and Marco Scirea, Open-Ended NPC Dialogue Favors Casual Players: A Pilot Comparison of Three LLM-Driven Dialogue Systems, 2025 IEEE Conference on Games, DOI 10.1109/CoG64752.2025.11114150.

5. Alessandro Marincioni, Myriana Miltiadous, Katerina Zacharia, Rick Heemskerk, Georgios Doukeris, Mike Preuss and Giulio Barbero, The Effect of LLM-Based NPC Emotional States on Player Emotions: An Analysis of Interactive Game Play, 2024 IEEE Conference on Games, DOI 10.1109/CoG60054.2024.10645631.

6. Milan Wevelsiep, Nicholas Thomas Walker, Nicolas Wagner and Stefan Ultes, A Voice-Controlled Dialogue System for NPC Interaction using Large Language Models, Proceedings of the 15th International Workshop on Spoken Dialogue Systems Technology, 2025, pages 29-38, https://aclanthology.org/2025.iwsds-1.4/.

7. Sudha Rao, Weijia Xu, Michael Xu, Jorge Leandro, Ken Lobb, Gabriel DesGarennes, Chris Brockett and Bill Dolan, Collaborative Quest Completion with LLM-driven Non-Player Characters in Minecraft, Wordplay workshop at ACL 2024, arXiv:2407.03460, https://arxiv.org/abs/2407.03460.

8. Andrew Zhu, Karmanya Aggarwal, Alexander Feng, Lara J. Martin and Chris Callison-Burch, FIREBALL: A Dataset of Dungeons and Dragons Actual-Play with Structured Game State Information, Proceedings of the 61st Annual Meeting of the Association for Computational Linguistics, 2023, pages 4171-4193, DOI 10.18653/v1/2023.acl-long.229.

9. Adon Phillips, Jochen Lang and David Mould, Goal-Oriented Interactions in Games Using LLMs, IEEE Transactions on Games, volume 17, issue 2, 2025, pages 510-521, DOI 10.1109/TG.2024.3515807.

10. Nicolai Hejlesen Jorgensen, Sarmilan Tharmabalan, Ilhan Aslan, Nicolai Brodersen Hansen and Timothy Merritt, Guiding, Not Railroading: Design and Evaluation of a Multi-Agent System for Narrative Redirection in Role-playing Games, Proceedings of the 31st International Conference on Intelligent User Interfaces, 2026, pages 1551-1601, DOI 10.1145/3742413.3789218.

11. Andrew Zhu, Lara Martin, Andrew Head and Chris Callison-Burch, CALYPSO: LLMs as Dungeon Master's Assistants, Proceedings of the AAAI Conference on Artificial Intelligence and Interactive Digital Entertainment, volume 19, issue 1, 2023, pages 380-390, DOI 10.1609/aiide.v19i1.27534.

12. Joon Sung Park, Joseph O'Brien, Carrie Jun Cai, Meredith Ringel Morris, Percy Liang and Michael S. Bernstein, Generative Agents: Interactive Simulacra of Human Behavior, Proceedings of the 36th Annual ACM Symposium on User Interface Software and Technology, 2023, DOI 10.1145/3586183.3606763.

13. Jonathan Light, Min Cai, Sheng Shen and Ziniu Hu, AvalonBench: Evaluating LLMs Playing the Game of Avalon, arXiv preprint arXiv:2310.05036, 2023, https://arxiv.org/abs/2310.05036.

14. Aidan O'Gara, Hoodwinked: Deception and Cooperation in a Text-Based Game for Language Models, arXiv preprint arXiv:2308.01404, 2023, https://arxiv.org/abs/2308.01404.

15. Davide Paglieri, Bartlomiej Cupial, Samuel Coward, Ulyana Piterbarg, Maciej Wolczyk, Akbir Khan, Eduardo Pignatelli, Lukasz Kucinski, Lerrel Pinto, Rob Fergus, Jakob Nicolaus Foerster, Jack Parker-Holder and Tim Rocktaschel, BALROG: Benchmarking Agentic LLM and VLM Reasoning On Games, ICLR 2025, arXiv:2411.13543, https://arxiv.org/abs/2411.13543.

16. Yuqi Wang, Fengyuan Liu, Haochen Luo, Zhiqi Yu and Qi Liu, RoleBreak: Benchmarking Long-Horizon Role-Playing Robustness in Spoken Dialogue, arXiv:2609.16614, submitted to ICASSP 2027, 15 September 2026, https://arxiv.org/abs/2609.16614.

17. Mahyar Tourchi Moghaddam, Tiziano Santilli and Mina Alipour, LLM-Assisted Reinforcement Learning for Affective Game Adaptation, Proceedings of the ACM on Human-Computer Interaction, volume 10, issue 4, EICS, article EICS029, 2026, DOI 10.1145/3816781.

18. Tianyang Xu, Hongqiu Wu, Weiqi Wu and Hai Zhao, OPEN-THEATRE: An Open-Source Toolkit for LLM-based Interactive Drama, EMNLP 2025 System Demonstrations, arXiv:2509.16713, https://arxiv.org/abs/2509.16713.

19. Qwen Team, Qwen3-4B-Instruct-2507, Hugging Face model repository, revision cdbee75f17c01a7cc42f958dc650907174af0554, Apache 2.0 licence, accessed 18 September 2026, https://huggingface.co/Qwen/Qwen3-4B-Instruct-2507.

20. Microsoft, Phi-4-mini-instruct, Hugging Face model repository, revision cfbefacb99257ffa30c83adab238a50856ac3083, MIT licence, accessed 18 September 2026, https://huggingface.co/microsoft/Phi-4-mini-instruct.

21. ggml-org, GBNF Guide, llama.cpp documentation, accessed 18 September 2026, commit acecd56032ddc34bada14a2d978f110d9c987095, https://github.com/ggml-org/llama.cpp/blob/acecd56032ddc34bada14a2d978f110d9c987095/grammars/README.md.

22. Ollama, API documentation: Structured outputs, accessed 18 September 2026, commit 2c29c9f05ea04623d0d30a85fb937c395dcf99c7, https://github.com/ollama/ollama/blob/2c29c9f05ea04623d0d30a85fb937c395dcf99c7/docs/api.md.

23. Zihao Guo, Hongtao Lv, Chaoli Zhang, Yibowen Zhao, Yixin Zhang and Lizhen Cui, The Illusion of Randomness: How LLMs Fail to Emulate Stochastic Decision-Making in Rock-Paper-Scissors Games?, Findings of the Association for Computational Linguistics: EMNLP 2025, pages 8618-8637, DOI 10.18653/v1/2025.findings-emnlp.458.

24. Wenyuan Zhang, Shuaiyi Nie, Jiawei Sheng, Zefeng Zhang, Xinghua Zhang, Yongquan He and Tingwen Liu, Revealing and Mitigating the Challenge of Detecting Character Knowledge Errors in LLM Role-Playing, arXiv preprint arXiv:2409.11726, 2024, revised 2025, introducing RoleKE-Bench, https://arxiv.org/abs/2409.11726.

25. Latitude, AI Dungeon: The Basics, AI Dungeon Help Center, accessed 18 September 2026, https://help.aidungeon.com/faq/the-basics.

26. Proxima, Suck Up!, Valve Steam store record, commercial version 1.0 released 1 October 2025, accessed 18 September 2026, https://store.steampowered.com/app/2726370/Suck_Up/.

27. Bumblebee Studios, Vaudeville, Valve Steam store record, commercial version 1.0 released 28 November 2025, https://store.steampowered.com/app/2240920/Vaudeville/; Vaudeville leaves Early Access, Steam News, 28 November 2025, https://store.steampowered.com/news/app/2240920/view/1817483467040523.

28. Jam & Tea Studios, Retail Mage, Valve Steam store record, released 12 November 2024, https://store.steampowered.com/app/3224380/Retail_Mage/; Making Retail Mage: A New Approach to AI in Games, 13 March 2025, https://www.jamandtea.studio/news/making-retail-mage-a-new-approach-to-ai-in-games.

29. Anuttacon, Whispers from the Star, Valve Steam store record, released 14 August 2025, https://store.steampowered.com/app/3730100/Whispers_from_the_Star/; Amazon Web Services, How Anuttacon Scaled AI-Enhanced Gaming Workloads for Whispers from the Star, 14 August 2025, https://aws.amazon.com/blogs/storage/how-anuttacon-scaled-ai-enhanced-gaming-workloads-for-whispers-from-the-star/.

30. inZOI Studio and KRAFTON, Guidance on System Requirements for Using Smart Zoi, 26 March 2025, accessed 18 September 2026, https://playinzoi.com/en/news/8419.

31. PUBG Studios and KRAFTON, Patch Notes: Update 42.1, June 2026, documenting the Ally Duo limited beta, https://pubg.com/en/news/10179; KRAFTON AI, From Workflow-Based SLM to Autonomous Agent: Evolving PUBG Ally's Architecture, 2026, https://www.krafton.ai/blog/pubg_ally_nemotron/; NVIDIA Technical Blog, How KRAFTON Built PUBG Ally, a Co-Playable Character Powered by NVIDIA ACE, 25 June 2026, updated 6 August 2026, https://developer.nvidia.com/blog/how-krafton-built-pubg-ally-a-co-playable-character-powered-by-nvidia-ace/.

32. Epic Games, 41.30 Fortnite Ecosystem Updates and Release Notes, 30 July 2026, https://dev.epicgames.com/documentation/fortnite/41-30-fortnite-ecosystem-updates-and-release-notes; LLM Conversations in Unreal Editor for Fortnite, accessed 18 September 2026, https://dev.epicgames.com/documentation/fortnite/llm-conversations-in-unreal-editor-for-fortnite; Using the Prompt Editor Tool in Unreal Editor for Fortnite, accessed 18 September 2026, https://dev.epicgames.com/documentation/fortnite/using-the-prompt-editor-tool-in-unreal-editor-for-fortnite.

33. Ubisoft, How Ubisoft's New Generative AI Prototype Changes the Narrative for NPCs, 19 March 2024, https://news.ubisoft.com/en-us/article/5qXdxhshJBXoanFZApdG3L/how-ubisofts-new-generative-ai-prototype-changes-the-narrative-for-npcs.

34. Convai, How Narrative Design Works and How Character Actions Work, Unreal Engine plugin documentation, accessed 18 September 2026, https://docs.convai.com/api-docs/plugins-and-integrations/convai-unreal-engine-plugin/features/narrative-design/how-narrative-design-works, https://docs.convai.com/api-docs/plugins-and-integrations/convai-unreal-engine-plugin/features/character-actions/how-character-actions-work.

35. Inworld AI, Inworld Origins, Valve Steam store record, released 27 July 2023, https://store.steampowered.com/app/2199920/Inworld_Origins/; Origins Announcement, Steam News, 2 July 2024, announcing shutdown on 8 July 2024, https://store.steampowered.com/news/app/2199920/view/4252042698974767674.