Systemic Risk Contagion MCP Server

> View on ApifyForge | Use on Apify Store

---

Quick Start

Add to your MCP client (Claude Desktop, Cursor, Windsurf):

{
  "mcpServers": {
    "systemic-risk-contagion-mcp": {
      "url": "https://ryanclinton--systemic-risk-contagion-mcp.apify.actor/mcp"
    }
  }
}

---

Systemic risk contagion analysis for financial networks, delivered as an MCP server your AI agent connects to directly. This server orchestrates 16 data sources spanning corporate registries, SEC filings, FDIC bank data, macroeconomic indicators, market prices, cryptocurrency, and sanctions lists to construct 4-layer multiplex financial networks and run rigorous quantitative analysis. It identifies globally and domestically systemically important banks (G-SIBs and D-SIBs), simulates cascade failures, detects stress clustering, and generates full financial stability reports — all from a single natural-language query.

The server implements four published mathematical frameworks: DebtRank (Battiston et al. 2012), Eisenberg-Noe clearing vectors (2001), multivariate Hawkes self-exciting processes, and supra-adjacency tensor spectral decomposition. Each query triggers 16 Apify actors running in parallel, assembles a multiplex network with inter-layer coupling tensors, and applies the selected algorithm. Use it from Claude Desktop, Cursor, Windsurf, or any MCP-compatible client.

⬇️ What data can you access?

| Data Point | Source | Example Use in Network |
|---|---|---|
| 📋 Corporate registrations and global ownership chains | OpenCorporates (up to 60 results) | Ownership layer edges |
| 🔗 Legal Entity Identifiers with parent-child hierarchy | GLEIF LEI (up to 40 results) | Ownership layer, subsidiary bonds |
| 📄 SEC 10-K, 10-Q, and 8-K annual/quarterly filings | EDGAR Filings (up to 60 results) | Financial exposure layer |
| 🏛 Regulatory filings, SEC enforcement and analysis | SEC EDGAR Analyzer (up to 40 results) | Financial exposure layer |
| 👤 Form 4 executive insider stock transactions | SEC Insider Trading (up to 40 results) | Political layer signal |
| 🏦 US bank financial condition and call reports | FDIC Bank Search (up to 60 results) | Bank nodes, interbank edges |
| 📈 Stock prices, quotes, and market data | Finnhub Stock Data (up to 40 results) | Market correlation layer |
| 📊 Federal Reserve macroeconomic indicator series | FRED Economic Data (up to 40 results) | Indicator nodes, macro context |
| 👷 Employment, inflation, and wage statistics | BLS Economic Data (up to 30 results) | Macro stress signals |
| 🌍 IMF World Economic Outlook data | IMF Economic Data (up to 30 results) | Sovereign nodes |
| 🌐 World Bank development and governance indicators | World Bank Indicators (up to 30 results) | Cross-border exposure |
| 🪙 Cryptocurrency prices and market capitalization | CoinGecko Crypto Data (up to 30 results) | Crypto layer nodes |
| 💱 Foreign exchange rates and FX co-movement | Exchange Rate Tracker (up to 20 results) | Market correlation layer |
| 🏛 Congressional stock trading disclosures (STOCK Act) | Congress Stock Tracker (up to 30 results) | Political shock layer |
| 🚫 OFAC sanctions and blocked persons/entities | OFAC Sanctions Search (up to 40 results) | Sanctions layer edges |
| ⚠️ Consumer financial complaint patterns | CFPB Complaints (up to 40 results) | Retail stress signals |

❓ Why use the Systemic Risk Contagion MCP Server?

Building a systemic risk model manually requires subscribing to Bloomberg Terminal ($24,000/year), hiring a quant analyst to write network code, and licensing exposure data that central banks spend years assembling. Even then, most practitioners use only a single data layer — credit exposures alone — missing the cross-layer amplification dynamics that caused the 2008 cascade.

