Artificial Intelligence in Video Games: How Do Characters Really Think?

When can we really say that a game character has AI?

A guard patrols a corridor. When they spot the player, they abandon their route, move closer, take cover when fired upon, and eventually return to patrol once the danger has passed. We instinctively tend to say that this character is controlled by artificial intelligence.

Yet nothing requires that guard to learn, reason like a human, or even use a neural network. Their entire behavior may rely on a series of rules written in advance by developers.

That is one of the particularities of the term artificial intelligence in video games. It has a much broader meaning than in contemporary discussions around ChatGPT, large language models, or machine learning. In game development, the term traditionally covers systems that allow a character or part of the game to perceive a situation, select a behavior, and act without being directly controlled by the player.

A character therefore does not need to learn in order to have game AI. It is already enough for them to choose a behavior according to the state of the world.

This definition opens up a very large field. Finding a route, choosing a target, deciding when to attack, coordinating a squad, adjusting the pacing of a match, generating a level, or learning a strategy can all involve techniques associated with artificial intelligence.

The real question is not whether the character “thinks.” It is understanding how the game creates the impression that the character understands what is happening.

---

Game AI begins with simple rules

The earliest video games had very little memory and computing power. Enemy behavior therefore had to remain extremely simple, but that does not mean it was necessarily random.

In Space Invaders, enemies follow a collective organization defined by the program. In Pac-Man, the ghosts use distinct routines that help give each of them recognizable behavior. Toru Iwatani would later explain that the ghosts were designed with independent routines and different personalities.

The fundamental principle is already there: a carefully chosen rule can produce behavior that appears intentional.

An enemy does not need to construct a philosophical model of the player. It can simply compare positions, check a distance, detect a collision, or change direction according to a few conditions. The result becomes interesting when those rules interact with an environment and with the unpredictable decisions of a human player.

Behavior can be simple without being trivial

Imagine an enemy with only three rules:

If the player is not visible → patrol
If the player is visible and far away → chase
If the player is visible and close → attack

This logic is rudimentary. Yet placed inside a level containing obstacles, several routes, animations, sound, and opportunities to escape, it can already create the impression of an opponent capable of changing intentions.

A large part of the history of game AI consists of making this kind of decision more flexible, better organized, and more believable.

---

Pathfinding: knowing where to go before deciding what to do

A character may decide to chase the player without knowing how to reach them.

That is the problem of pathfinding. The environment is represented in a form the algorithm can use — grid, graph, navigation mesh, or another structure — so that it can find a route between a starting position and a destination.

The A* algorithm became one of the most important historical references in this field. It explores possible paths while taking into account both the cost already traveled and an estimate of the remaining cost to the target. In a game, this can allow a unit to move around a building instead of simply walking in a straight line into a wall.

But two different problems need to be separated.

This distinction is fundamental. Finding the best route to a door does not explain why the character wants to open that door. A believable AI therefore often combines several layers: perception, decision-making, navigation, and movement.

Modern engines automate part of this work with navigation meshes, which represent the walkable areas of a level and allow characters to calculate routes that respect the geometry of the world.

---

State machines give behavior a structure

As characters begin to gain more behaviors, a long sequence of conditions becomes difficult to organize. Developers therefore commonly use Finite State Machines.

The character can have several possible states:

• patrol;
• investigate;
• chase;
• combat;
• flee.

They are generally in only one main state at a time, and conditions determine when transitions occur.

A simple guard AI might look like this:

PATROL
   │ player spotted
   ▼
CHASE
   │ player close enough
   ▼
COMBAT
   │ player lost
   ▼
SEARCH
   │ no trace found
   ▼
PATROL

This architecture has an obvious advantage: the behavior becomes readable to the people designing it. Each state has its own rules, and the transitions explain why the character changes activity.

It also has a limitation. As states and exceptions multiply, the connections can become difficult to maintain. A character capable of patrolling, fighting, looking for cover, protecting an ally, avoiding a grenade, reloading, and reacting to several events at once requires a more flexible organization.

State machines have not disappeared, however. Unreal Engine still provides StateTree, a hierarchical system that combines states and transitions with ideas inherited from behavior trees. These techniques therefore tend to evolve through combination rather than replacement.

---

Behavior trees organize more complex decisions

Behavior trees have become one of the best-known tools in modern game AI.

Instead of organizing behavior mainly as a network of connected states, they build a hierarchy of goals, conditions, and actions. The system traverses the tree to determine which branch should be executed.

A simplified behavior might follow this logic:

ENEMY
├── If immediate danger
│   └── Find cover
├── If player visible
│   ├── If weapon loaded
│   │   └── Attack
│   └── Otherwise
│       └── Reload
└── Otherwise
    └── Patrol

