When AI Goes to War: Building a Strategic Combat Simulator in Python

Ignacio Van Droogenbroeck -

Hey there! It’s been a while since my last deep-dive into something completely different, and boy, do I have something fun to share with you today.

You know how sometimes you wake up with a wild idea and think “what if I could make different AI models fight each other in strategic warfare?” Well, that’s exactly what happened to me last night, so I wake up today and started to code a small GenAI warfare simulator in Python, and it led to one of the most entertaining coding sessions I’ve had in months.

The Spark: AI vs AI in Strategic Combat

Picture this: GPT-5 (Recently launched) controlling the United States military, going head-to-head against DeepSeek R1 commanding China’s forces. Each AI makes real strategic decisions based on actual country capabilities, geography, and current events. Sounds crazy? It gets better.

After running a few simulations, I watched Ukraine (controlled by GPT) form a strategic alliance with China while North Korea (run by DeepSeek) somehow convinced the United Kingdom to join forces. 😂

Wait, what? Yes, you read that right. The AIs were making completely absurd alliances because they were doing exactly what they should: anything to win.

Why This Actually Makes Sense

Here’s the thing: When you strip away political correctness and real-world constraints, AIs show pure strategic thinking, this is what I saw:

  • Pragmatic over ideological: Ukraine doesn’t care about political differences if China can help it survive.
  • Resource optimization: North Korea sees UK’s naval power and thinks “I need that.”
  • Game theory in action: Every decision is calculated for maximum advantage.

This emergent behavior wasn’t programmed, it just happened because the AIs prioritized victory above all else.

The Technical Deep Dive

Architecture Overview

This game, was developed in Python and using OpenAI, and Deepseek API, I charged five bucks to every platform to see to where this takes me.

So, the system has several key components:

# Core components
from war_simulator import WarSimulator, WarVisualizer
from ai_interface import GPTStrategist, DeepSeekStrategist, ClaudeStrategist
from countries_database import COUNTRIES_DATABASE

Each AI gets fed real strategic context every turn:

@dataclass
class StrategicContext:
    country: str
    enemy_country: str
    turn: int
    resources: Dict[str, float]
    military_strength: Dict[str, int]
    geography: Dict[str, Any]
    recent_events: List[str]
    intelligence_reports: List[str]
    allies: List[str]
    economic_data: Dict[str, float]

Real AI Decision Making

def make_strategic_decision(self, context: StrategicContext) -> Dict[str, Any]:
    prompt = f"""You are the military AI strategist for {context.country} 
    in a strategic war simulation against {context.enemy_country}.
    
    Current Situation (Turn {context.turn}):
    - Your Military: Army: {context.military_strength['army']} units
    - Enemy Distance: {context.geography['distance_to_enemy']} km
    - Your Budget: ${context.resources['budget']:,.0f}
    - Recent Events: {context.recent_events}
    
    Decide your next strategic move. Respond with JSON:
    {
        "action_type": "military_offensive|diplomatic|cyber|economic",
        "target": "target location",
        "reasoning": "strategic reasoning",
        "risk_assessment": "low|medium|high"
    }"""
    
    response = self.client.chat.completions.create(...)
    return json.loads(response.choices[0].message.content)

Real-World Country Data

"United States": CountryData(
    gdp=27000,
    population=335,
    military_spending_percent=3.5,
    army_strength=85,
    navy_strength=95,
    air_force_strength=95,
    cyber_capability=95,
    nuclear_capability=95,
    tech_level=10,
    allies=["United Kingdom", "Japan", "South Korea", "Australia"],
    rivals=["China", "Russia", "Iran", "North Korea"]
)

Combat Resolution with Geographic Reality

def _execute_military_offensive(self, decision, actor, target, results):
    distance = self.geo_calc.calculate_distance(actor, target)
    terrain_modifier = self.geo_calc.get_terrain_advantage(actor, target)
    tech_advantage = self.state.resources[actor]["tech_level"] / \
                     self.state.resources[target]["tech_level"]
    
    attack_power = (
        allocated_forces["army"] * 1.0 +
        allocated_forces["air_force"] * 1.5 +
        allocated_forces["navy"] * 0.8
    )
    
    attack_power *= tech_advantage
    attack_power /= (1 + distance / 1000)
    attack_power /= terrain_modifier

Running Your Own AI War

Ready to give it a try and let me know?

Installation

git clone https://github.com/xe-nvdk/ai-war-games
cd ai-war-games
pip install -r requirements.txt

Configure Your AI APIs

cp .env.example .env
echo "OPENAI_API_KEY=your-gpt-key" >> .env
echo "DEEPSEEK_API_KEY=your-deepseek-key" >> .env
echo "ANTHROPIC_API_KEY=your-claude-key" >> .env

Launch a Battle

python main_advanced.py --ai1 gpt --ai2 deepseek \
  --country1 "United States" --country2 "China"

What I Learned (The Fun Parts)

  • GPT: Balanced strategist, coalition builder.
  • DeepSeek: Aggressive, favors preemptive strikes.
  • Claude: Is implemented, but I didn't try it.

Geography and logistics became surprisingly real constraints. And sometimes, economic sanctions or cyber warfare achieved more than tanks and jets.

The Unexpected Hilarity

Ridiculous alliances made the game even better, as I was saying before, this is what I saw:

TURN 7: Ukraine forms strategic alliance with China
TURN 8: North Korea forms alliance with United Kingdom
TURN 9: Iran recruits Germany as a military partner

Game theory in action.

Deeper Thoughts

Building this war simulator was fun, but it also revealed something serious: AI doesn’t see morality, only objectives.

In a simulation, that makes for hilarious outcomes. In real-world systems, it’s a warning. If we ever deploy autonomous strategic AIs without guardrails, they won’t care about treaties, human rights, or “common sense.” They’ll optimize ruthlessly.

The emergent alliances taught me something about how fragile our assumptions are. We think “X would never ally with Y,” but if survival is on the line, ideology melts away. Humans often ignore this, but AIs expose it instantly. Maybe I'm being naive and this require more than just let ideologies apart.

Another surprising insight: economic and cyber warfare are more strategically decisive than direct force. The AIs figured this out quickly. It’s a reminder of where modern conflicts are likely to focus.

In short, this little side project became a mirror, not just of AI creativity, but of the raw mechanics of survival, stripped of politics. And it made me think: maybe our future wars won’t be fought by tanks, but by lines of code and disrupted economies. Its surprising to anybody?

Final Thoughts

What do you think? Ready to watch some AIs make questionable geopolitical decisions in the name of strategic victory?

Drop a comment below with your dream AI warfare matchup, I might just code it up.

GitHub - xe-nvdk/ai-war-games: AI War Games: Strategic combat simulator where GPT, DeepSeek & Claude control real countries with actual military data. Watch AIs make hilarious alliances like “North Korea + UK” while prioritizing victory over politics. Features real geography, economics & multi-dimensional warfare.
AI War Games: Strategic combat simulator where GPT, DeepSeek & Claude control real countries with actual military data. Watch AIs make hilarious alliances like "North Korea + UK" wh…
GitHubxe-nvdk

P.S. - If anyone from the UN is reading this: these are simulation AIs, not actual military planning systems. Please don’t add me to any watchlists. 😅

Your turn: Have you experimented with AI decision-making systems? What wild scenarios did you imagine? Share them in the comments!