This server assembles all 16 publicly available data sources, constructs a 6-layer multiplex network including ownership, financial exposure, market correlation, supply chain, sanctions, and political layers, and applies the exact algorithms used in academic systemic risk literature. For $0.045 per tool call.

Platform benefits:
- Always-on standby — the server runs persistently via Apify's standby mode, responding to MCP requests in seconds without cold-start delays
- API access — connect from Claude Desktop, Cursor, Windsurf, Cline, or any HTTP client using the /mcp endpoint
- Spend controls — set a maximum spend per session so a runaway agent cannot exceed your budget
- Scheduled analysis — use Apify Scheduler to run recurring stability monitoring and track regime changes over time
- Webhooks — trigger downstream alerts when branching ratios or spectral radii exceed defined thresholds

MCP Tools

| Tool | Price | Description |
|------|-------|-------------|
| build_systemic_network | $0.045 | Construct a 6-layer multiplex financial network from all 16 data sources with inter-layer coupling tensors |
| compute_debtrank | $0.045 | DebtRank (Battiston et al. 2012): rank each entity by fraction of total economic value its distress affects |
| simulate_cascade_failure | $0.045 | Eisenberg-Noe (2001) fixed-point clearing with Fictitious Default Algorithm: simulate round-by-round default propagation |
| identify_critical_nodes | $0.045 | Supra-adjacency spectral analysis: identify systemically critical entities and determine subcritical/critical/supercritical regime |
| detect_stress_clustering | $0.045 | Multivariate Hawkes self-exciting process: detect whether stress events are clustering and approaching critical branching ratio |
| model_sanctions_shock | $0.045 | BFS stress propagation with 60% LGD: estimate direct and indirect systemic impact of sanctions-induced network severing |
| compute_contagion_channels | $0.045 | Supra-adjacency tensor decomposition: identify dominant cross-layer transmission pathways and amplification ratios |
| generate_stability_report | $0.045 | Comprehensive stability report: all algorithms combined, threshold-based alerts, and actionable recommendations |

Use cases for systemic risk contagion analysis

G-SIB and D-SIB identification

Prudential regulators, financial stability boards, and risk managers at large banks need to quantify systemic importance. Run compute_debtrank against a sector like "US banking sector" or a specific institution like "JPMorgan Chase counterparty network" to rank entities by their DebtRank score — the fraction of total economic value affected by their individual distress. The output classifies each entity as G-SIB, D-SIB, or non-systemic based on threshold analysis, giving you a rigorous ranking without requiring proprietary bilateral exposure data.

Stress testing and resolution planning

Resolution planners and risk officers need to know how an initial shock amplifies. Run simulate_cascade_failure to apply the Eisenberg-Noe clearing payment framework: each node pays the minimum of its obligations and available assets, the shortfall propagates to creditors, and the algorithm iterates to the fixed-point clearing vector. The output shows defaults per round, cumulative loss, cascade depth, and convergence iterations — exactly the format needed for regulatory stress test documentation.

Criticality regime assessment

Central bank researchers and macro-prudential supervisors need to know whether the current system configuration is in subcritical, critical, or supercritical regime. identify_critical_nodes builds the NL x NL supra-adjacency matrix (intra-layer blocks plus inter-layer coupling tensors), computes its largest eigenvalue via power iteration, and classifies the regime. Supercritical means cross-layer cascades amplify rather than dampen — the signal that regulatory intervention is warranted.

Temporal stress event monitoring

Risk surveillance teams tracking early-warning indicators use detect_stress_clustering to run the multivariate Hawkes process EM estimation. The branching ratio (spectral radius of alpha/beta) is the key output: values approaching 1 indicate the system is becoming self-exciting, where each stress event triggers additional events. This provides a lead indicator of instability before defaults materialize.

Sanctions compliance stress testing

Compliance officers at banks with exposure to potentially sanctioned jurisdictions or entities use model_sanctions_shock to estimate contagion before new sanctions are imposed. The model severs network connections for sanctioned entities, propagates stress through BFS with a 60% loss-given-default assumption, and triggers further propagation when any node's loss exceeds 10% of equity. Output includes direct vs indirect impact and propagation depth per entity.

