Utility-Based AI Systems

Utility-Based AI Systems represent a sophisticated decision-making paradigm in game development where non-player characters (NPCs) evaluate and select actions by dynamically assigning numerical scores to potential behaviors based on their desirability within the current game context ¹². Unlike traditional approaches that rely on fixed behavioral scripts or finite state machines, utility AI enables NPCs to exhibit adaptive, lifelike behavior that responds fluidly to changing circumstances and player interactions ¹. This methodology has become a common and effective technique across diverse game genres, providing developers with a flexible framework that balances computational efficiency with behavioral sophistication, ultimately enhancing player immersion and creating more believable virtual worlds ⁵.

Overview

The emergence of Utility-Based AI Systems addresses a fundamental limitation in traditional game AI architectures: the inability of scripted behaviors and rigid state machines to produce convincingly adaptive NPC behavior in complex, dynamic game environments ¹. Early game AI relied heavily on predetermined scripts and simple state transitions, which often resulted in predictable, repetitive NPC behavior that broke player immersion when characters failed to respond appropriately to novel situations ³. As games grew more sophisticated and player expectations for intelligent, responsive NPCs increased, developers needed decision-making systems that could weigh multiple competing priorities and adapt seamlessly to changing contexts.

Utility-based approaches emerged as a solution to this challenge by introducing a mathematically grounded framework for autonomous decision-making that answers the fundamental question: "What is the best action I can take right now?" ². The system converts varied data from the current game state into normalized numerical scores ranging from 0 to 1, then selects the action with the highest score for execution ². This objective comparison mechanism allows for nuanced decision-making that transcends simple goal achievement, enabling agents to weigh competing priorities and adapt their behavior based on contextual factors ⁴.

Over time, utility AI has evolved from a specialized technique used in complex simulation games like The Sims to a widely adopted methodology across genres including action games, strategy titles, and military training simulations ³⁶. Modern implementations have become increasingly sophisticated, incorporating hierarchical bucketing systems, integration with behavior trees and state machines, and designer-friendly tools that expose parameters for rapid iteration without code changes ²⁵. This evolution reflects the gaming industry's recognition that believable, adaptive AI is essential for creating engaging player experiences in increasingly complex virtual worlds.

Key Concepts

Utility Functions

Utility functions form the mathematical heart of utility-based AI systems, serving as the mechanism that evaluates potential actions against various criteria and assigns numerical scores based on how well each action serves the agent's objectives under current conditions ¹. These functions transform raw game state data—such as unit positions, stat values, item availability, and threat levels—into meaningful normalized scores typically ranging from 0 to 1 ².

Example: In a tactical combat game, an enemy soldier NPC might have a "Take Cover" utility function that considers multiple factors: the soldier's current health percentage, proximity to available cover positions, and number of visible enemies. When the soldier's health drops below 50%, nearby cover exists within 10 meters, and three or more enemies have line of sight, the utility function might output a score of 0.85. Conversely, at full health with only one distant enemy visible, the same function might output 0.20, making aggressive actions more attractive.

Action-Agnostic Decision Layer

The action-agnostic principle emphasizes that utility AI concerns itself only with what action should be taken, not how that action is executed ². This separation of concerns makes utility AI highly compatible with various implementation techniques, whether state machines, behavior trees, or other execution mechanisms, functioning as a decision layer that informs downstream systems about which action to pursue ².

Example: In an open-world RPG, a merchant NPC's utility system might determine that "Flee from Danger" is the highest-scoring action when bandits attack the marketplace. The utility system simply identifies this as the optimal choice and passes it to the game's action execution system. The actual implementation—whether the merchant uses a pathfinding algorithm to navigate to the nearest guard post, triggers a fear animation, or drops inventory items to move faster—is handled entirely by separate systems that interpret and execute the "Flee" command according to the game's specific mechanics.

Weighting Systems

Weighting systems allow designers to bias action selection toward preferred behaviors by assigning different multipliers to action categories, enabling the creation of distinct NPC personalities and behavioral archetypes without modifying underlying utility functions ². By doubling the score for offensive abilities, developers can create an aggressive enemy archetype, while heavily weighting defensive actions produces cautious characters ².

