If you have been on “Tech Twitter” (or X) lately, you have probably seen the buzzword of 2025: “Agentic AI.”
Investors are throwing billions at it. Microsoft and Google are promising that “Agents” will revolutionize the workplace. The pitch is simple: Instead of a chatbot that just talks to you (like ChatGPT), an Agent can do things for you—book flights, debug code, or navigate a website.
As a game developer, I have to laugh a little bit.
Because if you strip away the Silicon Valley marketing, an “Autonomous Agent” is something we have been building for twenty years. We just call them NPCs (Non-Player Characters).
But here is where it gets interesting: The worlds of Game AI and Generative AI are finally crashing into each other. And the result is going to change both how we play games and how we build software.
The “Old Brain” vs. The “New Brain”
To understand why this matters, we need to look at how game characters used to think versus how they think now.
For decades, the standard for Game AI was the Finite State Machine (FSM) or the Behavior Tree.
- The Logic: IF player is within 5 meters -> THEN switch state to “Attack”.
- The Pro: It is fast, predictable, and gives the designer total control.
- The Con: It is rigid. If the player does something unexpected (like putting a bucket on the NPC’s head, Skyrim style), the AI breaks because it has no rule for “Bucket Head.”
Enter the LLM (Large Language Model) Agent.
When you plug a model like Llama 3 or GPT-4 into a game character, you aren’t just giving it a script; you are giving it a brain capable of improvisation.
Suddenly, the NPC doesn’t just check a distance variable. It assesses the vibe. It can decide to beg for mercy, lie to you, or form a complex plan that the developer never explicitly coded.
The Tech Stack: How It Actually Works
For the developers reading this, we aren’t just sending API calls to OpenAI for every frame (that would bankrupt you and kill your frame rate). The industry is moving toward Hybrid Architectures.
- The “Reasoning” Layer (LLM): This runs asynchronously. It handles high-level goals.
- Input: “Player is attacking me, and I am low health.”
- Output: “Retreat to the nearest cover and call for backup.”
- The “Action” Layer (Traditional Code): This runs every frame. It handles the execution.
- System: Uses standard Pathfinding (NavMesh) to actually move the character to the cover identified by the LLM.
Tools like Unity Sentis are now allowing us to run these “brains” locally on the player’s GPU, meaning no laggy internet calls and no massive cloud bills.
The “Hallucination” Problem
Here is the catch that tech evangelists often ignore: Unpredictability is fun in games, but fatal in software.
In a game, if an AI Agent “hallucinates” and decides to run into a wall because it thinks it’s a ghost, it’s a funny bug. Players might even love it. In a banking app, if an AI Agent “hallucinates” and transfers your money to the wrong account, it’s a lawsuit.
This is why Game Development is the perfect testing ground for Agentic AI. We are the sandbox. We can afford to let these agents fail, glitch, and do weird things in the name of “emergent gameplay.”
What You Can Do Right Now
If you are a dev looking to get ahead of this curve, stop building simple chatbots. Start building Stateful Agents.
- Download Unity Sentis or Godot 4: Learn how to run a small model (like TinyLlama) locally.
- Learn “Function Calling”: This is the bridge between the AI and your code. It’s how the AI presses the “Jump” button.
- Play with “Simulacra“: distinct agents with different personalities interacting with each other.
The future of software looks a lot like a video game: autonomous, interactive, and slightly chaotic. And for once, the game devs are the ones holding the map.
Leave a Reply