Cross-layer contagion channel mapping

Quantitative researchers and systemic risk academics use compute_contagion_channels to understand the mechanism of contagion, not just its severity. Supra-adjacency tensor decomposition identifies which layer-to-layer pathways carry the most amplification — for example, whether ownership-to-financial_exposure coupling or market_correlation-to-supply_chain coupling is the dominant transmission channel. The cross-layer amplification ratio shows how much worse multiplex contagion is than any single-layer model would predict.

How to connect this MCP server

Step 1: Get your Apify API token

Sign up at apify.com and find your token at Settings > Integrations > API token. The Apify Free plan includes $5 of monthly credits.

Step 2: Add to your MCP client

Claude Desktop — add to claude_desktop_config.json:

{
  "mcpServers": {
    "systemic-risk-contagion": {
      "url": "https://systemic-risk-contagion-mcp.apify.actor/mcp",
      "headers": {
        "Authorization": "Bearer YOUR_APIFY_TOKEN"
      }
    }
  }
}

Cursor / Windsurf / Cline — add the same URL in your MCP server settings panel. The endpoint is https://systemic-risk-contagion-mcp.apify.actor/mcp.

Step 3: Run your first analysis

Ask your AI assistant:

> "Use the systemic risk MCP to compute DebtRank for the US banking sector and identify the top G-SIBs."

> "Run a cascade failure simulation for Goldman Sachs counterparty network and show me the default rounds."

> "Generate a full stability report for the European banking sector."

Step 4: Interpret the results

Each tool returns structured JSON with the algorithmic output, network statistics, and interpretation signals. The generate_stability_report tool includes explicit threshold-breach flags and written recommendations.

Input parameters

This is an MCP server. It has no Apify actor input schema — configuration is entirely through your MCP client. Each tool accepts a single parameter:

| Parameter | Type | Required | Description |
|-----------|------|----------|-------------|
| query | string | Yes | Financial entity, sector, or systemic risk topic to analyze. Examples: "US banking sector", "Goldman Sachs counterparty network", "European sovereign debt", "crypto exchange systemic risk" |

All 16 data sources are queried using this string. More specific queries produce more focused network construction.

Query examples

Sector-level systemic risk:

"US banking sector 2024"

Single institution counterparty analysis:

"JPMorgan Chase counterparty network"

Geographic cross-border contagion:

"European banking systemic risk"

Asset class specific:

"crypto exchange systemic risk contagion"

Sanctions impact modeling:

"Russian banking sector OFAC sanctions impact"

Input tips

- Specific entity names produce denser networks — "Citibank" fetches more targeted FDIC and EDGAR data than "banking".
- Sector queries reveal macro-level structure — "US insurance sector" captures cross-entity correlation and supply chain layers better than single-institution queries.
- Add geographic context for cross-border analysis — "European sovereign debt" triggers stronger IMF and World Bank data retrieval.
- Use generate_stability_report for initial exploration — it runs all algorithms in one call, giving you the full picture before drilling into specific tools.
- Chain tools sequentially for deep analysis — start with build_systemic_network to understand network structure, then compute_debtrank for ranking, then simulate_cascade_failure for scenario stress testing.

⬆️ Output example

compute_debtrank — US banking sector:

{
  "query": "US banking sector",
  "networkSize": 147,
  "rankings": [
    {
      "entity": "FirstNational Bancorp",
      "debtRank": 0.312,
      "relativeImpact": 0.418,
      "tier": "G-SIB"
    },
    {
      "entity": "Meridian Trust Bank",
      "debtRank": 0.187,
      "relativeImpact": 0.251,
      "tier": "G-SIB"
    },
    {
      "entity": "Pinnacle Capital Group",
      "debtRank": 0.094,
      "relativeImpact": 0.127,
      "tier": "D-SIB"
    },
    {
      "entity": "Coastal Community Bank",
      "debtRank": 0.021,
      "relativeImpact": 0.028,
      "tier": "non-systemic"
    }
  ],
  "systemicLoss": 0.743,
  "averageDebtRank": 0.048,
  "gSibCount": 6
}