Example: In a fantasy strategy game, two dragon NPCs might use identical utility functions but exhibit dramatically different personalities through weighting. The "Ancient Red Dragon" has a 2.0x multiplier on all aggressive actions (attack, pursue, intimidate) and a 0.5x multiplier on defensive actions (retreat, heal, hide), making it relentlessly aggressive. The "Wise Silver Dragon" uses inverse weights—0.7x on aggressive actions and 1.8x on defensive and diplomatic actions—creating a cautious, strategic opponent that prioritizes survival and negotiation even when using the same underlying decision-making logic.

Bucketing Systems

Bucketing systems organize actions into hierarchical priority categories, where the system first evaluates high-level buckets with weighted priorities, then selects and evaluates actions only within the chosen bucket ⁶. This approach, famously used in The Sims series, prevents computationally expensive evaluation of all actions simultaneously while maintaining logical priority hierarchies ⁶.

Example: A survival game NPC might organize actions into four buckets: "Critical Survival" (priority weight 10.0), "Basic Needs" (priority weight 5.0), "Social Interaction" (priority weight 2.0), and "Entertainment" (priority weight 1.0). When the NPC's hunger reaches critical levels, the "Basic Needs" bucket scores highest, and the system evaluates only actions within that bucket—"Eat Preserved Food" (utility 0.9), "Hunt Wildlife" (utility 0.6), or "Gather Berries" (utility 0.4)—rather than wasting computation comparing eating to low-priority actions like "Play Card Game" or "Tell Joke."

Continuous Reevaluation

Continuous reevaluation occurs as the decision-making cycle repeats, typically every frame or at regular intervals, enabling the agent to abandon current actions if higher-utility alternatives emerge and creating responsive, adaptive behavior ¹. This dynamic reassessment ensures NPCs respond immediately to changing circumstances rather than committing inflexibly to predetermined action sequences.

Example: In a stealth action game, a guard NPC is patrolling a corridor (utility score 0.4) when the player triggers an alarm in a nearby room. The guard's "Investigate Alarm" action immediately jumps to a utility score of 0.95, causing the NPC to abandon the patrol mid-route and rush toward the alarm source. If the player then attacks the guard directly, "Engage in Combat" spikes to 0.98, instantly overriding the investigation behavior. This continuous reevaluation creates the impression of an intelligent guard who dynamically prioritizes threats rather than robotically completing predetermined routines.

State Representation

State representation serves as the agent's mental map of the world, maintaining awareness of relevant game state variables including health status, resource availability, enemy positions, environmental hazards, and other contextually important information ⁴. Accurate state representation is essential because utility functions can only make intelligent decisions based on the information available to them.

Example: A squad commander NPC in a military simulation maintains a comprehensive state representation including: friendly unit positions and health percentages, known enemy positions with confidence levels (confirmed visual contact vs. suspected based on gunfire sounds), ammunition counts for each squad member, proximity to mission objectives, available cover positions within 50 meters, and time remaining until reinforcements arrive. When calculating the utility of "Advance to Objective," the function considers all these factors—low ammunition might reduce the score, while nearby cover and numerical superiority increase it—producing contextually appropriate tactical decisions.

Emergent Behavior

Emergent behavior refers to complex, unpredictable actions arising from simple underlying rules, which utility-based AI facilitates when multiple agents with utility-based decision-making interact ⁶. Their combined behaviors can produce novel situations not explicitly programmed, enhancing replayability and player discovery ⁶.

Example: In a city-building simulation, individual citizen NPCs use simple utility functions: prioritize work when money is low, socialize when loneliness is high, shop when needs arise. However, when hundreds of citizens interact, emergent patterns develop: a popular tavern becomes a social hub because many citizens' "Socialize" actions identify it as optimal, which attracts more citizens, creating a feedback loop. Meanwhile, a poorly located shop fails because few citizens' utility functions rate traveling there as worthwhile, eventually forcing the business to close. These city-wide patterns emerge naturally from individual utility calculations without explicit programming of economic systems or social dynamics.

Applications in Game Development

Adaptive Combat AI in Action Games

