The enemy guard spots a dead body and just… walks past it. I’ve seen this failure mode in more games than I’d like to admit, including one I worked on early in my career. We had sophisticated patrol AI, decent combat behaviors, and even investigation routines. What we didn’t have was context awareness. The guard “knew” to patrol and “knew” to investigate suspicious sounds, but these behaviors existed in isolation. There was no understanding of the situation the context that made walking past a colleague’s corpse seem reasonable to the AI.
Context-based decision systems changed how I think about game AI. Instead of characters following rigid rules regardless of circumstances, they evaluate their situation and choose behaviors that make sense given what’s actually happening around them.
What Context Actually Means
In game AI, context is the collection of relevant information about the current situation: what’s happening, where it’s happening, who’s involved, what recently occurred, and what the character’s current state is. It’s the difference between “I should attack” and “I should attack because the enemy is wounded, I’m at full health, my allies are nearby, and we have the high ground.”
A context-based decision system considers this situational information when choosing actions. The same character might attack aggressively in one context, retreat in another, call for help in a third, or negotiate in a fourth not because they’re following different rules, but because the context makes different actions appropriate.
I worked on a survival horror game where enemy behaviors needed to feel threatening but fair. We built a context system that considered factors like: How much ammunition does the player have? How recently did they encounter enemies? What’s their health status? How many escape routes are available?
The same enemy type would behave completely differently based on this context. If the player was low on ammo and health with enemies recently encountered, our creatures became more cautious creating tension without overwhelming the player. If the player was well-stocked and confident, enemies were more aggressive. Same enemy, same basic AI, but context-aware decision-making created dynamic difficulty and better pacing.
Building Context: What Information Matters
The first challenge with context-based systems is determining what contextual information to track. Include too little and you’re back to rigid AI. Include too much and you’re drowning in data, plus performance tanks from constantly evaluating hundreds of factors.
I’ve learned to focus on actionable context information that should actually change behavior. For a combat AI, relevant context might include:
- Relative health (mine vs. enemy’s)
- Numbers advantage (outnumbered or superior force?)
- Tactical positioning (cover available, high ground, flanking opportunities)
- Recent events (just took damage, ally died nearby, hearing combat sounds)
- Resource status (ammunition, abilities on cooldown)
- Time in combat (just started vs. prolonged engagement)
For a stealth guard, completely different context matters:
- Alert level (unaware, suspicious, searching, confirmed threat)
- Last known player position and how recent
- Distance to other guards and communication status
- Area being guarded (high security vs. low priority)
- Time of day or shift status
- Recent suspicious events in the area
The key is matching tracked context to decisions the character needs to make. Don’t track information that won’t influence behavior it’s wasted CPU cycles.
Practical Implementation Patterns
Utility-based scoring with contextual modifiers is my most-used approach. Each possible action has a base utility score, then context factors multiply or add to that score.
For example, “Take Cover” might have a base utility of 5. But contextual modifiers adjust it:
- Low health: x2.0 (utility becomes 10)
- Under fire: x1.5 (multiplies again, now 15)
- No cover nearby: x0.1 (drops to 1.5)
- Allies suppressing enemy: x0.5 (down to 0.75)
The final contextual utility determines if taking cover makes sense right now given the current situation. Same character, same available actions, but radically different decisions based on context.
I’ve also used context-triggered behavior selection where reaching certain contextual thresholds switches between entire behavior sets. A squad-based tactical game I worked on had individual soldiers with three behavior modes: Standard Combat, Desperate, and Confident.
The mode depended on squad-level context overall health, number of active squadmates, mission success probability. In Confident mode (squad healthy, winning), soldiers took risks and pressed advantages. In Desperate mode (squad decimated, losing), they fought conservatively and prioritized survival. Same soldiers, same basic abilities, but context completely changed their tactical approach.
Blackboard systems work well for sharing context across multiple AI characters. It’s a shared data structure where characters write contextual information and read what others have written. One guard spots the player and writes “PlayerLastSeen: Location X, Time T” to the blackboard. Other guards read this and adjust their behavior they don’t need to see the player themselves to respond to the context of “player spotted nearby recently.”
This creates emergent coordination. Guards converge on last known positions, establish perimeters, search systematically all from individual context-aware decisions without explicit coordination AI.
The Perception Problem
Context-based decisions are only as good as the information characters have access to. You need perception systems that feed accurate contextual information to the decision-makers.
I spent weeks debugging why guards in a stealth game made stupid decisions before realizing the perception system wasn’t marking information with reliability or recency. Guards “knew” the player’s position, but that information might be five seconds old. They’d make aggressive decisions based on outdated context.
The fix was tagging all perceptual information with confidence and timestamps. “I saw the player at position X” (high confidence, current). “I heard a noise from direction Y” (medium confidence, 2 seconds ago). “Ally reported player near Z” (low confidence, 5 seconds ago). Decision-making used these confidence and recency values as contextual factors.
Characters could then make sensible context-based decisions: rush toward high-confidence recent sightings, cautiously investigate medium-confidence sounds, ignore low-confidence old information unless nothing better is available.
When Context Makes the Biggest Difference
Dynamic difficulty and pacing benefit enormously from context awareness. Left 4 Dead’s “AI Director” is famous for this spawning enemies and items based on contextual evaluation of player stress, recent challenges, and current capabilities. Players rarely notice the manipulation because it feels natural; the game is reading the room and responding appropriately.
Social and squad AI becomes exponentially more believable with context awareness. Instead of allies just following scripted routines, they respond to what’s actually happening. An ally who calls out different tactical advice based on the combat context (flanking opportunities, dangerous enemies, resource scarcity) feels like a genuine teammate rather than a recording.
Stealth gameplay demands context awareness. Guards need to respond to the accumulation of suspicious events one weird noise might get investigated, but three in five minutes should trigger an alert. Players feel smart when they can manipulate context (create distractions) to enable infiltration.
I worked on a heist game where guard behavior was entirely context-driven. They had individual suspicion levels that rose based on contextual events: doors left open, colleagues not responding to radio, areas they couldn’t access, missing valuables. Accumulating suspicious context gradually shifted them from routine patrols to heightened alertness to full lockdown, all without rigid triggers.
The Debugging Nightmare
Context-based systems are phenomenally difficult to debug because behavior emerges from combinations of factors rather than simple cause-and-effect. A character does something weird, and you need to figure out which contextual factors combined to make that action seem like a good idea.
I now consider robust debugging tools mandatory for context-based AI. At minimum:
- Visual display of all contextual factors the character is currently aware of
- Utility scores for available actions showing how context modified them
- Decision history showing what context looked like when past decisions were made
- Ability to manually set context values to reproduce specific scenarios
For one project, we built a “context replay” system that could reconstruct the exact contextual state at any moment and step through decisions frame-by-frame. Debugging time dropped by probably 70% once we had that tool.
Balancing Complexity and Performance
Every contextual factor you evaluate costs CPU time. A utility system considering 20 contextual factors for 10 possible actions across 50 characters adds up fast.
Staggered evaluation helps not every character needs to make context-aware decisions every frame. Important characters near the player evaluate frequently (10-20Hz), background characters much less often (1-2Hz).
Context caching where you store processed contextual conclusions rather than re-evaluating raw data constantly. Instead of checking “are any allies nearby?” every update, maintain a cached count updated only when allies move significantly.
Simplified context for distant characters. Full contextual decision-making for close enemies, simplified rule-based behavior for distant ones. Players can’t observe nuanced context-aware behavior from 100 meters away anyway.
Final Thoughts
Context-based decision systems are the difference between AI that follows orders and AI that seems genuinely intelligent. Characters that respond appropriately to circumstances feel more believable, create better gameplay moments, and surprise players in good ways.
Start simple: identify three to five key contextual factors that should influence your AI’s biggest decisions, and build from there. Don’t try to create a perfectly context-aware system from day one you’ll either never finish or create something unmaintainable.
The goal isn’t perfect simulation of intelligence. It’s creating the illusion that characters understand what’s happening around them and respond sensibly. That’s achievable with focused, well-designed context-based systems, and it makes all the difference in how players perceive your AI.
Frequently Asked Questions
What’s the difference between context-based AI and scripted AI?
Scripted AI follows predetermined rules regardless of situation. Context-based AI evaluates current circumstances and adapts behavior accordingly, making the same character act differently in different situations.
Does context-based decision-making hurt performance?
It can if poorly implemented. The key is tracking only relevant context, using efficient evaluation methods (utility scoring), and updating less frequently for less important characters. When done right, the performance cost is manageable.
How do I know what context factors to track?
Focus on information that should change decisions. If knowing X doesn’t make a character behave differently, don’t track it. Start with 3-5 key factors and expand only when you need more nuance.