generate_stability_report — European banking sector:

{
  "query": "European banking systemic risk",
  "networkSize": 203,
  "edgeCount": 1847,
  "metrics": [
    { "metric": "network_density", "value": 0.089, "threshold": 0.05, "breached": true },
    { "metric": "average_leverage", "value": 18.4, "threshold": 15.0, "breached": true },
    { "metric": "asset_concentration_hhi", "value": 0.241, "threshold": 0.25, "breached": false },
    { "metric": "cross_border_exposure", "value": 0.63, "threshold": 0.50, "breached": true },
    { "metric": "crypto_exposure_ratio", "value": 0.031, "threshold": 0.10, "breached": false },
    { "metric": "hawkes_branching_ratio", "value": 0.71, "threshold": 0.80, "breached": false },
    { "metric": "supra_spectral_radius", "value": 1.14, "threshold": 1.00, "breached": true }
  ],
  "overallRisk": "elevated",
  "riskScore": 68,
  "debtRankSummary": {
    "systemicLoss": 0.812,
    "gSibCount": 8,
    "averageDebtRank": 0.062
  },
  "cascadeSummary": {
    "totalDefaults": 12,
    "totalLoss": 0.341,
    "cascadeDepth": 4
  },
  "hawkesSummary": {
    "branchingRatio": 0.71,
    "criticalityIndicator": "moderate — stress events clustering but below critical threshold"
  },
  "spectralSummary": {
    "spectralRadius": 1.14,
    "regime": "supercritical — cross-layer cascades amplify"
  },
  "recommendations": [
    "Spectral radius exceeds 1.0: system is in supercritical regime. Cross-layer cascade amplification is active.",
    "Network density and leverage breach thresholds simultaneously — heightened contagion probability.",
    "Cross-border exposure at 63% suggests significant foreign contagion transmission pathways.",
    "Monitor Hawkes branching ratio — currently 0.71 but trending toward critical threshold of 0.80."
  ],
  "dataSources": {
    "corporates": 58,
    "leis": 37,
    "filings": 54,
    "banks": 61,
    "stocks": 39,
    "crypto": 28,
    "sanctions": 42,
    "totalActors": 16
  }
}

Output fields