Utility-based systems excel at creating combat opponents that respond intelligently to player tactics and changing battlefield conditions ¹. Enemy NPCs evaluate multiple combat options—attacking, retreating, using special abilities, seeking cover, calling for reinforcements—based on factors like health status, ammunition, numerical advantage, and environmental opportunities.

Example: In a third-person shooter, an elite enemy soldier uses utility AI to create challenging, unpredictable combat behavior. When the player maintains distance and uses a sniper rifle, the enemy's "Advance Using Cover" action scores highest (0.82), causing the NPC to move tactically between cover positions to close the gap. When the player switches to a shotgun and charges, the enemy's utility functions immediately adapt—"Maintain Distance" and "Throw Grenade" spike to 0.88 and 0.76 respectively, causing the NPC to backpedal while deploying area-denial weapons. If the player damages the enemy to below 30% health, "Retreat to Rally Point" jumps to 0.91, and the soldier disengages to heal, creating dynamic combat that forces players to adapt their tactics.

Life Simulation and Social Behavior

Utility AI has proven particularly effective in life simulation games where NPCs must balance multiple competing needs and social dynamics ⁶. The bucketing approach pioneered by The Sims allows characters to prioritize survival needs while still engaging in social and entertainment activities when basic requirements are met.

Example: In a medieval village simulation, a blacksmith NPC balances work, social, and personal needs through utility AI. Each morning, the "Work at Forge" action scores highest (0.75) because the NPC's money is moderate and energy is high after sleeping. After four hours of work, hunger increases, pushing "Eat Meal" to 0.88, triggering a lunch break. During lunch at the tavern, the NPC's "Socialize with Present NPCs" action scores 0.62, leading to spontaneous conversation with a merchant, which might trigger a friendship development or business opportunity. As evening approaches and energy depletes, "Return Home to Sleep" gradually increases from 0.3 to 0.95 over several hours, creating natural daily rhythms without scripted schedules.

Strategic Decision-Making in Tactical Games

Military simulations and tactical strategy games employ utility-based AI for squad-level scenarios where autonomous virtual characters must make complex decisions under uncertainty ³. The Game AI Architecture (GAIA) framework provides a modular, hierarchical decision-making structure that allows selection of appropriate decision-making approaches for each specific decision point ³.

Example: In a real-time tactics game, a squad leader NPC commanding four soldiers uses utility AI to make strategic decisions during a building assault. The system evaluates options including "Breach Front Door" (utility 0.45—direct but dangerous), "Breach via Window" (utility 0.67—flanking advantage but requires climbing), "Suppress and Grenade" (utility 0.58—safe but uses limited resources), and "Call for Backup" (utility 0.71—safest but time-consuming). The utility functions consider squad health, ammunition, enemy strength estimates, mission time pressure, and available equipment. When one soldier is wounded, "Call for Backup" spikes to 0.89, but if mission time becomes critical, "Breach via Window" might override this at 0.93, demonstrating how utility AI weighs multiple strategic factors dynamically.

Dynamic Difficulty Adjustment

Utility AI enables sophisticated dynamic difficulty systems that modulate challenge by adjusting weights and utility thresholds in real-time based on player performance ². As players demonstrate skill, the system can increase enemy aggression weights or improve enemy utility function accuracy, creating adaptive difficulty without explicit difficulty settings.

Example: In a horror survival game, enemy creatures use utility AI with difficulty-adjusted parameters. When the player consistently evades enemies and maintains high health, the game increases the weight on aggressive actions from 1.0x to 1.4x and improves the accuracy of enemy perception systems, making creatures more relentless and perceptive. Conversely, if the player dies repeatedly in the same area, the system reduces aggression weights to 0.7x and slightly decreases enemy perception range, giving the player more opportunities to use stealth. These adjustments happen transparently, maintaining tension while preventing frustration, and because they modify utility weights rather than enemy health or damage, the difficulty adjustment feels organic rather than artificial.

Best Practices

Expose Parameters to Designers

Making utility weights, thresholds, and function parameters adjustable without code changes enables rapid iteration and allows non-programmers to tune NPC behavior ²⁵. This democratization of AI tuning accelerates the refinement process and empowers designers to experiment with behavioral variations.

