Turn-based strategy games have long challenged players to juggle many detailed tactical moves, often reducing compelling strategic objectives into countless clicks and micromanagement. What if this interface barrier could be lifted? Instead of commanding every individual unit directly, players articulate high-level goals while AI agents translate that intent into precise game operations.

Mark Tinderholt’s multi-player online game, Strategery, attempts just that by embedding AI agents inside the user interface. Drawing inspiration from classics like Risk and Axis & Allies, Strategery blends familiar mechanics with a fresh paradigm: AI assistants act as executive officers, handling the execution minutiae so players can focus on big-picture strategy.

In this post, we’ll explore the architecture underlying Strategery, delve into the technical innovations enabling AI delegation, and share practical insights for developers interested in integrating AI as a first-class interface element in games.

Mark Tinderholt, developer of Strategery (source: Medium)

Architecture Overview

┌────────────────────────────────────────────┐
│Architecture                                │
├────────────────────────────────────────────┤
│• Enterprise data sources                   │
│• Foundry platform                          │
│• AI applications                           │
└────────────────────────────────────────────┘

Key Technical Observations

• AI as an Executive Officer — Instead of AI simply playing against humans, the architecture embeds AI agents as in-game assistants that interpret high-level player intents into granular tactical commands.

• Intent-Action Separation — The system models player input as strategic intent, distinct from low-level actions. This abstraction enables AI to substitute for manual command input, bridging human strategic thinking with software execution.

• Reactive Frontend with SignalR — Real-time updates via SignalR push game state changes instantly to connected clients, maintaining synchronization during asynchronous AI computations and player moves.

• Event-Driven Backend with Azure Event Grid — Events triggered by user actions or AI decisions flow through Event Grid, supporting scalable and loosely coupled processing of game state updates.

• Persistent Distributed State in Cosmos DB — The use of Cosmos DB ensures consistent, low-latency access to the game state for all services, supporting multi-player concurrency and complex strategy execution.

• Custom-Built Instead of Forking TripleA — Although initially inspired by the open-source TripleA engine, the entire stack was rebuilt from scratch for greater control and to fully integrate AI as strategic partners rather than mere opponents.

How It Works

Capturing Strategic Intent in the UI

Players interact through a React frontend designed to express objectives naturally—such as "advance infantry on the eastern front" or "secure naval dominance in the south." The UI abstracts away manual clicking on every unit by capturing these intents as data structures representing desired outcomes rather than single actions.

// Example React state capturing player intent
const [playerIntent, setPlayerIntent] = useState({
  objective: "Capture Territory",
  targetRegion: "Southeast Asia",
  priority: "High",
});

This intent is then sent to the backend where AI agents leverage it to generate executable commands.

Backend Processing and Validation

The .NET API exposes endpoints for receiving intents and game commands. Upon receipt, it verifies legality against the current game state, stored in Cosmos DB, ensuring rules compliance before invoking AI processing pipelines.

AI Agent as Tactical Interpreter

The AI engine acts on player intent:

1. Parses strategic goals into tactical subgoals (e.g., moving specific units, allocating resources).
2. Plans sequences of commands optimized for efficiency and success probability.
3. Submits concrete commands back through the backend for execution.

AI decision-making uses heuristic and rule-based approaches tailored to the game’s mechanics, continuously adapting to the evolving battlefield.

Real-Time Feedback and Iteration

Once actions resolve, Event Grid notifies all interested components. SignalR then broadcasts updates to player clients, closing the loop with immediate visual feedback. Players can adjust intents for subsequent turns, allowing iterative collaboration between human and AI.

Quick Tips & Tricks

1. Design for Intent Over Action — Structure your game data models to separate "what the player wants" from "what the game does," enabling AI to fill the execution gap.

2. Leverage Serverless Eventing — Azure Event Grid offers a scalable way to asynchronously process game events, keeping backend services decoupled and responsive.

3. Use SignalR for Seamless Sync — Implement SignalR hubs to maintain real-time state synchronization, critical for fluid multiplayer experiences.

4. Persist State in Globally Distributed Stores — Cosmos DB provides low-latency consistency essential for multiplayer strategy games involving complex shared state.

5. Build AI as a UI Partner, Not Just Opponent — Reimagine AI agents as cooperative aides, allowing players to delegate and collaborate rather than only compete.

6. Iterate with Player Feedback — Incorporate telemetry and player testing to tune AI strategic behavior for increasing engagement and satisfaction.

Conclusion

Strategery exemplifies a transformative approach to strategy gaming: leveraging AI not just as an adversary but as an integrated executive partner within the user interface. This shift enables players to focus on meaningful strategic decisions rather than micromanaged actions, enhancing immersion and accessibility.

Built from the ground up on robust Azure services and modern frameworks, the architecture balances responsiveness with asynchronous AI computation, delivering a fluid multiplayer experience. As AI advances, this model opens pathways for richer human-AI collaboration in gaming and beyond.

The future of strategy games lies in empowering players with AI partners—delegating complexity so users can truly craft strategy, not clicks.

References

1. Make It So: Delegating Strategy Game Operations to AI Agents - Mark Tinderholt — The original article detailing the project and architectural insights.

2. Azure Cosmos DB Documentation — Microsoft's globally distributed, multi-model database service used for game state management.

3. Azure Event Grid Overview — Explains event-based architecture for asynchronous messaging, fundamental to the backend processing.

4. SignalR for Real-time Web Functionality — Microsoft's library enabling real-time client-server communication in the web frontend.

5. TripleA Open Source Strategy Game Engine — Inspiration source for strategic mechanics and game design concepts.

Concept art and UI depiction from Mark Tinderholt’s Medium article.