# Adversarial Geopolitical Equilibrium MCP Server (`ryanclinton/adversarial-geopolitical-equilibrium-mcp`) Actor

MCP intelligence server for adversarial geopolitical equilibrium detection and analysis.

- **URL**: https://apify.com/ryanclinton/adversarial-geopolitical-equilibrium-mcp.md
- **Developed by:** [ryan clinton](https://apify.com/ryanclinton) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per event + usage

This Actor is paid per event and usage. You are charged both the fixed price for specific events and for Apify platform usage.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-event

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

## Adversarial Geopolitical Equilibrium MCP Server

Interlocking incomplete-information game analysis across geopolitical arenas. Computes simultaneous Bayesian extensive-form equilibria, models strategic misperception via hypergame theory, simulates sanctions cascades on trade-weighted hypergraphs, analyzes escalation dynamics via Hamilton-Jacobi-Isaacs differential games, solves Colonel Blotto resource allocation across cyber/kinetic domains, designs alliances via Shapley value mechanism design, and forecasts regime transitions.

This MCP server wraps 16 specialized Apify actors spanning sanctions databases, trade flows, economic indicators, financial markets, legislative data, and social intelligence.

### Tools

| Tool | Description | Key Outputs |
|------|-------------|-------------|
| `compute_interlocking_equilibria` | Simultaneous PBE across trade, military, cyber, diplomatic, economic arenas | Strategies, beliefs, linkages, system stability |
| `simulate_geopolitical_agents` | Multi-agent simulation with real economic data enrichment | Equilibrium strategies, payoff distributions |
| `analyze_sanctions_cascade` | Cascade simulation on trade-weighted hypergraph | Cascade rounds, GDP impact, tipping points |
| `assess_escalation_dynamics` | HJI differential game for two-player escalation | Trajectory, peak escalation, nuclear risk, saddle point |
| `design_alliance_mechanism` | Cooperative game theory for alliance evaluation | Shapley values, core stability, superadditivity |
| `detect_strategic_misperception` | Hypergame theory for belief hierarchy analysis | Misperception gaps, exploitability, stability |
| `evaluate_cyber_kinetic_blotto` | Colonel Blotto across cyber/conventional/nuclear/economic/info domains | Allocations, expected wins, critical battlefields |
| `forecast_regime_transitions` | Multi-factor logistic regime change prediction | Transition probability, scenario type, risk factors |

### Data Sources

| Actor | Data Source | Used For |
|-------|------------|----------|
| OFAC Sanctions Search | US Treasury OFAC | Direct sanctions status |
| OpenSanctions Search | OpenSanctions DB | International sanctions/PEP |
| UN COMTRADE | UN trade database | Bilateral trade volumes for cascade modeling |
| World Bank Indicators | World Bank | GDP, governance, stability indicators |
| IMF Economic Data | IMF | Macroeconomic indicators |
| FRED Economic Data | Federal Reserve | US and global economic series |
| Finnhub Stock Data | Finnhub | Market reactions to geopolitical events |
| Congress Bill Search | Congress.gov | Sanctions legislation, defense bills |
| Federal Register | Federal Register | Executive orders, sanctions regulations |
| Congressional Stock Trades | Congress trades | Insider knowledge signals |
| Interpol Red Notices | Interpol | International fugitive data |
| WHO GHO | WHO | Health crisis data for stability modeling |
| OECD Statistics | OECD | Economic/social indicators |
| GDACS Disaster Alerts | GDACS | Natural disaster impact on stability |
| Hacker News | HN | Tech/security community intelligence |
| Bluesky Social | Bluesky | OSINT social intelligence |

### Mathematical Foundations

#### Perfect Bayesian Equilibrium (PBE)

Each geopolitical arena (trade, military, cyber, diplomatic, economic) is modeled as a Bayesian extensive-form game. Players have private types (hawkish/dovish, protectionist/free-trade, etc.) and update beliefs via Bayes' rule:

````

P(type\_j | observed) = P(observed | type\_j) \* P(type\_j) / P(observed)

```

We compute equilibria via **Quantal Response Equilibrium** (McKelvey & Palfrey 1995), a softmax generalization of Nash equilibrium that guarantees existence. Temperature parameter controls rationality (0 = perfect rationality, higher = more noise).

#### Interlocking Games

Arenas are linked: actions in one affect payoffs in others. Linkages are classified as:
- **Strategic complements**: Escalation in one arena reinforces escalation in the linked arena (e.g., trade ↔ economic)
- **Strategic substitutes**: Escalation in one reduces incentive in the other (e.g., military ↔ diplomatic)
- **Independent**: No significant cross-arena effect

#### Hypergame Theory (Bennett 1977)

Models situations where players disagree about what game is being played. Each player has a **subjective game** that may differ from the objective game and from other players' subjective games. Belief hierarchy: what A thinks B thinks C believes...

Misperception is the primary cause of unintended escalation in international relations.

#### Colonel Blotto (Borel 1921, Roberson 2006)

Two or more players allocate limited resources across N battlefields simultaneously. Each battlefield is won by the player who allocates more. The Nash equilibrium involves mixed strategies on the resource simplex.

For asymmetric resources, the weaker player concentrates on fewer battlefields while the stronger player spreads thin — creating strategic vulnerability.

#### Hamilton-Jacobi-Isaacs (HJI) PDE

Escalation is modeled as a continuous-time differential game:

```

dV/dt + H(x, nabla V) = 0

````

where V is the value function and H is the Hamiltonian coupling both players' optimal controls. The state vector x = (escalation_level, posture_1, posture_2, crisis_intensity, deescalation_pressure) evolves under coupled dynamics with stochastic shocks.

**Saddle point**: The point where escalation direction reverses — the highest escalation the system reaches before deescalation forces dominate.

#### Cooperative Game Theory

Alliance evaluation uses:
- **Shapley value**: Fair allocation based on marginal contribution across all possible coalitions
- **Core**: Set of allocations where no sub-coalition has incentive to deviate
- **Nucleolus**: Lexicographic minimization of worst-off coalition's excess
- **Superadditivity**: v(S union T) >= v(S) + v(T) — coalition is worth more than parts

#### Sanctions Cascade

Threshold model on directed weighted trade hypergraph:
1. Direct sanctions set target nodes to severity 1.0
2. Each round: cumulative pressure from sanctioned trade partners computed
3. When pressure > resilience threshold, node becomes sanctioned
4. Secondary sanctions compliance pressure amplifies cascade
5. GDP impact estimated at 15% per unit of sanctions severity

### Supported Countries

20 major state actors with baseline parameters:

US, CN, RU, GB, FR, DE, JP, IN, KR, AU, IL, IR, SA, TR, BR, KP, UA, TW, PK, PL

### Connection

#### Claude Desktop

```json
{
  "mcpServers": {
    "geopolitical-equilibrium": {
      "type": "url",
      "url": "https://adversarial-geopolitical-equilibrium-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN"
    }
  }
}
````

#### Direct HTTP

```bash
curl -X POST https://adversarial-geopolitical-equilibrium-mcp.apify.actor/mcp?token=YOUR_APIFY_TOKEN \
  -H "Content-Type: application/json" \
  -d '{
    "jsonrpc": "2.0",
    "method": "tools/call",
    "params": {
      "name": "analyze_sanctions_cascade",
      "arguments": {
        "target_countries": ["RU"],
        "all_countries": ["US", "CN", "RU", "GB", "DE", "JP", "IN", "TR"]
      }
    },
    "id": 1
  }'
