AI-Native Games: Core AI Integration

• AI-native games are defined by their reliance on runtime generative AI, making the AI component essential for core gameplay and experience.
• They integrate AI outputs into narrative, rules, NPC behavior, and world state, ensuring gameplay mechanics cannot function without active AI input.
• Design methods include controlled generative pipelines, schema constraints, and dynamic evaluation metrics to maintain playability and interactive consistency.

AI-native games are games in which artificial intelligence is constitutive of the core loop rather than an auxiliary subsystem. In the narrow formulation proposed by the recent survey literature, a game is AI-native when it relies on runtime generative AI, when AI output directly affects action interpretation, content, rules, NPC behavior, world state, or outcome judgment, and when removing the AI component would make the central form of play collapse or become fundamentally different (Xu et al., 1 Jul 2026). Across the broader literature, however, the term also covers games whose main activity is programming autonomous agents, training executable learning systems, co-creating worlds and rules with AI, or evaluating general intelligence through gameplay itself (Togelius, 2016). The result is a field spanning agent-programming war games, text-interactive competitions, world-model-driven runtimes, generative narrative systems, educational simulations, and open-ended evaluation platforms.

1. Definition, criteria, and boundary cases

The most explicit definition of AI-native games is the counterfactual criterion: if the AI component were removed or trivially replaced, the central form of play would become impossible or fundamentally different (Xu et al., 1 Jul 2026). That definition is operationalized through three necessary conditions. First, there must be runtime generative AI rather than only traditional game AI such as pathfinding, finite-state NPCs, utility systems, adaptive difficulty, or offline asset generation. Second, the game must exhibit core-loop dependence, so that AI output affects player action interpretation, content, rules, NPC behavior, world state, or outcome judgment. Third, the AI must be non-substitutable: finite authored content or deterministic rules could not reproduce the same core experience without changing the form of play (Xu et al., 1 Jul 2026).

This framework sharply distinguishes AI-native games from adjacent categories. AI-augmented games may include optional conversational NPCs, cosmetic generation, or recommendations, yet remain playable in essentially the same form if those systems are removed. AI-boundary artifacts place generative AI at the center of activity but lack strict ludic structure such as goals, rules, consequential state progression, or win conditions; AI Dungeon is treated as the canonical example of this boundary category (Xu et al., 1 Jul 2026). Traditional procedural content generation is likewise excluded when it operates inside closed grammars or authored search spaces without open-ended semantic mediation at runtime.

Other strands of the literature employ a broader concept. The chapter on AI in and for games treats AI-native design as games in which AI is integral to core systems such as procedural content generation, adaptive player-experience modeling, responsive NPCs, and data-driven personalization operating continuously during play and design iteration (Karpouzis et al., 2021). The chapter on future video games similarly describes AI-native games as those in which AI functions as a generative substrate, a generalist player and co-player, a continuous adapter, a co-creative partner, and a scaffold for open-ended worlds and rule invention (Togelius, 2016). The serious-games literature adds a further distinction between instructional intelligence and adaptivity, arguing that games designed around AI as a first-class runtime capability should aim for both deep state estimation and real-time orchestration rather than optimizing one at the expense of the other (Tripathi et al., 21 May 2026). Taken together, the literature contains both a narrow generative-runtime definition and a broader first-class-AI-runtime definition.

2. Historical lineage and early formulations

One early formulation appears in AI WAR, a 3D war game and engine whose central loop is not manual piloting but the design and programming of autonomous Cybugs in the CAICL language (Ahmed, 2010). The paper explicitly frames the player as a coach who trains a player and then sits outside the ground to watch that player compete. CAICL exposes sensing commands, action commands, control-flow constructs, and system variables governing fuel, damage, shielding, combat, and movement. The paper identifies five supported behavior classes—Sensing; Efficient coordination of movement and location; Dynamic allocation of resources; Ability to model the opponent; and Planning and problem solving—and the example Cybug, Ghazu, is implemented as a sense–think–act control loop with labels, conditional branches, randomized routines, and a self-destruct tactic (Ahmed, 2010). In this formulation, gameplay progression is inseparable from authoring the agent’s intelligence.

