Autonomous agents / Jan 2026 - Feb 2026
10-Agent AI Board Game Simulation
A hierarchical multi-agent simulation where autonomous AI characters coordinate through a shared game world while delegating dialogue and actions to specialized sub-agents.
Multi-agent Systems / Hierarchical Agents / Agent Orchestration / Structured JSON / Simulation
Highlights
- Designed a 10-agent hierarchy consisting of one Dungeon Master, three player agents, and specialized dialogue and action sub-agents.
- Separated high-level character decisions from specialized execution, allowing player agents to delegate different kinds of behavior.
- Converted agent decisions into structured JSON commands for movement, dialogue, combat, and world actions.
- Maintained a shared game state while autonomous characters made independent decisions based on their roles and personalities.
Problem
A multi-agent system becomes more interesting when agents are not simply generating independent responses.
They need to operate inside the same environment, reason from shared state, make their own decisions, delegate specialized work, and produce actions that another system can reliably execute.
I used a board-game simulation as a controlled environment for exploring those problems.
The game provides clear state, rules, characters, movement, interactions, and consequences, making it possible to see how a hierarchy of agents behaves as the world changes.
System design
The system is organized into multiple levels of responsibility.
At the top is a Dungeon Master agent, responsible for the overall game world and progression.
Three autonomous player agents represent individual characters. Each player maintains its own personality and makes high-level decisions based on the current game state.
Those player agents can delegate specific behavior to specialized sub-agents, including agents responsible for:
- Dialogue
- Actions
This separates questions such as:
What should my character do?
from:
How should that decision be expressed or executed?
The complete hierarchy contains ten agents operating around the same game simulation.
What I built
I built the orchestration and state system that allows these agents to participate in a shared world.
Player agents receive relevant game state and determine what their character should do next.
Specialized sub-agents convert those intentions into dialogue or executable game actions.
Rather than allowing agents to return unrestricted text for gameplay decisions, actions are represented as structured JSON commands.
Those commands can describe operations such as:
- Movement
- Combat
- Dialogue
- Interactions
- Changes to the game world
The simulation processes those actions and updates the shared state, which becomes context for the agents' next decisions.
This creates a loop:
shared state -> agent decision -> delegated action -> structured command -> world update -> new shared state
Why hierarchical agents?
I didn't want every agent responsible for every part of a character's behavior.
The player agent operates at a higher level: it decides what the character wants to do.
Specialized agents handle narrower responsibilities such as generating dialogue or expressing the chosen action in the format expected by the simulation.
That separation made the system useful for exploring a broader multi-agent design question:
When should one general agent do everything, and when should responsibility be delegated to specialized agents?
The board game provides a visible demonstration of that architecture because the results of delegation immediately affect a shared environment.
Technical focus
The main challenges were coordination, state, and reliable agent output.
Shared state
Agents operate independently, but they cannot each have a different understanding of the game world. Actions therefore need to update a common state that subsequent decisions can use.
Delegation
High-level player agents determine intent while specialized agents handle narrower behaviors, creating explicit parent/sub-agent relationships.
Structured actions
Free-form model responses are not sufficient for operating a game engine. Agent decisions therefore need to become predictable structured commands that application logic can validate and execute.
Together, those pieces turn the project from a collection of AI characters into a functioning hierarchical multi-agent system.