Unreal Engine notably uses Behavior Trees together with a Blackboard. The Blackboard stores information required for decision-making: player position, presence of a target, last known location, state of a door, or any other useful data.

This separation makes it possible to distinguish what the character knows from what they decide to do with that information.

Behavior trees are not inherently intelligent. They remain an organization of rules written by designers. Their value lies in their ability to manage complex behavior in a more modular and understandable way.

---

Perceiving the world before reacting to it

An AI-controlled character generally should not have access to every piece of information contained in the game.

If they know exactly where the player is while the player is standing behind three walls, they do not seem intelligent. They seem to be cheating.

Perception systems therefore define what the agent is allowed to know. A character may have a field of view limited by angle and obstacles, react to sounds, remember the player’s last known position, or receive information when taking damage.

Unreal Engine, for example, separates several responsibilities between its perception system, Behavior Trees, and the Environment Query System. The latter can query the environment to answer questions such as: which location offers the best cover? Where is the nearest resource? Which position keeps the agent away from the player while preserving a line of fire?

This architecture can be summarized like this:

A character’s sophistication often comes less from one miraculous algorithm than from the quality of the exchanges between these different layers.

---

Good AI is not AI that always wins

This distinction is essential in video games.

A perfectly efficient opponent could instantly aim at the player’s head, know every position, exploit every weakness in the system, and always make the mathematically optimal decision. It would probably be highly effective.

It would also often be unbearable to fight.

Game AI therefore pursues a different objective from a program designed only to maximize performance. It must contribute to an experience that is interesting, readable, and sufficiently fair.

The best opponent is not the one that plays perfectly. It is the one whose behavior produces an interesting match.

For this reason, designers deliberately introduce limitations: reaction time, imperfect accuracy, reduced perception, mistakes, hesitation, or visual cues that allow the player to anticipate an attack.

Perceived intelligence often depends on this readability. An enemy that makes an excellent decision without the player understanding why may feel arbitrary. A slightly less efficient opponent whose intentions remain visible can appear far more believable.

---

AI can also control the game itself

Not every AI system corresponds to a character.

Left 4 Dead provides one of the most famous examples with its AI Director. Rather than directly controlling a particular zombie, this system observes the state of the game and influences its overall pacing.

Valve explains that the Director estimates, among other things, a form of “intensity” experienced by the survivors. When pressure becomes high, the system can temporarily reduce threats. In other situations, it increases the enemy population to create new peaks of tension.

The goal is therefore not simply to make the game more difficult. The system tries to create an alternation between periods of pressure and moments of recovery.

This distinction matters:

AI can control a character, but it can also control pacing, staging, or certain conditions of an entire match.

In Left 4 Dead, this principle also contributes to replayability. The same maps can produce different encounters because enemy populations and certain events are not completely fixed.

AI then becomes a form of algorithmic director.

---

Procedural generation and AI are not exactly the same thing

The two concepts are often associated because they can use some of the same techniques.

Procedural Content Generation, or PCG, consists of creating game content algorithmically with limited or indirect human intervention. This can include levels, maps, objects, quests, textures, systems, or other elements.

A dungeon generator may automatically assemble rooms according to a set of rules. An open world may distribute vegetation procedurally. A game may generate new maps for each run from a seed.

That does not necessarily mean the system “learns.”

Generation can be entirely deterministic and based on hand-written rules. Conversely, some PCG research does indeed use methods drawn from artificial intelligence or machine learning.

Three concepts worth distinguishing

These categories can overlap, but they are not synonymous.

---

Machine learning changes a fundamental rule: behavior can be learned

The systems described so far mainly operate with rules and structures explicitly designed by humans.

Machine learning introduces a different approach. Instead of directly writing every decision, a model can be trained to produce behavior from examples or experience.

Unity ML-Agents illustrates this principle well. Its environment allows developers to create agents that observe a situation, choose actions, and then be trained using techniques such as reinforcement learning.

In this framework, an agent generally receives:

1. observations about its environment;
2. a set of possible actions;
3. a reward signal indicating whether certain consequences are desirable.

The algorithm gradually searches for a decision policy that accumulates more reward.

A character can therefore learn to move, control a physical object, or cooperate inside a simulation without every possible situation being individually coded.

This method also has a cost. Training takes time, the resulting behavior may be harder to predict, and debugging does not always offer the clarity of an explicitly constructed behavior tree.

That is why machine learning has not simply replaced traditional techniques.

---

Games remain full of “classic” AI for good reasons

A state machine has one extraordinary quality for a development team: it is generally possible to understand why it changed state.

