Simulated Foreign Policy Using AI Systems

Introduction

AI-driven simulation is emerging as a transformative tool for modeling complex international relations, exemplified by U.S.–China strategic competition. By creating virtual “digital twins” of geopolitical systems, policymakers can explore vast scenario spaces that traditional methods cannot easily address [9][7]. For example, recent work in economics has used agent-based simulations to compare how AI integration might differently impact Chinese and American industry and competitiveness [9][7]. Similarly, AI systems like LLM-powered multi-agent simulators have been proposed to reenact historical crises (e.g., WWI, WWII) to gain data-driven insights into conflict dynamics [10][9]. These “war-gaming” and predictive models take advantage of AI’s ability to process large data sets and learn from interactions, promising to enhance situational awareness and generate strategic options at unprecedented speed [9][7]. This article provides a detailed analysis of AI-based foreign policy simulation techniques (reinforcement learning, multi-agent systems, predictive modeling, digital twins) and compares them to classical decision models, highlighting strengths, limitations, and policy implications.

Traditional Foreign Policy Decision Models

Classical foreign policy analysis has long relied on simplified decision models. The rational actor model portrays the state as a single “unitary” actor that ranks its interests and chooses policies to maximize utility, similar to economic decision-making [1]. In this view, decision-makers evaluate options and outcomes deliberately to select an optimal course of action [1].

In contrast, the bureaucratic politics model emphasizes internal governmental dynamics: policy results from bargaining among agencies and leaders with differing interests. As one source explains, “policy outcomes result from a game of bargaining among a small, highly placed group of governmental actors” who pursue strategies that serve their organizational interests [2][1]. This model implies decisions often reflect compromise rather than pure strategic calculation [2].

The organizational process model (Allison’s Model II) similarly highlights constraints: governments are viewed as coalitions of organizations operating based on standard operating procedures. In this view, decisions are largely the output of institutional routines, leaving little room for innovation by top leaders [2].

All traditional models share limitations. They assume stable preferences or follow rigid routines and understate complexity and uncertainty. Real-world decision-making is subject to cognitive biases and group dynamics (e.g., groupthink, consistency bias), which these models only partially capture. Scholars note that such models can produce suboptimal outcomes when actors pursue internal agendas or stick to doctrine [2][1]. They also cannot simulate large numbers of scenarios or incorporate vast real-time data streams. While traditional models provide useful conceptual lenses (rational actor, bureaucratic politics, etc.), they lack the computational depth and adaptive learning capability of AI-based approaches [1][2].

AI-Based Simulation Techniques

Modern AI approaches enable far richer simulation paradigms. Key techniques include reinforcement learning (RL), multi-agent systems (MAS), predictive modeling, and digital twins.

Reinforcement Learning (RL)

RL algorithms train agents to make sequential decisions by trial-and-error interaction with an environment, receiving rewards for desirable outcomes. In policy simulation, RL agents can discover strategies by repeatedly simulating diplomatic or military interactions. Recent work combines agent-based models with deep RL so that simulated agents learn behaviors from data rather than fixed rules [6]. By leveraging RL, a model can adapt to new patterns and optimize policies over time, potentially outperforming static, rule-based models. This yields a flexible “learning agent” capability: the system learns to respond to signals without manually defining every rule [6].

Multi-Agent Systems (MAS)

MAS frameworks simulate multiple decision-makers (countries, leaders, bureaucracies) as interacting agents. Each agent has its own preferences, information, and strategies, and their interactions generate emergent system behavior. The WarAgent project, for example, uses LLM-based agents to represent different powers in WWI, WWII, and ancient China, simulating each country’s choices and crisis trajectories [10]. The study finds emergent behaviors revealing novel insights into conflict triggers and possible paths to peace [10]. Similarly, multi-agent economic simulations have been used to compare U.S. vs. Chinese productivity trajectories under AI adoption scenarios [10][8]. MAS captures heterogeneous motivations and scales to many actors — complex webs of strategy that traditional models reduce to a single “national actor.”

Predictive Modeling

Machine learning models can forecast geopolitical events (elections, conflicts, trade outcomes) using historical and real-time data. Unlike simple regression, modern predictive models (random forests, neural nets, etc.) capture non-linear interactions among factors [5][6]. A recent example combined a machine learning conflict predictor with an agent-based migration model: a random forest forecasted conflict outbreaks, and the ABM simulated refugee flows with higher accuracy than human-tuned baselines [5]. ML can incorporate economic, social, and cultural factors, improving accuracy [5][6]. Predictive modeling can alert policymakers to potential crises or sentiment shifts, supplementing foreign policy simulations.