A different but equally explicit early example is Samu Entropy, a family of esports-style games in which the “content” of play is an executable TensorFlow-like dataflow graph (Bátfai et al., 2017). Players construct, fine-tune, train, and competitively evaluate learning systems through role-specialized mechanics: Samu executes graphs, Greta edits graphs through a Motherboard Builder, Nandi supplies supervision, Matyi gathers data, and Erika evaluates competitive performance. The paper translates classification uncertainty and correctness into bit-valued game signals via entropy and “information accuracy,” making model fitness a visible score currency rather than a hidden optimization objective (Bátfai et al., 2017). Here AI is not merely inside the game; building AI is the game.

Competition environments further broadened the concept. The Snakes AI Competition was explicitly designed for autonomous bots, with Java controllers selecting one of four directions per tick under a strict one-second decision budget, simultaneous movement, standardized tournament structure, and public logs and broadcasts (Brown et al., 2021). EvoMan, inspired by Mega Man II, exposed a 68-sensor state vector and combinatorial action control to support neuroevolution and competitive coevolution between player and enemy populations (Araújo et al., 2016). Both systems place reproducible programmatic control, explicit timing, and benchmarkable outcomes at the center of the game loop.

The Text-Based Adventure AI Competition reintroduced a different aspect of AI-nativity: the epistemic problem of discovering actions from language rather than optimizing over a known action set (Atkinson et al., 2018). Agents receive narrative text each turn and must generate a single free-text command that the game parser accepts. This turns natural-language understanding, affordance extraction, symbolic state abstraction, and acting under partial observability into the core challenge. In the broader history of AI-native games, this competition marks a transition from programmable control over explicit states to gameplay whose action space must itself be inferred from semantics (Atkinson et al., 2018).

3. Mechanics, architectures, and runtime organization

The central systems problem of contemporary AI-native design is organizing semantic openness into stable gameplay. The survey literature argues that open-ended AI outputs become playable only when constrained by mechanical invariants: goals, rules, state, feedback, pacing, and player agency (Xu et al., 1 Jul 2026). These invariants anchor interpretation, make AI outputs consequential, structure turn rhythm, and ensure that free-form inputs alter future affordances rather than remaining decorative. Common implementation patterns include proposal-and-verification pipelines, explicit world models, long-session memory systems, hidden case models for investigation and social play, Retrieval-Augmented Generation, schema-constrained outputs, and caching that turns ephemeral generation into durable state (Xu et al., 1 Jul 2026).

The serious-games literature formulates a general runtime architecture that transfers directly to AI-native entertainment and simulation games (Tripathi et al., 21 May 2026). The loop begins with perception over telemetry, natural language, and optional multimodal signals; proceeds to state estimation by a learner or player modeling agent; then passes through a policy layer that selects task difficulty, hint timing, quest sequencing, encounter dynamics, or NPC strategy; then to a generation layer, often LLM- or RAG-based; then to validation and guardrails; and finally to delivery and logging. The same chapter presents formalizations through MDPs and POMDPs, Bayesian Knowledge Tracing, Item Response Theory, and PID-style dynamic difficulty adjustment, not as a single canonical model but as the mathematical substrate for different forms of adaptive, AI-native control (Tripathi et al., 21 May 2026).

PlayGen extends this architecture to the runtime engine itself by learning an action-conditioned world transition model $P(o_{t+1}\mid o_t,a_t)$ directly from gameplay (Yang et al., 2024). Its runtime is an autoregressive latent diffusion model with a DiT backbone, VAE compression, and an RNN-like hidden state $z_t$ for temporal context. Rather than treating AI as content generation around a conventional engine, PlayGen uses the learned model as renderer-simulator. The paper evaluates playability along three dimensions—real-time interaction, sufficient visual quality, and accurate simulation of interactive mechanics—and reports 20 FPS on an NVIDIA RTX 2060 with DDIM sampling as low as four steps, sustained beyond 1000 frames of gameplay (Yang et al., 2024). This is a strong form of AI-native runtime, because world evolution, visual output, and control responsiveness are all delegated to learned dynamics.