Rationale: Game AI requires extensive playtesting and iteration to achieve the desired feel. When parameters are hardcoded, every adjustment requires programmer time, recompilation, and deployment, creating bottlenecks that slow development. Designer-accessible parameters enable immediate experimentation and faster convergence on optimal behavior.

Implementation Example: Create a data-driven utility system where each NPC archetype references a JSON or XML configuration file defining utility functions, weights, and thresholds. For a "Cautious Archer" enemy, designers can edit values like "retreat_health_threshold": 0.6, "aggression_weight": 0.7, and "cover_seeking_weight": 1.5 directly in the configuration file. Implement hot-reloading so designers can modify these files during play sessions and see behavioral changes immediately without restarting the game, enabling rapid iteration during playtesting.

Implement Comprehensive Logging and Visualization

Tools that display utility scores, selected actions, and decision rationale help designers understand and debug agent behavior ⁵. This transparency facilitates collaboration and problem-solving across disciplines by making the AI's "thought process" visible.

Rationale: Utility AI can produce unexpected behaviors when multiple factors interact in complex ways. Without visibility into why an NPC chose a particular action, debugging becomes guesswork. Visualization tools transform opaque decision-making into understandable data that designers and programmers can analyze collaboratively.

Implementation Example: Develop an in-game debug overlay that displays above selected NPCs showing: the top five actions with their current utility scores, the winning action highlighted in green, and a breakdown of contributing factors for the selected action. For instance, when observing a guard NPC, the overlay might show: "Investigate Sound: 0.87 (Sound Proximity: 0.9, Threat Level: 0.6, Curiosity: 0.8)" as the selected action, with "Patrol Route: 0.42" and "Return to Post: 0.31" as alternatives. Include a logging system that records decision history, allowing designers to scrub through gameplay timelines and understand why an NPC made a specific choice at a particular moment.

Start Simple and Iterate

Begin with straightforward utility functions and gradually add complexity based on observed behavior and design needs ¹. This approach prevents overwhelming complexity early in development and ensures each added layer of sophistication serves a clear purpose.

Rationale: Complex utility systems with many interacting factors are difficult to debug and tune. Starting simple establishes a working foundation that can be incrementally enhanced, making it easier to identify which additions improve behavior and which create problems.

Implementation Example: For a survival game's wildlife AI, begin with a single utility function per basic behavior: "Hunt" considers only hunger level, "Flee" considers only nearby threat presence, and "Rest" considers only energy level. Playtest this basic system to ensure the core loop functions correctly. Then incrementally add complexity: modify "Hunt" to also consider prey availability and hunting success rate; enhance "Flee" to evaluate threat severity and available escape routes; expand "Rest" to factor in safety of current location. Each iteration adds one or two factors, making it easy to identify if new complexity improves believability or creates problems.

Modular Task Systems

Organize actions into modular, reusable components that enable continuous addition of new behaviors as features expand ⁶. This architecture supports scalability and reduces technical debt as games grow in complexity.

Rationale: Games evolve throughout development, with new mechanics, items, and interactions added regularly. Monolithic utility systems become increasingly difficult to maintain as complexity grows. Modular architecture allows new actions to be added without refactoring existing code.

Implementation Example: Design a plugin-based action system where each action is a self-contained module implementing a standard interface with methods like CalculateUtility(GameState), GetRequiredResources(), and Execute(). When adding a new weapon type to an action game, create a new "UseFlamethrower" action module that calculates utility based on enemy clustering and fuel availability, registers itself with the action manager, and integrates automatically with existing NPCs without modifying their core AI code. This allows different NPC types to share action modules while maintaining distinct behavior through different weighting configurations.

Implementation Considerations

Tool and Format Choices

The selection of data formats and editing tools significantly impacts workflow efficiency and designer accessibility ². Utility AI systems benefit from human-readable data formats and intuitive editing interfaces that allow non-programmers to modify behavior parameters.

