The Arai System is a modular AI Co-Pilot designed to enhance player experiences in various games by providing intelligent, context-aware assistance. Arai is a general-purpose gaming framework, and is particularly suited for simulation and strategy games (SLGs), though its flexible design supports adaptation to other genres.
Unlike traditional game AI, which often relies on fixed scripts or behavior trees, Arai integrates an Entity-Component-System (ECS) architecture, a Model Context Protocol (MCP) for communication, a sandbox environment for simulations, and large language models (LLMs) for advanced decision-making. Arai’s Copilots are autonomous, memory-enabled, and capable of economic reasoning, setting them apart from conventional AI systems.
In games with complex decision-making, such as resource management or strategic planning, players often face significant cognitive demands. Arai addresses this by offering actionable recommendations that simplify choices while preserving player control. For example, in a game involving kingdom management, Arai might analyze resources, suggest allocation options, and simulate outcomes in a sandbox.
This article outlines Arai’s architecture, implementation, and potential benefits, targeting developers building interactive games and players seeking supportive gameplay tools.
The Entity-Component-System (ECS) architecture is a data-driven design pattern widely used in game development for its scalability and modularity. Entities act as unique identifiers, components store data (e.g., position, resources), and systems execute logic (e.g., movement, resource management).
This separation supports efficient state management, crucial for games with numerous entities. For instance, Unity’s Data-Oriented Technology Stack (DOTS) and the Bevy engine utilize ECS to enable complex simulations with minimal overhead.
Arai employs ECS to manage game state and AI logic, allowing modular AI integration without altering core game code. Unlike traditional object-oriented designs, where AI is tightly coupled to objects, ECS enables Arai’s AI systems to target specific components (e.g., resource data), ensuring flexibility across various game types.
Traditional game assistants, such as finite state machines or behavior trees, excel in predictable scenarios but falter in dynamic, open-ended environments. For example, in a trading game, behavior trees may struggle to adapt to sudden market shifts caused by player actions. Large language models (LLMs) address this by reasoning over complex states, though their real-time integration poses challenges due to latency and computational demands.
Arai combines ECS’s efficiency with LLMs’ reasoning capabilities. The Model Context Protocol (MCP) facilitates effective communication between game engines and AI agents, while the sandbox environment supports safe decision simulations, delivering tailored assistance in dynamic settings.
Sandbox environments offer an isolated space for testing game scenarios, vital for AI-driven simulations. Arai’s sandbox enables both player experimentation (e.g., testing layouts) and AI analysis (e.g., evaluating strategies).
The Model Context Protocol (MCP) manages communication between game clients, AI agents, and the sandbox via WebSocket, ensuring efficient, asynchronous updates across components.
Arai integrates ECS, LLMs, and sandbox concepts into a flexible Co-Pilot framework applicable to a wide range of games. Unlike prior work focused on single-game AI or generic LLM uses, Arai offers a modular, adaptable solution that balances performance, scalability, and player engagement. It provides developers with a reusable tool to enhance gameplay across diverse titles.
The Arai System consists of four core components: the Game Adapter, MCP Server, Sandbox Environment, and AI Agent. These work together to provide real-time, context-aware AI assistance, as shown:
Game Adapter: Acts as the MCP Client, interfacing with the game engine to extract state (e.g., resources, units) and relay AI recommendations. It is a lightweight module compatible with ECS-based engines like Unity DOTS or Bevy.
MCP Server: Manages communication between the Game Adapter, Sandbox, and AI Agent using WebSocket for asynchronous updates, designed to scale with multiple game instances.
Sandbox Environment: Offers an isolated space for simulating scenarios, supporting AI analysis (e.g., strategy testing) and player experimentation, mirroring the game’s ECS structure.
AI Agent: Utilizes an LLM for autonomous, memory-based decision-making, analyzing game state, and simulating outcomes in the Sandbox for context-aware recommendations.
The Arai System follows a structured workflow to provide context-aware assistance. Each step in the data flow is designed to ensure seamless interaction between components while maintaining strict separation from direct game state changes.
1) State Fetching: The AI Agent uses tools provided by the Model Context Protocol (MCP) to retrieve the current player state (e.g., resource levels). This may involve calling game backend APIs via the MCP Server, which interfaces with the Game Adapter to access game engine data through WebSocket.
2) Player Interaction and Analysis The player interacts with the AI Agent, expressing specific needs or goals. The Agent analyzes these inputs alongside the fetched state and numerical data to determine the most suitable action path and establish a task flow.
3) Task Execution and Simulation The AI Agent executes the task flow step-by-step using the MCP-provided tools. These tools may simulate player actions or interface with the game backend for operations. Meanwhile, the Sandbox Environment primarily serves to simulate and demonstrate the execution process.
4) Recommendation Generation During analysis and execution, the AI Agent relies on MCP tools, critical data from the Game Adapter (e.g., game-specific fields and explanations), and its knowledge base to create actionable recommendations (e.g., “Increase resource production”).
5) Recommendation Delivery The MCP Server relays the recommendations to the Game Adapter for display (e.g., via UI prompts). Importantly, the Arai System does not alter game state; actual changes occur exclusively on the game backend server, either through player action or tasks executed via MCP tools interfacing with backend APIs.
In a resource management game, the AI Agent fetches resource data using MCP tools. After player interaction, it analyzes the state, builds a task flow to optimize production, simulates the process in the Sandbox for demonstration, and provides a suggestion. The game state remains unchanged until actions are executed on the game backend server, ensuring Arai’s role as a supportive tool.
In a game where players manage a settlement, the Game Adapter extracts components like ResourceComponent (food, gold) and sends them to the MCP Server. The AI Agent analyzes the state, simulates a strategy in the Sandbox (e.g., allocating workers), and suggests: “Build additional production facilities to prevent shortages,” displayed via the UI.
# Example Game Adapter pseudocode
class GameAdapter:
def __init__(self, websocket_url):
self.client \= WebSocketClient(websocket\_url)
self.ecs\_world \= GameEngine.get\_ecs\_world()
async def send_state(self):
resources \= self.ecs\_world.get\_components(ResourceComponent)
state \= {"resources": resources.to\_json()}
await self.client.send(state)
async def receive_recommendation(self):
recommendation \= await self.client.receive()
GameUI.display(recommendation\["text"\]) \# e.g., "Build additional production facilities"
Arai’s architecture aims to be scalable and practical for commercial games. WebSocket supports efficient communication for asynchronous mechanics, and the ECS-based Sandbox minimizes overhead by mirroring game state. The MCP Server allows horizontal scaling for multiple players, while the AI Agent’s LLM is optimized for batch processing to manage latency. These choices strive to make Arai suitable for mid-to-large-scale games.
The Arai System leverages the Entity-Component-System (ECS) architecture due to its scalability and modularity, making it ideal for integrating autonomous AI Co-Pilots in simulation and strategy games (SLGs).
In ECS, entities are unique identifiers, components store data (e.g., resource levels), and systems execute logic (e.g., resource allocation). This separation decouples game state from behavior, enabling Arai to insert AI logic as independent systems without modifying core game code. ECS enables autonomous Copilots by efficiently managing memory and economic components, aligning with Arai’s vision of memory-rich, economically active AI agents.
Unlike traditional object-oriented designs (OOP), where AI is often entangled with game objects, ECS allows Arai to process only relevant data (e.g., resource components), minimizing overhead and supporting SLGs with thousands of entities. ECS’s cache-friendly design further ensures high performance, critical for real-time state management in dynamic game environments.
Arai integrates AI through ECS system hooks—specialized systems that query components and trigger Co-Pilot actions. For example, a ResourceMonitorSystem analyzes ResourceComponent data to detect shortages and sends alerts to the Model Context Protocol (MCP) Server.
A concrete example is: if resources.gold < 100, the system sends a “Trade for gold” alert to guide player decisions. These hooks are lightweight, targeting specific components, and modular, allowing developers to customize AI behavior for diverse SLGs.
# Example ECS AI System Hook
class ResourceMonitorSystem:
def __init__(self, ecs_world, mcp_client):
self.ecs\_world \= ecs\_world
self.mcp\_client \= mcp\_client
async def update(self):
resources \= self.ecs\_world.get\_components(ResourceComponent)
if resources.gold \< 100:
await self.mcp\_client.send({"type": "alert", "message": "Trade for gold to boost economy"})
Arai synchronizes game state between the game engine and the Sandbox Environment using ECS’s component-based structure. The Game Adapter serializes relevant components (e.g., ResourceComponent: { food: 150, gold: 300 }) into JSON and sends them via WebSocket to the MCP Server.
This ensures the Sandbox mirrors the live game state, enabling accurate AI simulations. ECS’s modularity allows selective serialization, reducing data transfer and supporting SLGs with asynchronous mechanics.
In an SLG where players manage a trading empire, Arai’s TradeAnalysisSystem queries TradeRouteComponent data to identify inefficiencies. It sends this data to the AI Agent, which simulates alternative routes and suggests: “Redirect caravans to Port City for higher profits.” This integration requires minimal ECS systems, preserving the game’s existing architecture while enhancing player decision-making.
Developers register their SLG with the MCP Server, providing an ECS component schema (e.g., ResourceComponent: { food: int, gold: int }) and a knowledge base of game rules (e.g., “Farms produce 10 food per turn”).
Arai System is also optimized for Web3-enabled games, the schema may include a TokenComponent for blockchain assets, ensuring compatibility with decentralized mechanics. This one-time setup, implemented via a REST API, enables the AI Agent to understand game mechanics and state structure.
# Example Game Registration
async def register_game(mcp_server_url):
schema \= {
"components": {
"ResourceComponent": {"food": "int", "gold": "int"},
"TokenComponent": {"asset\_id": "string", "value": "int"},
"BuildingComponent": {"type": "string", "output": "int"}
},
"rules": \["Farms produce 10 food per turn", "Gold funds buildings"\]
}
await http_client.post(f"{mcp_server_url}/register", json\=schema)
The AI Agent’s knowledge base is a structured repository of game rules, player preferences (e.g., “Prioritize economy”), and historical data (e.g., resource trends). It leverages memory of past states, such as resource shortages, to inform strategies. Stored as a graph database, it enables fast queries by the LLM.
The MCP Server updates the knowledge base with real-time game data, ensuring recommendations remain relevant and context-aware.
The Game Adapter, acting as the MCP Client, uses WebSocket for asynchronous communication with the MCP Server. It sends game state (e.g., ECS component data) and receives AI recommendations, which are displayed via the game’s UI.
The client is a lightweight library compatible with ECS-based engines like Unity DOTS or Bevy, optimized for low-latency SLG mechanics.
The AI Decision-Making process is central to Arai’s Co-Pilot functionality, delivering context-aware, actionable recommendations through a closed-loop system. It involves four stages, executed by the AI Agent (powered by an LLM) in coordination with the MCP Server and Sandbox Environment:
1) State Acquisition: The AI Agent uses tools provided by the Model Context Protocol (MCP) to fetch serialized ECS component data (e.g., { "food": 150, "gold": 300, "buildings": [{"type": "farm", "output": 10}]}), potentially via game backend APIs accessed through the MCP Server and Game Adapter.
It queries the knowledge base and Game Adapter data (e.g., field explanations) to contextualize the state, identifying critical factors (e.g., low food relative to population growth).
2) Task Flow Generation: After interacting with the player to understand their needs, the AI Agent, using an LLM, infers the most suitable action path based on game rules, player goals, and current state, establishing a task flow (e.g., “Build two farms”).
3) Execution and Simulation: The AI Agent executes tasks step-by-step using MCP tools, which may interface with the game backend for operations, while the Sandbox Environment is used primarily to simulate and demonstrate the execution process and predict outcomes (e.g., food increase after building farms).
4) Recommendation Delivery: The AI formats an actionable suggestion (e.g., “Build two farms near the river to address food shortage”) and sends it to the MCP Server for relay to the Game Adapter as a UI prompt. The Arai System does not directly update game state; changes occur only on the game backend server, either through player action or backend operations triggered via MCP tools.
Player Action: The player accepts the recommendation via the UI (e.g., clicking “Build Farms”), triggering the game backend server to update the ECS state (e.g., adding two BuildingComponent entities). Alternatively, certain tasks may be executed directly via MCP tools interfacing with backend APIs.
State Update: The Game Adapter or MCP tools fetch the updated state from the backend and send it to the MCP Server, refreshing the knowledge base for the AI Agent.
Feedback Loop: The AI Agent analyzes the updated state to refine future recommendations or task flows (e.g., “Focus on gold production next”), ensuring alignment with player goals.
Error Handling: If a task or action fails (e.g., insufficient gold), the AI logs the issue using MCP tools and suggests an alternative (e.g., “Sell excess wood to fund farms”).
Recommendations are displayed via a customizable UI, such as a Co-Pilot panel or in-game tooltips.
A provided SDK allows developers to style prompts (e.g., “Build two farms [Accept/Ignore]”) to match the game’s aesthetic. The UI is non-intrusive, ensuring players retain control while benefiting from AI guidance.
The Sandbox Environment is a critical component of Arai’s AI-driven simulations, providing an isolated ECS instance that mirrors the game’s state and rules. It is primarily used to simulate and demonstrate the execution of task flows and strategies, such as resource allocation or economic decisions, without impacting the live game, ensuring accurate visualization of potential outcomes.
The Sandbox supports demonstration of economic strategies, like resource trading, to illustrate outcomes, aligning with Arai’s focus on economically aware Co-Pilots. While it can also facilitate player experimentation (e.g., testing building layouts), its main role in Arai is to provide a simulated environment for the AI Agent to showcase task execution and predicted results, complementing the actionable recommendations delivered to players.
The Sandbox is initialized with the game’s registered ECS schema and rules, hosted alongside the MCP Server. It uses a lightweight ECS instance to replicate only the necessary game state, minimizing resource usage.
The Sandbox receives game state updates via WebSocket and simulates outcomes using the same logic as the game engine. For example, in a medieval SLG, it simulates the impact of building farms on food production, ensuring efficient processing for scalability. This lightweight design addresses potential developer concerns about computational overhead.
In a kingdom-management SLG, the player faces a food shortage ({ "food": 150, "gold": 300 }). The AI Agent, recalling past shortages from its memory, proposes building two farms and tests this in the Sandbox:
Input State:
{
"food": 150,
"gold": 300,
"buildings": [
{
"type": "farm",
"output": 10
}]
}
Simulation: The Sandbox adds two BuildingComponent entities (farms), costing 200 gold, and predicts food increasing to 350 after 3 turns (10 + 20 units/turn).
Output: The AI Agent recommends: “Build two farms near the river to resolve food shortage in 3 turns.” This recommendation is sent to the game’s UI, where the player can accept it, updating the live game state.
This example demonstrates the Sandbox’s role in enabling precise, memory-informed AI guidance, reinforcing Arai’s vision of memory-rich Copilots.
This scenario demonstrates Arai’s application in a game where players manage a settlement facing a resource shortage. It highlights how the Game Adapter, MCP Server, Sandbox Environment, and AI Agent collaborate to provide actionable recommendations, adaptable to various game types.
The settlement’s state includes:
ResourceComponent: { "food": 100, "gold": 400 }
BuildingComponent: [{ "type": "farm", "output": 10 }, { "type": "mine", "output": 20 }]
PopulationComponent: { "count": 200, "food_demand": 150 }
The player sets a goal: “Prevent resource shortage.”
1) State Extraction: The Game Adapter serializes the ECS state into JSON and sends it to the MCP Server via WebSocket.
2) AI Analysis and Strategy Generation: The AI Agent identifies a food deficit (100 < 150) and proposes building two farms (cost: 200 gold, output: +20 food/turn).
3) Sandbox Simulation: The Sandbox tests the strategy, predicting food stability in 4 turns.
4) Recommendation Delivery: The AI Agent suggests: “Build two farms to resolve food shortage in 4 turns,” displayed as a UI prompt.
5) Player Action and Feedback: The player accepts, updating the state (gold: 200). The AI Agent monitors the outcome and adjusts future suggestions.
Context-Awareness: Recommendations align with game state and player goals, using memory of past states.
Modularity: Seamless integration with ECS-based engines.
Player Empowerment: Non-intrusive prompts maintain player control.
Arai is designed for ease of integration and player engagement across diverse games. Its ECS-based structure works with engines like Unity or Bevy via a simple SDK, adapting to various mechanics. The lightweight Sandbox and WebSocket-driven MCP Server aim to handle complex games efficiently, delivering timely recommendations. Players receive optional, intuitive prompts informed by past states, ensuring they retain control while benefiting from AI support.
Arai is a versatile AI Co-Pilot enhancing gameplay with context-aware suggestions across various game genres. Its ECS architecture, MCP Server, Sandbox, and AI Agent collaborate to provide actionable advice, as demonstrated in managing a settlement’s resources. It offers developers a practical tool for deployment, simplifying complex gameplay while keeping players engaged.
Future goals include:
Supporting multiple games with a shared AI Agent.
Analyzing visual data for improved recommendations.
Personalizing suggestions for individual players.
Optimizing for smaller games to aid indie developers.
These steps aim to broaden Arai’s impact in game development.
K A R L | 0xAstra
Over 100 subscribers