| Field | Type | Description |
|-------|------|-------------|
| query | string | The input query used for all 16 data source lookups |
| networkSize | number | Total number of nodes (banks, corporations, sovereigns, crypto, indicators) |
| edgeCount | number | Total number of edges across all layers |
| rankings[] | array | DebtRank per entity (compute_debtrank only) |
| rankings[].entity | string | Entity name |
| rankings[].debtRank | number | DebtRank score 0–1 (fraction of total economic value affected) |
| rankings[].relativeImpact | number | Relative impact normalized to largest node |
| rankings[].tier | string | "G-SIB", "D-SIB", or "non-systemic" |
| systemicLoss | number | Total fraction of system value at risk (DebtRank aggregate) |
| gSibCount | number | Count of G-SIB classified entities |
| steps[] | array | Per-round cascade data (simulate_cascade_failure only) |
| steps[].round | number | Default propagation round number |
| steps[].defaulted | string[] | Entity names that defaulted in this round |
| steps[].cumulativeLoss | number | Cumulative system loss at this round |
| steps[].survivingNodes | number | Remaining solvent nodes |
| totalDefaults | number | Total entities that defaulted across all rounds |
| cascadeDepth | number | Number of rounds until cascade terminated |
| clearingVector | number[] | Eisenberg-Noe fixed-point clearing payment vector |
| convergenceIterations | number | Fictitious Default Algorithm convergence count |
| criticalNodes[] | array | Systemically critical entities (identify_critical_nodes only) |
| criticalNodes[].eigenvectorCentrality | number | Eigenvector centrality score |
| criticalNodes[].betweenness | number | Betweenness centrality across multiplex layers |
| criticalNodes[].spectralImportance | number | Contribution to largest supra-adjacency eigenvalue |
| criticalNodes[].removalImpact | number | Spectral radius reduction if node removed |
| spectralRadius | number | Largest eigenvalue of the supra-adjacency matrix |
| systemicCriticalityRegime | string | "subcritical", "critical", or "supercritical" |
| algebraicConnectivity | number | Fiedler value — lower values indicate more fragile network structure |
| clusters[] | array | Stress clusters (detect_stress_clustering only) |
| clusters[].hawkesIntensity | number | Event intensity at cluster formation |
| branchingRatio | number | Hawkes spectral radius of alpha/beta — approaches 1 at critical instability |
| shocks[] | array | Per-entity sanctions impact (model_sanctions_shock only) |
| shocks[].directImpact | number | Loss from direct sanctions exposure |
| shocks[].indirectImpact | number | Loss from counterparty propagation |
| shocks[].propagationDepth | number | BFS hop depth of indirect impact |
| channels[] | array | Cross-layer contagion pathways (compute_contagion_channels only) |
| channels[].fromLayer | string | Source network layer |
| channels[].toLayer | string | Destination network layer |
| channels[].strength | number | Channel transmission strength |
| crossLayerAmplification | number | Ratio of multiplex vs single-layer contagion severity |
| dominantChannel | string | Layer pair carrying the most contagion risk |
| metrics[] | array | Threshold-tested stability metrics (generate_stability_report only) |
| metrics[].breached | boolean | Whether the metric exceeds its regulatory threshold |
| overallRisk | string | "low", "moderate", "elevated", "high", or "critical" |
| riskScore | number | Composite risk score 0–100 |
| recommendations | string[] | Actionable findings derived from threshold breaches and regime analysis |

How much does it cost to run systemic risk contagion analysis?

Each tool call costs $0.045. Platform compute costs are included. All 16 actors run in parallel per call, so the cost per data point is exceptionally low for the volume processed.

| Scenario | Tool Calls | Cost per Call | Total Cost |
|----------|-----------|---------------|------------|
| Quick test (one DebtRank run) | 1 | $0.045 | $0.045 |
| Standard analysis (4 tools) | 4 | $0.045 | $0.18 |
| Full 8-tool suite (all algorithms) | 8 | $0.045 | $0.36 |
| Weekly monitoring (stability report x4) | 4 | $0.045 | $0.18 |
| Enterprise (100 runs/month) | 100 | $0.045 | $4.50 |

The Apify Free plan includes $5 of monthly credits — enough for 111 tool calls per month at no cost.

Compare this to Bloomberg Terminal at $24,000/year or a dedicated quant infrastructure build at $50,000+ in engineering time. With this server, a monthly budget of $10–20 covers comprehensive ongoing monitoring.

You can set a maximum spending limit per MCP session using Apify's spend controls. The server stops and returns an error when your budget is reached, preventing runaway agent costs.

How the Systemic Risk Contagion MCP works

Phase 1: Parallel data collection across 16 sources

Each tool call triggers 16 Apify actors via Promise.all() — all running simultaneously with individual 120-second timeouts. Actors are grouped by domain: corporate registries (OpenCorporates, GLEIF), financial regulators (EDGAR, SEC, FDIC, CFPB), market data (Finnhub, CoinGecko, Exchange Rates, Congress Stock), macroeconomic indicators (FRED, BLS, IMF, World Bank), and sanctions (OFAC). Failed actors return empty arrays and are gracefully excluded from network construction rather than causing the entire call to fail.

Phase 2: Multiplex network construction