A different infrastructural direction is represented by AI GameStore, which synthesizes standardized, containerized variants of human games for AI evaluation while simultaneously articulating design rules that are directly reusable in AI-native games (Ying et al., 19 Feb 2026). The platform constrains games to JavaScript, keyboard-only controls, pause/resume, required scoring, multiple levels, resets, and instrumentation. It annotates games with a capability taxonomy—Visual Processing, Spatial-Temporal Coordination, Memory, Planning, World Model Learning, Physical Reasoning, and Social Reasoning—and evaluates both humans and frontier vision-LLMs through a paused-step harness with screenshots, prior actions, rationales, and a scratchpad memory channel (Ying et al., 19 Feb 2026). Although AI GameStore is primarily an evaluation platform, its architecture formalizes a reproducible, telemetry-rich substrate for AI-native game design.

Industrial creation systems extend these patterns into multimodal asset and video synthesis. Hunyuan-Game describes an “intelligent game creation” stack with game-domain text-to-image, VFX generation, transparent asset generation, character consistency pipelines, image-to-video, dynamic illustration loops, generative super-resolution, and interactive game video generation through action-conditioned controls (Li et al., 20 May 2025). In that framing, AI-native games are designed around dynamic content synthesis, player co-creation, and real-time personalization as first-class primitives rather than downstream tools. The work is not itself a single game, but it supplies production-grade mechanisms—reference control, prompt rewriting, alpha-aware outputs, and action-to-camera mapping—that can serve as the substrate for AI-native play (Li et al., 20 May 2025).

4. Typology and representative forms

The most systematic taxonomy separates the outward player-facing form from the internal AI mechanic that makes the system AI-native (Xu et al., 1 Jul 2026). On the G-axis, the survey identifies nine classes across 53 artifacts: Narrative Adventure, RPG, Puzzle, Strategy/Management, Simulation, Sandbox/Creation, Social Deduction/Party, Relationship/Companion, and Hybrid/Experimental. On the N-axis, it identifies six dominant AI mechanics: Epistemic Interaction, Social Influence, Generative Narrative / AI GM, Semantic Action Adjudication, Multi-Agent Simulation, and Generative Construction. The corpus is concentrated in language-forward designs, especially G1 Narrative Adventure and the N1/N3 mechanics of epistemic interaction and generative narrative; semantic adjudication, multi-agent simulation, generative construction, and relationship play remain comparatively sparse (Xu et al., 1 Jul 2026).

One representative generative-narrative system is 1001 Nights, in which co-created language becomes world state and equipment in real time (Sun et al., 2023). The player writes story fragments to steer an AI King, implemented with GPT-4, toward contextually appropriate weapon keywords. The model returns a strict JSON structure with isValid, comment, and story; valid continuations may introduce weapons such as sword, shield, dagger, knife, blade, or wand, which then materialize in the player’s inventory. A second GPT-4 pass summarizes the evolving context into an environment-only prompt, which Stable Diffusion renders, with ControlNet and a pixelization stage aligning the result to a Persian/Arabian retro aesthetic (Sun et al., 2023). The game’s core loop cannot be reduced to authored branching without losing the mechanic that language literally produces the world.

God’s Innovation Project exemplifies generative construction by making prompt-to-terrain generation the main player verb (Nair et al., 31 Mar 2025). Players build prompts from a word bank derived from the Five Dollar Model’s training corpus; the pretrained model in the “map” domain turns the prompt embedding into a 10×10 grid of tile indices, which is inserted into a selected sub-grid of a 40×40 world. Domain-specific post-processing connects water into rivers and lakes, aggregates rock blocks into mountain-like structures, and regularizes house tiles for 3D adjacency. Terrain has direct gameplay consequences: rocks are impassable, water slows NPCs, and house-related tiles spawn new villagers at the start of the next day (Nair et al., 31 Mar 2025). Prompting is restricted to an in-distribution 1000-word pool to preserve playability and prevent trivial cheat phrases.

Educational AI-native design appears in Malinowski’s Lens, which transforms Argonauts of the Western Pacific into a RAG-grounded exploration-and-assessment loop (Hoffmann et al., 10 Nov 2025). GPT-4o generates 40–60 word scenes and choices grounded in ChromaDB retrieval over the text, while DALL·E 3 produces VGA-style images under a strict prompt template. The gameplay alternates between fieldwork exploration, artifact and vocabulary collection, and an “Academic Defense” phase that assembles a ten-question quiz tailored to the session history. The game also embeds an explicit representational intervention: indigenous people are rendered as silhouettes while Malinowski appears in detail, making the visual system itself part of the pedagogical framing (Hoffmann et al., 10 Nov 2025).