Considerations: Choose between code-based definitions (offering maximum flexibility but requiring programming knowledge), data files like JSON or XML (balancing readability with structure), or visual node-based editors (maximizing accessibility but potentially limiting expressiveness). Consider integration with existing game engines and asset pipelines, version control compatibility, and the technical proficiency of team members who will work with the system.

Example: A mid-sized studio developing a tactical RPG might implement utility AI using JSON configuration files for action definitions and weights, combined with a custom Unity editor window that provides a visual interface for designers. The JSON files remain in version control for tracking changes, while the editor window displays utility curves graphically, allows drag-and-drop weight adjustment, and provides real-time preview of how parameter changes affect NPC decision-making in test scenarios. This hybrid approach gives programmers direct file access when needed while providing designers with an accessible interface for common adjustments.

Performance Optimization Strategies

Calculating utilities dynamically during runtime imposes computational costs, particularly when many entities use utility systems simultaneously in complex scenes ¹. Implementation must balance behavioral sophistication with performance constraints.

Considerations: Evaluate whether to calculate utilities every frame or at intervals, implement caching strategies for expensive calculations, use bucketing to reduce the number of evaluated actions, employ spatial partitioning to limit perception system queries, and consider distributing calculations across multiple frames for non-critical NPCs.

Example: In an open-world game with potentially hundreds of active NPCs, implement a tiered update system: player-facing NPCs within 50 meters calculate full utility every frame for maximum responsiveness; NPCs between 50-100 meters use a bucketing system and update every 5 frames; distant NPCs beyond 100 meters use simplified utility functions with only 3-4 actions and update every 30 frames. Additionally, cache utility calculations for actions whose inputs haven't changed—if an NPC's health, position, and nearby threats remain constant, the "Seek Cover" utility score from the previous frame remains valid. This tiered approach maintains believable behavior for visible NPCs while preventing performance degradation from distant characters.

Balancing Autonomy and Narrative Control

Striking the right balance between agent autonomy and narrative control remains critical for maintaining immersive experiences without sacrificing story coherence ¹. Utility systems must allow NPCs to behave intelligently while respecting scripted story moments and designer intentions.

Considerations: Determine when NPCs should have full autonomy versus when narrative requirements override utility-based decisions, implement systems for temporarily constraining or biasing utility calculations during story sequences, and design utility functions that naturally align with narrative goals rather than fighting against them.

Example: In a story-driven action game, implement a "narrative constraint" system that can temporarily modify utility weights during scripted sequences. During a mission where a companion NPC must stay with the player for story reasons, the system multiplies the "Stay Near Player" action weight by 3.0 and sets a minimum utility floor of 0.6, ensuring the companion remains nearby even when their autonomous utility calculations might suggest other actions. However, if the player's health drops critically low, the constraint system allows the companion's "Provide Medical Aid" action to override the stay-near constraint, maintaining believability. After the scripted sequence concludes, constraints are removed and the NPC returns to fully autonomous decision-making.

Team Skill Distribution and Documentation

The effectiveness of utility AI implementation depends heavily on team members' understanding of the system and availability of clear documentation ². Consider the technical background of designers, programmers, and other stakeholders who will work with the system.

Considerations: Assess team members' mathematical and programming proficiency, provide appropriate training and documentation, create example templates and reference implementations, and establish clear workflows for collaboration between programmers who build the system and designers who tune behaviors.

Example: A studio implementing utility AI for the first time might create a comprehensive onboarding package including: a technical design document explaining the mathematical foundations for programmers, a designer-focused guide with visual examples showing how weight adjustments affect behavior, a library of pre-built utility function templates for common scenarios (health-based decisions, proximity-based actions, resource management), and recorded video tutorials demonstrating the workflow from creating a new action to tuning its parameters. Additionally, establish a weekly "AI review" meeting where designers present NPC behaviors they're struggling with, and programmers help diagnose whether issues stem from utility function design, weight tuning, or missing contextual information.

Common Challenges and Solutions

Challenge: Behavioral Loops and Erratic Actions

Poorly defined utility functions can lead NPCs into frustrating behavioral loops where they oscillate rapidly between actions or make contextually inappropriate decisions that undermine gameplay enjoyment ¹. This often occurs when utility scores for competing actions remain too close together or when utility functions don't account for action transition costs.