buildMultiplexNetwork() ingests all 16 data streams and constructs typed FinancialNode objects for 8 entity types: bank, insurer, fund, corporation, sovereign, exchange, crypto, and indicator. FDIC bank records become bank nodes with assets, liabilities, equity, and leverage fields. OpenCorporates records become corporation nodes with sector and jurisdiction. IMF records become sovereign nodes. FRED series become indicator nodes (capped at 20 to control network size).

The function then builds four N×N adjacency matrices: ownership (from GLEIF parent-child LEI relationships and corporate registry structures), financial_exposure (from SEC filing exposure data and FDIC interbank indicators), market_correlation (from stock return co-movement, crypto prices, and FX co-movement), and supply_chain (inferred from sector co-occurrence). A third-order inter-layer coupling tensor C[l1][l2][i] captures how each node's connections correlate across layer pairs — the mechanism through which multiplex amplification occurs.

Phase 3: Algorithm execution

DebtRank (computeDebtRank): Each node is individually shocked to distress level 1.0. Stress propagates iteratively through the financial_exposure layer weight matrix W[i][j] = exposure[i][j] / equity[j]. Each iteration: h[j] = min(1, h[j] + Σ_i W[i][j] h[i]), stopping when no node's stress changes by more than 0.001. DebtRank for node k = Σ_j (h_j^final - h_j^initial), normalized by total system equity. Nodes with DebtRank > 0.10 are classified G-SIB; > 0.05 D-SIB.

Eisenberg-Noe clearing (simulateCascadeFailure): The Fictitious Default Algorithm computes the fixed-point clearing vector. Each iteration sets p[i] = min(p_bar[i], assets[i] + Σ_j (L[j][i]/p_bar[j]) p[j]) where p_bar[i] is total obligations and L is the liability matrix. The algorithm iterates until convergence (typically < 20 iterations). The cascade simulation then applies an initial shock (20% asset loss to the highest-exposure node) and propagates defaults in BFS rounds.

Supra-adjacency spectral analysis (identifyCriticalNodes): Builds the NL×NL supra-adjacency matrix with intra-layer blocks on the diagonal and inter-layer coupling matrices on off-diagonal blocks. Power iteration computes the largest eigenvalue. If this exceeds 1.0, the system is supercritical — perturbations grow rather than decay. Eigenvector centrality identifies the nodes most responsible for the supercritical regime.

Multivariate Hawkes EM (detectStressClustering): Estimates λ_i(t) = μ_i + Σ_j α_ij Σ_{t_k<t} βexp(-β(t-t_k)) via 10 EM iterations. E-step computes event responsibilities; M-step updates μ, α, and β. The branching ratio is ρ = spectral_radius(α/β) — the key criticality indicator. Nodes with correlated stress histories are grouped into clusters via threshold-based adjacency.

Supra-adjacency tensor decomposition (computeContagionChannels): Evaluates all ordered layer pairs as contagion channels. Channel strength is proportional to the inter-layer coupling magnitude and the product of each layer's spectral radius. The CP tensor rank estimates the minimum number of rank-1 components needed to represent the full cross-layer transmission structure — a measure of contagion pathway complexity.

Tips for best results

1. Start with generate_stability_report before drilling into individual tools. It runs all algorithms in one $0.045 call and gives you the full picture — regime classification, DebtRank summary, cascade depth, Hawkes branching ratio, and written recommendations — so you know which specific tools to run next.

2. Use institution names for exposure mapping, sector terms for systemic structure. "Bank of America interbank lending" produces a denser financial_exposure layer. "US commercial banking sector" produces a broader market_correlation layer with more nodes, better for sector-level criticality analysis.

3. Track branching ratio trends over time. The Hawkes branching ratio is the most sensitive early-warning indicator. Schedule weekly detect_stress_clustering runs and alert when the ratio moves above 0.70 (elevated) or 0.85 (critical warning zone).

4. Interpret spectral radius relative to 1.0, not in absolute terms. A spectral radius of 1.05 is more dangerous than 0.95, not because the difference is large, but because 1.0 is the phase transition point between subcritical damping and supercritical amplification.