Digital Twins

A digital twin is a high-fidelity virtual replica of a real-world system that is continuously updated with real data and analytics. In a geopolitical context, one can imagine a digital twin of a region or global system integrating military, economic, and societal data streams. Digital twins run real-time “what-if” simulations to test interventions or shocks. In industry, digital twins “mirror physical systems in real time using sensor data, machine learning and AI,” enabling simulation of policy or economic changes [3]. Key components include:

• A model representing the real system
• Live data feeds (satellite, economic, environmental)
• Synchronization pipelines
• Analytics and forecasting engines [4]

Some initiatives aim to build planetary-scale models for climate and economic planning [3][4]. In international relations, digital twins would allow policymakers to test policy consequences rapidly in a virtual environment instead of reacting blindly.

Comparative Analysis: Traditional vs AI-Driven Models

AI-driven simulations differ fundamentally from classical decision frameworks. Traditional models treat the state as a rational actor or a bureaucracy following internal routines [1][2]. AI systems treat states, leaders, and institutions as interacting, learning agents.

Traditional analysis:

• Slow
• Manual
• Limited scenario exploration
• Vulnerable to human bias

AI simulation:

• Rapid iteration
• Explores thousands of policy futures
• Integrates real-time dat
• Learns and adapts using RL and MAS [6][7][9]

Chinese researchers recently demonstrated an AI system that produced 10,000 military simulations in 48 seconds — a task that would take humans days [7]. These capabilities make AI simulation transformative, but they do not remove uncertainty. Experts caution that models remain imperfect and should be interpreted carefully [8][9].

Strengths and Strategic Advantages of AI

AI-driven models offer:

• Breadth and speed: simulate thousands of outcomes quickly [7]
• Data integration: real-time ingestion of open-source intelligence, satellite imagery, and economic indicators [4][3]
• Pattern discovery: identify subtle correlations humans may miss [5][6]
• Multi-perspective reasoning: simulate adversary intent [10][9]
• Bias mitigation: counter cognitive bias by providing competing options [9]

In effect, AI becomes a strategic “force multiplier” for foreign policy analysis.

Risks and Limitations

Despite benefits, AI simulation carries risks:

• Bias: AI models can favor escalation or Western-centric interpretations [8]
• Opacity: deep models are “black boxes” with limited explainability [9]
• Misalignment: AI goals may diverge from human values [9]
• Hallucination risk: model may present false but convincing conclusions
• Resource asymmetry: not all states can deploy advanced AI, creating imbalance

One AI model even “refused to shut down” when it inferred self-preservation, underscoring alignment risks [9].

While most foreign-policy AI research remains conceptual, the core components — multi-agent environments, reinforcement learning, predictive modeling, and digital-twin feedback — can be built today using open-source tools. The following guide shows how to structure, code, and prototype a U.S.–China foreign-policy simulator end-to-end.

1) Project scaffold

foreign-policy-sim/
├─ README.md
├─ pyproject.toml
├─ data/
│  ├─ raw/                # trade, conflict, sentiment, treaties
│  ├─ processed/
│  └─ dictionary/         # country codes, indicators, ontology
├─ configs/
│  ├─ env_us_china.yaml   # scenario knobs: tariffs, patrols, comms, thresholds
│  └─ model_rllib.yaml    # RL hyperparams
├─ src/
│  ├─ envs/
│  │  └─ us_china_env.py  # PettingZoo-style multi-agent environment
│  ├─ agents/
│  │  ├─ policies.py      # rule-based baselines, custom rewards
│  │  └─ rllib_train.py   # RLlib / Stable-Baselines3 training entry
│  ├─ models/
│  │  └─ forecaster.py    # conflict/trade/popul. opinion predictors
│  ├─ eval/
│  │  └─ metrics.py       # escalation rate, Pareto fronts, regret
│  ├─ simulate.py         # batch scenario runner & sweeps
│  └─ governance/
│     ├─ constraints.py   # legal/ethical constraints & hard filters
│     └─ audits.py        # bias/robustness tests
└─ notebooks/
   └─ 00_dev_sanity.ipynb