Real-world context: An enemy NPC might rapidly alternate between "Take Cover" and "Advance" every few frames because both actions score nearly identically (0.67 vs 0.65), creating jittery, unnatural movement. Alternatively, a civilian NPC might repeatedly enter and exit a building because the utility functions don't consider the effort of transitioning between states, making the character appear indecisive and breaking immersion.

Solution:

Implement hysteresis and action commitment mechanisms that prevent rapid action switching ¹. Add a "commitment bonus" that temporarily increases the utility of the current action by 0.1-0.2, requiring alternative actions to score significantly higher before triggering a switch. Include transition costs in utility calculations—if an NPC is currently taking cover, the "Advance" action should subtract a penalty (e.g., 0.15) representing the risk and effort of leaving cover, ensuring only substantially better opportunities trigger movement.

Example: For the oscillating enemy, add a 0.15 commitment bonus to the current action and a 0.1 transition penalty for switching to movement-based actions. Now "Take Cover" at 0.67 receives a 0.15 bonus (effective score 0.82), while "Advance" at 0.65 receives a -0.1 penalty (effective score 0.55), creating clear separation. The NPC will only abandon cover when "Advance" genuinely scores above 0.82, ensuring deliberate, purposeful behavior changes rather than nervous oscillation.

Challenge: Computational Performance with Multiple Agents

Calculating utilities for numerous actions across many simultaneous NPCs can create performance bottlenecks, particularly in complex scenes with dozens or hundreds of active agents ¹. Frame rate drops and gameplay stuttering result when utility calculations consume excessive CPU resources.

Real-world context: A strategy game with 50 active units, each evaluating 15 possible actions every frame, performs 750 utility calculations per frame. If each calculation involves multiple game state queries (distance checks, line-of-sight tests, pathfinding estimates), the cumulative cost can easily exceed the frame budget, causing noticeable performance degradation.

Solution:

Implement multi-tiered update frequencies, bucketing systems, and calculation caching ¹⁶. Use bucketing to reduce evaluated actions from 15 to 4-5 per decision cycle. Implement distance-based update frequencies where nearby NPCs update every frame while distant NPCs update every 10-30 frames. Cache expensive calculations like pathfinding estimates and reuse them until relevant game state changes. Distribute calculations across frames using a staggered update system where only a subset of NPCs calculate utilities each frame.

Example: Restructure the strategy game to use three-tier bucketing (reducing actions from 15 to 5 per evaluation) and staggered updates where NPCs are divided into five groups, with one group updating each frame. This reduces per-frame calculations from 750 to 50 (10 NPCs × 5 actions). Additionally, cache pathfinding distance estimates for 10 frames unless unit positions change significantly, and implement spatial hashing so NPCs only query nearby units rather than all 50 units when evaluating tactical actions. These optimizations reduce computational cost by approximately 85% while maintaining believable behavior.

Challenge: Difficulty Debugging Unexpected Behaviors

When NPCs make surprising or inappropriate decisions, identifying the root cause can be challenging because utility scores result from complex interactions between multiple factors ⁵. Without visibility into the decision-making process, developers resort to trial-and-error debugging.

Real-world context: A stealth game's guard NPC inexplicably ignores the player standing in plain sight, continuing a patrol route instead of investigating. The designer suspects a bug but cannot determine whether the issue stems from perception system failure, incorrect utility function weights, or unexpected interaction between multiple utility factors.

Solution:

Implement comprehensive logging and real-time visualization tools that expose the AI's decision-making process ⁵. Create debug overlays showing current utility scores for all evaluated actions, highlighting which factors contribute to each score and why the selected action won. Implement a historical logging system that records decision history, allowing developers to review past decisions and understand behavioral patterns over time.

Example: Add a debug mode that displays above the guard NPC: "Current Action: Patrol (0.58) | Investigate Player: 0.42 (Visibility: 0.8, Threat Assessment: 0.3, Alert Level: 0.2)". This immediately reveals the problem—despite high visibility (0.8), the threat assessment and alert level are unexpectedly low, preventing investigation. Further inspection shows the guard's "Alert Level" hasn't increased because the player entered the guard's vision during a scripted "relaxed" period that suppresses alertness. The visualization makes the root cause immediately apparent, enabling a quick fix by adjusting how scripted states interact with perception systems.