The broader taxonomy also encompasses social and epistemic systems. The survey treats Vaudeville as a canonical G1×N1 case in which investigation depends on AI-generated testimony and lie structures; Suck Up!, Yandere AI Girlfriend Simulator, and Hostage Down are N2 systems built around persuasion and affective influence; Infinite Craft, Alchemic AI, and OneSpellFitsAll are N4 systems in which AI adjudicates open-ended combinations, spells, or semantic actions; Aivilization and Historical Simulator: Chongzhen exemplify N5 multi-agent worlds with goals, memory, and situated events (Xu et al., 1 Jul 2026). What unifies these otherwise dissimilar games is not theme or interface but the fact that AI performs indispensable semantic mediation inside the playable loop.

5. Evaluation, metrics, and empirical performance

AI-native games have generated several distinct evaluation cultures. In text-only environments, the Text-Based Adventure AI Competition normalized progress by each game’s scoring system and then aggregated performance across a 20-game suite (Atkinson et al., 2018). The normalized score for a run is

$SN(g,r)=\frac{S(g,r)}{S_{\max}(g)},$

and the aggregate percentage score is

$$\bar{S}=\frac{100}{|G||R|}\sum_{g\in G}\sum_{r\in R}\frac{S(g,r)}{S_{\max}(g)}.$$

A complementary generalization measure is the percentage of games with non-zero score,

$$\mathrm{NZ}=\frac{100}{|G||R|}\sum_{g\in G}\sum_{r\in R}\mathbf{1}[S(g,r)>0].$$

On the 2018 evaluation, NAIL achieved 2.56% completion and 45.5% non-zero score, CARL 1.59% and 30%, Golovin 1.45% and 31%, BYU-Agent 2016 0.79% and 15%, and RandomAgent 1.66% and 34% (Atkinson et al., 2018). The competition’s significance lies less in absolute score than in its demonstration that affordance extraction, parser robustness, and memory are central evaluation axes for AI-native language play.

AI GameStore replaces per-game absolute scoring with normalization to the human median and aggregation by geometric mean across a 100-game suite (Ying et al., 19 Feb 2026). Its core metric is

$$S_{\mathrm{norm}}=\mathrm{clip}\!\left(100\times \frac{\text{Raw Game Score}}{\text{Human Median Score}},\,1,\,10000\right).$$

Across seven frontier vision-LLMs evaluated zero-shot for two minutes per game, all geometric mean normalized scores were below 10, with GPT-5.2 at 8.26, Claude-Opus-4.5 at 7.74, Gemini-2.5-Pro at 7.49, Gemini-2.5-Flash at 7.07, GPT-5-mini at 6.13, Llama-4-Maverick at 5.91, and Qwen-3-VL-32B at 4.68 (Ying et al., 19 Feb 2026). The same study reports a 12–18× runtime gap relative to humans and a bimodal score distribution, with models struggling most on Memory, Planning, and World Model Learning. In the GameStore framework, AI-native games become not only play objects but a scalable substrate for measuring machine general intelligence against a living distribution of human-designed tasks (Ying et al., 19 Feb 2026).

PlayGen introduces a mechanics-centric evaluation regime for learned game runtimes (Yang et al., 2024). It supplements LPIPS, PSNR, FID, and FVD with action-aware metrics derived from a Valid Action Model: $$ActAcc=\frac{1}{L}\sum_{i=1}^{L}[a_i^{pred}==a_i^{gt}], \qquad ProbDiff=\frac{1}{L}\sum_{i=1}^{L}[P(a_i^{pred})-P(a_i^{gt})].$$ For Super Mario Bros at prediction length 32, the paper reports LPIPS 0.062, PSNR 26.18, FID 6.12, FVD 105.44, ActAcc 0.803, and ProbDiff 0.056; at length 1024, LPIPS 0.222, PSNR 18.19, FID 50.91, FVD 173.06, ActAcc 0.789, and ProbDiff 0.065. For Doom, ActAcc declines from 0.858 at 32 frames to 0.822 at 1024 frames while 20 FPS can still be maintained on an RTX 2060 with four DDIM steps (Yang et al., 2024). The evaluation target is therefore not just appearance, but sustained mechanical faithfulness under interaction.

Other strands formalize progress in different ways. Samu Entropy defines entropy over predictive distributions and computes “information accuracy” as