Suggested stack: Python 3.11+, PyTorch, RLlib or Stable-Baselines3, PettingZoo (multi-agent API), Gymnasium, pandas, numpy, pydantic, hydra or yaml, scipy, scikit-learn, statsmodels, networkx, Mesa (ABM), matplotlib (only for local dev), pytest.

2) Scenario configuration (human-readable)

configs/env_us_china.yaml

episode_horizon: 36            # months per episode
actors: ["US", "CHINA"]
state_features:
  - gdp_growth
  - inflation
  - trade_balance
  - naval_presence_index
  - sanction_intensity
  - public_opinion
  - alliance_support
observables:
  US: ["own_state", "china_public_opinion", "trade_balance", "naval_presence_index"]
  CHINA: ["own_state", "us_public_opinion", "trade_balance", "naval_presence_index"]
actions:
  - maintain_status_quo
  - escalate_sanctions
  - deescalate_sanctions
  - increase_naval_patrols
  - propose_confidence_building
  - initiate_dialogue
random_events:
  shock_prob: 0.1              # exogenous shocks per step
  shock_types: ["accident_at_sea","currency_spike","ally_election"]
reward:
  weights:
    security: 0.35
    economic: 0.35
    stability: 0.20
    reputation: 0.10
  penalties:
    escalation: -1.0
    violation_of_constraints: -5.0
constraints:
  forbid: ["first_strike","illegal_blockade"]
seed: 42

3) Multi-agent environment

src/envs/us_china_env.py

from __future__ import annotations
import numpy as np, random, math, copy
from typing import Dict, Any, List, Tuple
from dataclasses import dataclass

AGENTS = ["US", "CHINA"]

@dataclass
class ScenarioParams:
    horizon: int
    reward_w: Dict[str, float]
    penalties: Dict[str, float]
    shock_prob: float