```

### Example Conversations

#### Sanctions Cascade Analysis

> **User**: What would happen if the US imposed comprehensive sanctions on Russia? Who else gets pulled in?
>
> **Assistant**: *Calls `analyze_sanctions_cascade` with target\_countries=\["RU"] and all\_countries=\["US","CN","RU","GB","DE","JP","IN","TR","KR","AU","BR","SA"]*
>
> The cascade simulation ran 4 rounds. Direct sanctions on Russia propagated to 5 additional countries:
>
> - Round 1: Turkey (trade exposure 0.45, above threshold 0.40)
> - Round 2: India (secondary sanctions compliance pressure from US)
> - Round 3: Brazil (cascaded from India trade linkage)
> - Total GDP impact: $890B across all affected actors
> - Trade disruption: 12.3% of simulated global trade

#### Escalation Dynamics

> **User**: How would a US-China crisis over Taiwan escalate?
>
> **Assistant**: *Calls `assess_escalation_dynamics` with player1="US", player2="CN", initial\_crisis\_intensity=0.7*
>
> HIGH ESCALATION: Peak 6.8/10 reached at t=3.2. Saddle point at level 6.8 — this is where deescalation pressure from international community begins to dominate. Nuclear risk peaked at 4.2%. Stable equilibrium at 2.3 — the crisis eventually settles to moderate tension. Time to deescalation: t=5.4.

#### Alliance Design

> **User**: Is the QUAD alliance (US, JP, IN, AU) stable?
>
> **Assistant**: *Calls `design_alliance_mechanism` with countries=\["US","JP","IN","AU"]*
>
> Alliance is VIABLE: superadditive with 2 core-stable formations. Shapley values: US contributes 42% of coalition value, Japan 24%, India 20%, Australia 14%. The US-Japan sub-alliance is the strongest component. India's inclusion is marginally stable — removing geographic diversity bonus would make it unprofitable.

### Limitations

- Baseline actor parameters are approximate and may not reflect current conditions
- PBE computation uses quantal response (bounded rationality) — pure strategy Nash equilibria may exist but not be found
- Sanctions cascade uses simplified gravity model for trade linkages — real trade networks have more complex structure
- HJI escalation dynamics are stochastic — results vary between runs
- Hypergame analysis uses heuristic perception rules — real misperceptions are more nuanced
- Blotto equilibrium is approximate (exact mixed strategy equilibria require continuous distributions)
- Regime transition model is structural, not predictive of specific trigger events

### Tips

- **Start with compute\_interlocking\_equilibria** for a broad overview, then drill down
- **analyze\_sanctions\_cascade works best with 8+ countries** — include major trade partners of targets
- **assess\_escalation\_dynamics is most useful for bilateral crises** — it's a 2-player game
- **design\_alliance\_mechanism needs 3+ countries** — use for evaluating coalition proposals
- **detect\_strategic\_misperception reveals WHY miscalculations happen** — pair with escalation analysis
- **forecast\_regime\_transitions benefits from real data** — enable economic data and news enrichment

# Actor input Schema

## Actor input object example

```json
{}
```

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("ryanclinton/adversarial-geopolitical-equilibrium-mcp").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("ryanclinton/adversarial-geopolitical-equilibrium-mcp").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call ryanclinton/adversarial-geopolitical-equilibrium-mcp --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ryanclinton/adversarial-geopolitical-equilibrium-mcp",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "Adversarial Geopolitical Equilibrium MCP Server",
        "description": "MCP intelligence server for adversarial geopolitical equilibrium detection and analysis.",
        "version": "1.0",
        "x-build-id": "PZZkzrA7R2C0YTVAf"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ryanclinton~adversarial-geopolitical-equilibrium-mcp/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ryanclinton-adversarial-geopolitical-equilibrium-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ryanclinton~adversarial-geopolitical-equilibrium-mcp/runs": {
            "post": {
                "operationId": "runs-sync-ryanclinton-adversarial-geopolitical-equilibrium-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ryanclinton~adversarial-geopolitical-equilibrium-mcp/run-sync": {
            "post": {
                "operationId": "run-sync-ryanclinton-adversarial-geopolitical-equilibrium-mcp",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {}
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```