A behavior tree also makes it possible to observe which branch is being executed. Engines provide debugging tools specifically designed to visualize behavior, Blackboard data, or perception information in real time.

This predictability is valuable.

A studio needs to reproduce bugs, balance encounters, guarantee that a character respects certain rules, and prevent a system from producing behavior that conflicts with the story.

Machine learning becomes especially interesting when the decision space is difficult to describe manually or when learning adds a specific value. It is not automatically superior when a classic rule solves the problem cleanly.

In game development, the best technology is often the one whose behavior is good enough, controllable enough, and compatible with production constraints.

---

Generative AI adds language and dynamic production

The arrival of large language models and other generative models introduces a new layer.

A character can now produce a response that was not written word for word inside a dialogue tree. It can receive information about its role, its environment, and the conversation, then generate a response adapted to the context.

Current systems go further by combining several models: speech recognition, language models, speech synthesis, facial animation, and access to selected game-state information.

In 2026, NVIDIA presents ACE as a collection of technologies intended for conversational and autonomous characters. Projects are now experimenting with companions capable of receiving a natural-language instruction, interpreting the game state, and then producing a response or selecting an action.

But one technical detail is particularly revealing: generative models do not necessarily replace traditional gameplay AI.

In the architecture presented in 2026 for PUBG Ally, the player’s voice is transcribed, a small language model interprets the request and the state of the match, and gameplay actions are then passed to traditional systems. A behavior tree notably continues to handle fast reactions that cannot wait for linguistic reasoning.

The result is a hybrid architecture:

Player
  ↓
Language / voice
  ↓
Generative model
  ↓
Intent or high-level decision
  ↓
Behavior tree / gameplay systems
  ↓
Navigation · animation · actions

This organization summarizes the recent evolution of game AI quite well: new technologies complete existing layers instead of rebuilding the entire character around one model.

---

Free-form conversation also creates new problems

Traditionally written dialogue can be reviewed, tested, localized, and approved before release.

A response generated in real time does not offer the same level of predictability.

Developers therefore have to deal with new questions: how do you prevent a character from contradicting the story? How do you restrict its knowledge to what it is supposed to know? How do you preserve its personality? How do you prevent inappropriate responses? How do you maintain acceptable latency? What happens when the player asks it to do something the gameplay system cannot actually execute?

These constraints explain why generative architectures are often surrounded by rules, structured context, and traditional systems.

The model may suggest or interpret an intention, but the game still needs to verify that this intention corresponds to a valid action.

This distinction between speaking freely and acting freely inside a game system will probably become one of the major design topics of the coming years.

---

So when can we really call something artificial intelligence?

There is no single technical boundary clearly separating “real AI” from a simple script.

In game development practice, the term AI has long been used whenever a system automatically selects behaviors according to information about its environment or the state of the game.

That definition therefore includes very different techniques.

The term “artificial intelligence” therefore describes a family of techniques, not a level of consciousness.

A Pac-Man ghost and a character using a language model both belong to this history, even though the complexity of their systems obviously has very little in common.

---

The player judges the result, not the algorithm

There is one final interesting paradox.

A technically complex system can produce a character the player considers stupid. Conversely, a few simple rules can create a remarkable impression of personality if they are well integrated with gameplay, animation, and level design.

Perceived intelligence depends in particular on the character’s ability to react coherently, communicate intentions, account for the environment, and respect the rules the player believes they have understood.

An enemy that intelligently takes cover while leaving half its body sticking out from behind the wall will seem clumsy. A companion capable of generating sophisticated conversation but unable to navigate around a closed door will quickly break the illusion.

That is why game AI cannot be isolated from the rest of the production pipeline. Navigation, animation, level design, audio, interface, and game design all directly influence how its behavior will be perceived.

---

From written rules to hybrid agents

The evolution of artificial intelligence in video games ultimately does not resemble a sequence in which each new technology eliminates the previous one.

Pathfinding remains essential despite machine learning. State machines continue to exist alongside behavior trees. Procedural systems still use deterministic rules. Generative models are now being integrated into architectures that retain traditional navigation, perception, animation, and gameplay logic.

This accumulation exists for a simple reason: these tools do not solve the same problems.

Pathfinding finds a route. A state machine organizes situations. A behavior tree chooses actions. A Director controls pacing. Machine learning can learn a policy. A generative model can interpret or produce language and new content.

The most likely future is therefore not a character entirely controlled by one enormous intelligence. It looks more like an assembly of specialized systems communicating with one another.

That also gives us an answer to our opening question. When a game character appears intelligent, there is usually no small digital brain hidden behind its face. There is an architecture of perception, rules, memory, navigation, and decision-making coherent enough to create that impression.

And in a video game, that carefully controlled illusion is often exactly what we need.