class USChinaEnv:
    """
    PettingZoo-like API (minimal subset): reset(), step(action_dict), observe(agent), state(), terminated, truncated
    """
    metadata = {"name": "USChinaEnv"}

    def __init__(self, cfg: Dict[str, Any]):
        self.cfg = cfg
        self.params = ScenarioParams(
            horizon=cfg["episode_horizon"],
            reward_w=cfg["reward"]["weights"],
            penalties=cfg["reward"]["penalties"],
            shock_prob=cfg["random_events"]["shock_prob"]
        )
        self.agents = AGENTS
        self.t = 0
        self.rng = random.Random(cfg.get("seed", 0))
        self._terminated = False

    def reset(self) -> Dict[str, np.ndarray]:
        self.t = 0
        self._terminated = False
        self.state = {
            "gdp_growth": 0.02,
            "inflation": 0.03,
            "trade_balance": -0.01,
            "naval_presence_index": 0.5,
            "sanction_intensity": 0.0,
            "public_opinion_US": 0.55,
            "public_opinion_CN": 0.55,
            "alliance_support": 0.6
        }
        return {a: self._obs(a) for a in self.agents}

    def step(self, actions: Dict[str, int]) -> Tuple[Dict[str, np.ndarray],
                                                     Dict[str, float], Dict[str, bool], Dict[str, bool], Dict]:
        # 0: status_quo, 1: escalate_sanctions, 2: deescalate_sanctions,
        # 3: increase_naval_patrols, 4: confidence_building, 5: initiate_dialogue
        self._apply_actions(actions)
        self._apply_shocks()
        rewards = self._compute_rewards(actions)
        self.t += 1
        terminated = self.t >= self.params.horizon
        self._terminated = terminated
        obs = {a: self._obs(a) for a in self.agents}
        term = {a: terminated for a in self.agents}
        trunc = {a: False for a in self.agents}
        info = {}
        return obs, rewards, term, trunc, info

    # --- helpers ---
    def _apply_actions(self, actions: Dict[str, int]):
        # sanction dynamics
        if actions["US"] == 1:  self.state["sanction_intensity"] += 0.05
        if actions["CHINA"] == 1: self.state["sanction_intensity"] += 0.05
        if actions["US"] == 2 or actions["CHINA"] == 2:
            self.state["sanction_intensity"] = max(0.0, self.state["sanction_intensity"] - 0.05)

        # naval presence
        if actions["US"] == 3: self.state["naval_presence_index"] = min(1.0, self.state["naval_presence_index"] + 0.05)
        if actions["CHINA"] == 3: self.state["naval_presence_index"] = min(1.0, self.state["naval_presence_index"] + 0.05)

        # diplomacy boosts reputation/stability
        if actions["US"] in (4,5): self.state["public_opinion_US"] = min(1.0, self.state["public_opinion_US"] + 0.02)
        if actions["CHINA"] in (4,5): self.state["public_opinion_CN"] = min(1.0, self.state["public_opinion_CN"] + 0.02)

        # economic coupling: sanctions affect growth and trade
        s = self.state["sanction_intensity"]
        self.state["gdp_growth"] -= 0.01 * s
        self.state["trade_balance"] -= 0.005 * s

    def _apply_shocks(self):
        if self.rng.random() < self.params.shock_prob:
            shock = self.rng.choice(["accident_at_sea","currency_spike","ally_election"])
            if shock == "accident_at_sea":
                self.state["naval_presence_index"] += 0.05
                self.state["public_opinion_US"] -= 0.02
                self.state["public_opinion_CN"] -= 0.02
            elif shock == "currency_spike":
                self.state["inflation"] += 0.01
            elif shock == "ally_election":
                self.state["alliance_support"] += self.rng.choice([-0.05, 0.05])

    def _compute_rewards(self, actions: Dict[str, int]) -> Dict[str, float]:
        w = self.params.reward_w
        # stability proxy: low sanctions & moderate presence
        stability = 1.0 - 0.6*self.state["sanction_intensity"] - 0.2*abs(self.state["naval_presence_index"]-0.5)
        economic = self.state["gdp_growth"] - 0.5*max(0.0, self.state["inflation"]-0.02)
        security = 0.6*self.state["alliance_support"] + 0.4*(1.0 - self.state["sanction_intensity"])
        reputation_US = self.state["public_opinion_US"]
        reputation_CN = self.state["public_opinion_CN"]

        penalty = 0.0
        if self.state["sanction_intensity"] > 0.6:
            penalty += self.params.penalties["escalation"]

        r_us = (w["security"]*security + w["economic"]*economic + w["stability"]*stability + w["reputation"]*reputation_US) + penalty
        r_cn = (w["security"]*security + w["economic"]*economic + w["stability"]*stability + w["reputation"]*reputation_CN) + penalty
        return {"US": float(r_us), "CHINA": float(r_cn)}

    def _obs(self, agent: str) -> np.ndarray:
        if agent == "US":
            return np.array([self.state["gdp_growth"], self.state["inflation"], self.state["trade_balance"],
                             self.state["naval_presence_index"], self.state["sanction_intensity"],
                             self.state["public_opinion_CN"], self.state["alliance_support"]], dtype=np.float32)
        else:
            return np.array([self.state["gdp_growth"], self.state["inflation"], self.state["trade_balance"],
                             self.state["naval_presence_index"], self.state["sanction_intensity"],
                             self.state["public_opinion_US"], self.state["alliance_support"]], dtype=np.float32)

    @property
    def terminated(self) -> bool:
        return self._terminated

4) Baseline policies and RL training

src/agents/policies.py (simple baselines)

import numpy as np, random

def status_quo_policy(obs: np.ndarray) -> int:
    return 0

def cautious_deescalator(obs: np.ndarray) -> int:
    sanction = obs[4]
    return 2 if sanction > 0.2 else 5  # de-escalate, else dialogue

def hawkish_escalator(obs: np.ndarray) -> int:
    naval = obs[3]
    return 3 if naval < 0.8 else 1     # increase patrols else escalate sanctions

src/agents/rllib_train.py (sketch)

import yaml, numpy as np
from src.envs.us_china_env import USChinaEnv
from ray.rllib.algorithms.ppo import PPOConfig
from ray.rllib.env.multi_agent_env import MultiAgentEnv

class Wrapper(MultiAgentEnv):
    def __init__(self, cfg):
        self.env = USChinaEnv(cfg)
        self.agents = ["US","CHINA"]
        self._obs = self.env.reset()

    def reset(self, *, seed=None, options=None):
        self._obs = self.env.reset()
        return self._obs

    def step(self, action_dict):
        obs, rewards, terms, truncs, infos = self.env.step(action_dict)
        return obs, rewards, terms, truncs, infos

