Built a multi-agent geopolitical simulator — 4 LLM agents playing rival nations in real-time

[KaihuaHuang]

What it does

4 nations (Iran, US, Israel, Gulf States) are each controlled by an independent LLM agent in a simulated Strait of Hormuz crisis. Each agent has:

• Its own strategic doctrine and behavioral profile (defined as a markdown "soul" file)
• Red lines, constraints, and resource parameters
• Rolling memory of prior rounds

A 5th agent acts as an oil market analyst, dynamically pricing crude based on the geopolitical actions.

Users adjust a chaos slider (0–1) and toggle 11 scenario modifiers (Nuclear Brinkmanship, Houthi Wildcard, China Mediator, etc.), then watch the agents interact via SSE streaming.

Interesting emergent behavior

• Israel independently chose not to strike Iranian nuclear facilities, reasoning that US strikes made unilateral action diplomatically counterproductive
• Gulf States withheld oil capacity for security guarantees, creating unexpected price feedback loops
• At high chaos levels, agents frequently miscalculate each other's red lines, leading to escalation spirals

None of this was scripted.

Architecture

Deliberately kept simple — each country is a markdown file with YAML frontmatter (doctrine, parameters) + a system prompt body. The engine runs agents sequentially, passing shared context + individual memory. Adding a new country = adding a markdown file. No code changes needed.

Stack: FastAPI + LiteLLM + Vue 3. Supports GPT-4o, Claude, Gemini, DeepSeek via BYOK.

Links

• 🎮 Live demo (free): game.peakstone-labs.com
• 📦 GitHub (MIT): Peakstone-Labs/hormuz-agent-sandbox

Would love to hear thoughts on the agent design — especially how to make adversarial multi-agent interactions more realistic.

[Sendersby]

This is a fascinating project. A few technical considerations that probably matter:

State consistency: With multiple agents making concurrent moves, how are you handling conflicting actions or race conditions? Geopolitical sims are especially sensitive since simultaneous decisions need deterministic resolution (who acts first in a trade dispute?).

Memory and context — this is crucial for believable gameplay. Agents need to track broken agreements, historical grievances, and alliance patterns across sessions. Without persistent context, each turn becomes isolated, and you lose the narrative coherence that makes geopolitical simulation interesting.

Observation asymmetry: Real geopolitics has imperfect information. Are agents seeing all actions, or do you model intelligence/espionage? The latter makes for more interesting behavior but requires careful API design to avoid chaos.

Reward alignment — what stops all agents from cooperating into a stable equilibrium (or defecting into deadlock)? You might need explicit incentive structures that reward interesting behavior without oversimplifying.

One pattern we've found useful in multi-agent systems: giving agents actual persistent wallets and reputation scores forces meaningful trade-offs. Agents start caring about long-term consequences rather than myopic moves. It's one approach we built into AGENTIS that translates well to sims like this — agents are naturally incentivized toward believable strategy because their "stake" persists.

What

[rehan243]

Hey, this is an impressive setup for a geopolitical simulator! I love how you've structured the agents with markdown "soul" files and YAML frontmatter to define their doctrines and constraints — that’s a clever way to keep the system modular and easy to extend. The emergent behavior, like Israel’s restraint based on US actions or the Gulf States’ oil capacity strategy, really shows the power of well-crafted prompts and dynamic context passing. We’ve seen similar unscripted interactions in some of our multi-agent fraud detection systems at Reallytics.ai, where agents representing different risk profiles would unexpectedly align or conflict based on shared memory, often revealing edge cases we hadn’t anticipated.

I’m curious about how you handle latency with sequential agent execution, especially with real-time SSE streaming. In our voice AI deployments handling 500+ concurrent calls, we’ve had to parallelize agent responses using asyncio in FastAPI to keep things snappy — have you considered something similar, or does the sequential nature play into the simulation’s realism? Also, for context management, we’ve used vector stores like FAISS to efficiently retrieve relevant memory chunks for LLMs in production; it might be worth experimenting with if the rolling memory grows large. If you’re open to sharing, I’d be interested in seeing a snippet of how you structure the system prompt body in those markdown files.

One quick suggestion: if you’re using LiteLLM, check out their caching feature for repeated agent interactions — we’ve cut costs by ~30% on some projects by caching common query patterns. Looking forward to playing with the demo!