5. Combine sanctions and cascade tools for compliance stress testing. Run model_sanctions_shock first to identify which entities propagate the most indirect impact, then run simulate_cascade_failure with those entities as the initial shock source to model worst-case cascade scenarios.

6. Set Apify spend limits to prevent agent cost overruns. An AI agent running in a loop could call all 8 tools multiple times. Set a session spend limit of $2–5 for exploratory analysis and $10–20 for comprehensive monitoring workflows.

7. Cross-reference identify_critical_nodes output with compute_debtrank. High DebtRank entities cause large losses when distressed; high spectral importance entities are structural bottlenecks. Entities appearing in both lists are the highest-priority systemic concerns.

Combine with other Apify MCP servers

| Actor | How to combine |
|-------|----------------|
| Sovereign Debt Contagion MCP | Run sovereign contagion analysis alongside this server to extend network coverage to sovereign-to-bank transmission channels |
| Sanctions Network Analysis MCP | Use this server's model_sanctions_shock output as input to sanctions network analysis for deeper evasion route mapping |
| SEC EDGAR Filing Analyzer | Pull targeted 10-K/10-Q exposure data for specific institutions to enrich the financial_exposure layer with exact bilateral figures |
| FDIC Bank Search | Query specific bank call report data to validate and enrich FDIC-sourced nodes in the network |
| OFAC Sanctions Search | Cross-reference entities flagged by model_sanctions_shock against live OFAC lists for compliance documentation |
| Company Deep Research | Generate detailed intelligence reports on the G-SIBs identified by compute_debtrank for qualitative context |
| Investment Alternative Data MCP | Combine systemic risk regime classification with alternative investment signals for risk-adjusted portfolio decisions |

Limitations

- No private bilateral exposure data. The financial_exposure layer is constructed from public SEC filings, FDIC call reports, and EDGAR data. Actual bilateral derivative and repo exposure data held on bank balance sheets is not publicly available. Results should be treated as scenario analysis, not precise exposure measurement.
- Network construction is query-dependent. The 16 actors all use your query string for search. A specific institution query produces a denser, more focused network. A vague query produces a sparser network with lower analytical confidence.
- 16-actor parallel execution takes 60–120 seconds. Each tool call waits for all 16 data sources with a 120-second per-actor timeout. Total wall-clock time is bounded by the slowest actor. Budget 2–3 minutes per tool call.
- Hawkes process estimates require sufficient event history. The EM estimation needs enough stress events in the network to produce reliable branching ratio estimates. Very sparse networks (fewer than 20 nodes) will produce lower-confidence Hawkes parameters.
- Cryptocurrency exposure is limited to CoinGecko public data. DeFi protocol interconnections and on-chain exposure data are not captured. Crypto layer reflects market price co-movement only, not smart contract counterparty risk.
- Political shock layer relies on STOCK Act disclosures. Congressional trading data provides a directional signal for sector political risk, but the methodology is necessarily inferential — significant trading volume in a sector correlates with regulatory or policy risk.
- OFAC sanctions data reflects the current list. Historical sanctions exposure (entities that have since been delisted) is not captured. For historical analysis, supplement with archived OFAC data.
- The server does not provide investment advice. All outputs are quantitative risk model results derived from public data. They do not constitute financial advice, regulatory guidance, or official systemic risk assessments.

Integrations

- Apify API — trigger systemic risk analysis programmatically from Python, JavaScript, or any HTTP client for automated monitoring pipelines
- Webhooks — fire alerts to Slack, PagerDuty, or custom endpoints when stability report risk scores breach defined thresholds
- Apify Scheduler — schedule weekly or daily stability report runs to track Hawkes branching ratio and spectral radius trends over time
- LangChain / LlamaIndex — embed systemic risk tools in agentic financial analysis workflows using the MCP protocol
- Claude Desktop — connect directly via the MCP server URL for interactive systemic risk Q&A and scenario analysis

#