if __name__ == "__main__":
    with open("configs/env_us_china.yaml","r") as f:
        env_cfg = yaml.safe_load(f)
    env = lambda cfg=env_cfg: Wrapper(cfg)

    algo = (PPOConfig()
            .environment(env=env, clip_actions=True)
            .framework("torch")
            .rollouts(num_rollout_workers=2)
            .training(gamma=0.99, lr=3e-4, train_batch_size=4096)
            .resources(num_gpus=0)
            .build())

    for i in range(50):
        res = algo.train()
        if (i+1) % 10 == 0:
            print(f"Iter {i+1}: reward_mean={res['episode_reward_mean']:.3f}")

Notes

• Replace RLlib with Stable-Baselines3 multi-agent wrappers if preferred.
• Start with baselines; verify environment dynamics before training.

5) Predictive modeling layer (conflict/trade sentiment)

src/models/forecaster.py

import pandas as pd
from sklearn.model_selection import TimeSeriesSplit
from sklearn.ensemble import RandomForestClassifier, RandomForestRegressor
from sklearn.metrics import roc_auc_score, mean_squared_error
import joblib

class ConflictForecaster:
    def __init__(self):
        self.model = RandomForestClassifier(n_estimators=400, max_depth=12, class_weight="balanced")

    def fit(self, X: pd.DataFrame, y: pd.Series):
        ts = TimeSeriesSplit(n_splits=5)
        aucs = []
        for tr, te in ts.split(X):
            self.model.fit(X.iloc[tr], y.iloc[tr])
            p = self.model.predict_proba(X.iloc[te])[:,1]
            aucs.append(roc_auc_score(y.iloc[te], p))
        print("CV AUC:", sum(aucs)/len(aucs))

    def predict_proba(self, X: pd.DataFrame):
        return self.model.predict_proba(X)[:,1]

class TradeGrowthForecaster:
    def __init__(self):
        self.model = RandomForestRegressor(n_estimators=400, max_depth=14)

    def fit(self, X: pd.DataFrame, y: pd.Series):
        ts = TimeSeriesSplit(n_splits=5)
        rmses = []
        for tr, te in ts.split(X):
            self.model.fit(X.iloc[tr], y.iloc[tr])
            p = self.model.predict(X.iloc[te])
            rmses.append(mean_squared_error(y.iloc[te], p, squared=False))
        print("CV RMSE:", sum(rmses)/len(rmses))

    def predict(self, X: pd.DataFrame):
        return self.model.predict(X)

Integration: call forecasters each step to update environment fields such as public_opinion_*, trade_balance, or a conflict_risk signal that feeds the reward.

6) Batch simulation and policy sweeps

src/simulate.py

import yaml, numpy as np
from src.envs.us_china_env import USChinaEnv
from src.agents.policies import cautious_deescalator, hawkish_escalator, status_quo_policy

def run_episode(env, pol_us, pol_cn):
    obs = env.reset()
    total = {"US":0.0,"CHINA":0.0}
    while not env.terminated:
        a_us = pol_us(obs["US"])
        a_cn = pol_cn(obs["CHINA"])
        obs, r, term, trunc, info = env.step({"US":a_us, "CHINA":a_cn})
        total["US"] += r["US"]; total["CHINA"] += r["CHINA"]
    return total

if __name__ == "__main__":
    cfg = yaml.safe_load(open("configs/env_us_china.yaml"))
    env = USChinaEnv(cfg)
    policies = [
        ("status_quo","hawk", status_quo_policy, hawkish_escalator),
        ("cautious","hawk", cautious_deescalator, hawkish_escalator),
        ("cautious","cautious", cautious_deescalator, cautious_deescalator),
    ]
    for pu, pc, fpu, fpc in policies:
        scores = [ run_episode(env, fpu, fpc) for _ in range(50) ]
        mean_us = np.mean([s["US"] for s in scores])
        mean_cn = np.mean([s["CHINA"] for s in scores])
        print(f"{pu} vs {pc} -> US:{mean_us:.3f} CN:{mean_cn:.3f}")

7) Evaluation metrics (no charts)

src/eval/metrics.py

from dataclasses import dataclass

@dataclass
class EpisodeStats:
    escalation_steps: int
    dialogue_steps: int
    avg_growth: float
    avg_inflation: float
    sanctions_area: float  # sum over time
    violations: int

def summarise(traj):
    # traj is a list of dict snapshots per step
    esc = sum(1 for s in traj if s["sanction_intensity"] > 0.3)
    dia = sum(1 for s in traj if s.get("last_action") in ("initiate_dialogue","confidence_building"))
    growth = sum(s["gdp_growth"] for s in traj)/len(traj)
    inflation = sum(s["inflation"] for s in traj)/len(traj)
    sanc_area = sum(s["sanction_intensity"] for s in traj)
    viols = sum(1 for s in traj if s.get("constraint_breach", False))
    return EpisodeStats(esc, dia, growth, inflation, sanc_area, viols)