Challenge: Balancing Designer Control with AI Autonomy

Designers often want NPCs to behave autonomously and intelligently while also ensuring specific narrative moments or gameplay scenarios unfold as intended ¹. Pure utility-based autonomy can conflict with scripted story requirements, while heavy-handed overrides undermine the benefits of adaptive AI.

Real-world context: A narrative-driven game requires a companion NPC to stay near the player during a specific mission for story reasons, but the companion's utility AI keeps prioritizing other actions like investigating interesting objects or engaging distant enemies, breaking the intended experience.

Solution:

Implement a layered constraint system that can temporarily bias or bound utility calculations without completely overriding autonomy ¹. Use "soft constraints" that multiply specific action weights during narrative moments, and "hard constraints" that set minimum or maximum utility bounds for critical actions. Design utility functions to naturally align with narrative goals when possible, and reserve overrides for exceptional circumstances.

Example: During the story mission, activate a soft constraint that multiplies the companion's "Stay Near Player" weight by 2.5, making proximity significantly more attractive without completely eliminating other behaviors. Add a hard constraint that sets a minimum utility floor of 0.5 for "Stay Near Player," ensuring it never scores too low to be considered. However, allow critical actions like "Revive Downed Player" or "Defend Against Immediate Threat" to override these constraints when their utility exceeds 0.85, maintaining believability in emergency situations. This approach keeps the companion nearby as the narrative requires while preserving intelligent responses to unexpected gameplay situations.

Challenge: Creating Distinct NPC Personalities

Without careful design, NPCs using the same utility system can feel homogeneous, exhibiting similar behaviors and lacking distinct personalities that make individual characters memorable ². Simply adjusting weights may not create sufficiently differentiated behavior patterns.

Real-world context: A game features multiple enemy types that should feel distinct—aggressive berserkers, cautious snipers, and tactical squad leaders—but all enemies use the same utility functions with only minor weight variations, resulting in enemies that feel too similar in practice.

Solution:

Combine weight variations with personality-specific utility functions and behavioral constraints ². Create archetype-specific utility functions that evaluate actions through different lenses—berserkers might have utility functions that increase aggression as health decreases (opposite of typical behavior), while cautious characters might have functions that heavily penalize risk. Layer multiple differentiation techniques including unique action sets, distinct weight profiles, and personality-specific utility calculation modifiers.

Example: For the berserker archetype, implement a custom "Berserk Attack" utility function that increases as health decreases (inverting normal risk-aversion), with weights of 2.0x on all melee actions and 0.3x on defensive actions. For snipers, create a "Maintain Distance" utility function that heavily penalizes proximity to enemies, with 1.8x weights on ranged attacks and 0.5x on movement actions. For squad leaders, add unique actions like "Coordinate Team" and "Call Tactical Retreat" unavailable to other types, with utility functions that consider ally positions and status. These layered differences—unique functions, distinct weights, and exclusive actions—create genuinely distinct personalities that players can recognize and adapt to.

References

1. Oreate AI. (2024). Understanding Utility AI: A Game-Changer in Decision-Making for Video Games. https://www.oreateai.com/blog/understanding-utility-ai-a-game-changer-in-decisionmaking-for-video-games/3d50a78359746f9676b6c3c8199bb6db
2. ShaggyDev. (2023). Utility AI. https://shaggydev.com/2023/04/19/utility-ai/
3. Northeastern University. (2013). AI Game Engine Programming. https://course.ccs.neu.edu/cs5150f13/readings/dill_designpatterns.pdf
4. Smythos. (2025). Utility-Based AI Agents. https://smythos.com/managers/ops/utility-based-ai-agents/
5. YouTube. (2024). Utility AI Video Tutorial. https://www.youtube.com/watch?v=78AcS_0lQSM
6. Revolutionary Games Studio Forum. (2025). Utility AI: Restructuring the AI System. https://forum.revolutionarygamesstudio.com/t/utility-ai-restructuring-the-ai-system/919