$infoacc=\sum_{i=1}^{m} a_i e_i,$

where $a_i$ is $1$ for correct predictions and $z_t$0 otherwise, and $z_t$1 is the entropy of the predicted class distribution for input $z_t$2 (Bátfai et al., 2017). EvoMan evaluates controller quality with a shaped fitness that rewards damage dealt, penalizes damage taken, and penalizes prolonged low energy: $z_t$3 It then averages performance across five matches against the current best and randomly sampled opponents to reduce brittleness (Araújo et al., 2016). These metrics indicate that AI-native evaluation is highly heterogeneous: depending on the system, the target may be semantic generalization, human-normalized competence, mechanics fidelity, information-theoretic learning progress, or coevolutionary robustness.

6. Design problems, controversies, and future directions

The recurrent design difficulty is converting open-ended AI output into legible, consequential, and fair play. The survey names this problem directly: AI-native design depends on mechanical invariants that stabilize semantic openness (Xu et al., 1 Jul 2026). Without explicit goals, state, feedback, pacing, and agency, the system drifts toward chatbot interaction or aesthetic novelty rather than game structure. This is why so much of the literature emphasizes validators, schema-constrained outputs, tool use, state graphs, retrieval, hidden case models, and repair loops (Xu et al., 1 Jul 2026). The same concern appears in earlier work in different vocabulary: AI WAR remarks that simple Cybugs are easy to design but learning behavior and complete environmental awareness are difficult, and the text-adventure competition repeatedly exposes parser mismatches, indirect references, out-of-game menus, and insufficient long-term planning as dominant failure modes (Ahmed, 2010, Atkinson et al., 2018).

Latency, inference cost, and runtime instability are equally central. AI GameStore’s paused-step interface is explicitly a workaround for high-latency APIs, and its authors identify longer horizons, real-time control, and richer multi-agent worlds as future work (Ying et al., 19 Feb 2026). The survey generalizes these concerns into “inference economics,” recommending local small models for narrow roles, cloud–local collaboration, on-demand inference, speculative decoding, batching, quantization, and caching as first-class design patterns (Xu et al., 1 Jul 2026). The serious-games literature reaches a similar conclusion from a different direction, arguing that explainability, validation, computational cost, learner trust, and limited empirical evidence on long-term outcomes remain unresolved even when LLMs, RL, and multi-agent orchestration appear architecturally promising (Tripathi et al., 21 May 2026).

Safety and governance are not peripheral issues because runtime generation can directly alter persistent world state, social interactions, and personalized trajectories. The survey emphasizes defense in depth against bias, toxicity, hallucination, prompt injection, privacy violations, behavioral manipulation, and unresolved IP questions, while also noting preservation problems when hosted model behavior changes over time (Xu et al., 1 Jul 2026). Malinowski’s Lens responds to representational risk by rendering indigenous people as silhouettes; GIP constrains prompting to an in-distribution 1000-word bank to preserve reliability and play balance rather than permitting arbitrary text; 1001 Nights relies on in-character moderation and strict JSON structure to resist jailbreaks and derailment (Hoffmann et al., 10 Nov 2025, Nair et al., 31 Mar 2025, Sun et al., 2023). These are not interchangeable solutions, but they illustrate a common principle: control must be embedded at the mechanic level, not bolted on after generation.

Future work in the literature converges on several directions. One is deeper mechanics-level innovation around semantic adjudication, world-model acquisition, memory, and planning rather than simple content volume (Xu et al., 1 Jul 2026). Another is multimodal and multi-agent expansion: AI GameStore calls for richer social reasoning and grounded multimodal inputs, while Hunyuan-Game and PlayGen point toward interactive video generation, longer-sequence coherence, more faithful world models, character consistency, and player co-creation across images, video, and action-conditioned environments (Ying et al., 19 Feb 2026, Li et al., 20 May 2025, Yang et al., 2024). A third is domain-specific adaptation in education and training, where Malinowski’s Lens and the serious-games chapter show that AI-native systems can combine RAG grounding, adaptive assessment, and runtime generation, but only if validation and pedagogical alignment remain explicit (Hoffmann et al., 10 Nov 2025, Tripathi et al., 21 May 2026). The literature therefore treats AI-native games not as a single genre but as a design regime in which AI must be indispensable, mechanically bounded, and empirically accountable.