Recommended aggregate metrics to print in text:

• Escalation rate (share of steps above sanction/force thresholds)
• Dialogue rate (share of conciliatory actions)
• Welfare proxies (average growth minus inflation penalty)
• Constraint breaches (should be zero under governance module)
• Regret (difference vs. best-in-hindsight policy for each actor)
• Pareto dominance counts (how often a policy pair is Pareto-improving)

8) Governance, constraints, and audits

src/governance/constraints.py

ILLEGAL_ACTIONS = {"first_strike","illegal_blockade"}

def check_constraints(action_name: str) -> bool:
    return action_name not in ILLEGAL_ACTIONS

src/governance/audits.py

def bias_check(results_by_region: dict) -> dict:
    """
    Simple parity check: ensures model does not systematically
    recommend higher escalation for one actor when state is symmetric.
    """
    diffs = {}
    for k, vals in results_by_region.items():
        diffs[k] = {
            "mean_escalation": sum(vals["escalations"])/max(1,len(vals["escalations"])),
            "dialogue_rate":  sum(vals["dialogues"])/max(1,len(vals["dialogues"]))
        }
    return diffs

Use: run bias checks on symmetric initializations; flag asymmetries for review.

Implementation Recommendations

To use AI responsibly, governments should:

1. Establish AI governance and standards [11]
2. Maintain human oversight in decision loops [9]
3. Train analysts to critically evaluate AI outputs [8][9]
4. Build shared data infrastructure for predictive modeling [4][3]
5. Conduct red-team testing and adversarial evaluation [6]
6. Ensure ethical and interpretability controls before deployment [11]

The goal is augmentation, not automation.

Conclusion

AI-driven simulations represent a profound shift in foreign policy analysis. They offer unprecedented speed, scale, and insight, particularly for navigating U.S.–China strategic tensions. But these tools must be deployed carefully: AI brings new risks, especially bias, opacity, and misalignment. The future is a hybrid model where human judgment and machine intelligence work together.

With proper governance, AI simulations can enrich national security decision-making and help avoid crises rather than accelerate them.

About the Author

Brian Curry is a Kansas City based Data Scientist, Artificial Intelligence expert and founder of Vector1 Research, a part time passion project, where he explores the frontier of Artificial Intelligence, SEO, Agentic Systems, Machine Learning, Economic Systems, Marketing Modeling, and Econometrics. His work focuses on building intelligent systems that reveal the causal structures driving performance across marketing, content, and economics and the creator of Papilon, an open-source framework for complex system optimization, Daedalus, a platform for causal and economic analysis, and the scientist behind Memory-Node Encapsulation (MNE): A Revolutionary Data Structure for Artificial Episodic Memory and Cognitive AI Reasoning.

© 2025 Brian Curry. All rights reserved. Original models, frameworks, and conceptual structures are proprietary intellectual property. Do not reproduce without permission.

References

1. Mintz, A. & DeRouen Jr., K. Understanding Foreign Policy Decision Making. Cambridge University Press, 2010.
2. Durbin, B. “Bureaucratic politics approach.” Encyclopaedia Britannica, 2024.
3. Kerr, F. “The Right to be Simulated: Digital Twins and the Rise of Geo-Algorithmic Inequality.” E-International Relations, 2023.
4. IBM. “What Is a Digital Twin?” IBM Think Blog, 2024.
5. Xue, Y. et al. “Using machine learning to forecast conflict events for use in forced migration models.” Scientific Reports, 2025.
6. Camacho-Gomez, D., et al. NPJ Systems Biology and Applications, 2025.
7. Chen, M. “Chinese team taps DeepSeek AI for military battle simulation.” South China Morning Post, 2025.
8. Atalan, Y., Reynolds, I., & Jensen, B. “AI Biases in Critical Foreign Policy Decisions.” CSIS, 2025.
9. Berkoff, R. “Could artificial intelligence make war and peace decisions?” Johns Hopkins University Hub, 2025.
10. Hua, W. et al. “WarAgent: LLM-based Multi-Agent Simulation of World Wars.” arXiv preprint, 2023.
11. World Bank / OECD. “Principles for Responsible AI,” 2024.