Counterparty Concentration & Network Risk

M-052 models reinsurance counterparty credit and contagion risk across the 15-firm life-insurance peer set. The engine (CounterpartyNetwork, insmodel.L3.counterparty_network) is a directed weighted graph, not an actuarial projection: nodes are firms and external reinsurers, and edges are ceded reinsurance recoverables (the cedant's credit exposure to the reinsurer). The model answers three questions — how concentrated is the network, what does a single counterparty downgrade cost the system, and does that loss cascade when an impaired counterparty is itself a reinsurer to others.

Graph construction (build_from_filing_data). Firm nodes are created from FIRM_PROFILES (the calibration profiles carrying disclosed-figure total_assets_B and reinsurance_recoverables_M per firm). Edges come from the hard-coded KNOWN_RELATIONSHIPS table — ~35 cedant→reinsurer pairs with a dollar exposure_M and a structure string (coinsurance, modco, funds_withheld, indemnity, etc.) transcribed from FilingAnalysis D2 counterparty maps (e.g. CRBG→Fortitude Re $24.1B modco/funds-withheld; JXN→Athene(APO) $15.5B; PFG→Talcott Resolution $18.3B). Two non-credit edge types — asset_management (e.g. CRBG→Blackstone $71.2B) and parent (GA→KKR) — are excluded from the credit graph because they are not recoverables exposures. An edge is flagged collateralized when its structure string contains funds_withheld or modco, the rationale being that modco/funds-withheld structures retain assets on the cedant's balance sheet and so materially reduce loss-given-default.

Residual "Other Reinsurers" plug. After mapping named relationships, the engine compares each firm's total disclosed reinsurance_recoverables_M against the sum of its named edges. Any residual above $100M is booked as a single synthetic edge to an Other Reinsurers node (credit quality 0.90, collateralized). This closes the disclosed total but collapses the entire unnamed long tail of each firm's reinsurance program into one node — a material modelling choice (see Limitations 1 and is visible in the snapshot: Other Reinsurers is both the largest single edge ($45.3B, GA) and the largest aggregate counterparty ($114.0B).

Concentration metrics (get_concentration_metrics). Exposure is aggregated per counterparty across all cedants. The engine reports: the largest single edge; a system-wide HHI computed as the sum of squared percentage shares of each counterparty's aggregate exposure (0–10,000 scale); a per-firm HHI and per-firm single-name concentration (max counterparty share); and the top-3 counterparties by aggregate. HHI is the standard Herfindahl-Hirschman concentration measure applied to counterparty shares rather than market shares.

Single-counterparty stress (stress_counterparty). A named counterparty is downgraded by rating_downgrade notches (clamped to 1–6). The notch count maps to a base_haircut via the fixed DOWNGRADE_HAIRCUTS schedule (1→5%, 2→10%, 3→20%, 4→35%, 5→50%, 6→75%) — a convex severity curve. The effective haircut applied to each exposure is base_haircut × collateral_factor × quality_factor, clamped so the effective haircut never exceeds 1.0 (min(1.0, …)). The collateral_factor is 0.5 for collateralized (modco / funds-withheld) edges and 1.0 otherwise. The quality_factor is 1 + QUALITY_SENSITIVITY × (1 − credit_quality) with QUALITY_SENSITIVITY = 0.50, so a weaker counterparty (lower credit_quality) suffers a larger recoverable loss on the same downgrade — e.g. a counterparty at credit_quality = 0.85 (Fortitude Re) carries quality_factor = 1.075, while a credit_quality = 1.0 counterparty leaves the haircut unchanged (quality_factor = 1.0). Per-firm losses are exposure_M × effective_haircut, summed to total_system_loss_M. The haircut is a proxy for loss-given-default: it represents the writedown a cedant takes on recoverables when the reinsurer's credit deteriorates, not a probability of default.

Contagion cascade (compute_cascade_impact). After the direct stress, the engine looks for second-order losses. For each firm impaired by the direct event, it computes a credit-quality hit loss_M / total_assets_M (capped at 0.5, i.e. ~3 notches). If that impaired firm is itself named as a reinsurer to other firms in the graph, those downstream cedants take a secondary haircut quality_hit × (0.5 if collateralized else 1.0) on their exposure to it. Secondary losses above a $10K floor are recorded in a cascade_chain of (source_firm, target_firm, loss) tuples. The cascade is single-hop — it does not iterate to third-order effects, and it only fires when an impaired firm's ticker coincides with a reinsurer name in the graph (in this peer set, only RGA satisfies that). This is why the Fortitude Re stress produces zero cascade (CRBG/LNC/UNM are not reinsurers to others) and the snapshot deliberately routes its cascade demonstration through Other Reinsurers, whose cedants include RGA.

Operational notes. The haircut schedule and the 50% collateral credit are model-design parameters, not calibrated experience: counterparty risk here is the risk that these LGD proxies are mis-set relative to true recovery, not parameter-estimation error on a fitted distribution. The exposure figures are point-in-time disclosed recoverables (FY2024 10-Ks), so the network is a single as-of snapshot with no roll-forward. As of the 2026-06-05 engine change (commit aa4d2eb / PR #75), the per-node credit_quality / COUNTERPARTY_CREDIT scalar is consumed by the single-counterparty stress: it enters the effective haircut as a linear amplifier quality_factor = 1 + QUALITY_SENSITIVITY × (1 − credit_quality) (QUALITY_SENSITIVITY = 0.50), so a BBB+ name and an AA name no longer produce identical losses for the same notch shock. It remains a coarse single-parameter use of the rating — not a PD/LGD term structure (see Limitation 4) — and the cascade path is still driven by notch count, collateral flag, and loss/assets rather than the standing quality scalar.

REFRESHED 2026-06-06 — re-run via scripts/model_snapshots.py M-052 against the current engine (post commit aa4d2eb / PR #75, where credit_quality entered the loss math via quality_factor). The prior table (captured 2026-06-04) predated that change and was flagged STALE; the stress/cascade figures below are now reproduced directly from the engine and the gold baseline is re-frozen to match. Structural metrics (counts, edges, total exposure, HHI, collateralized %) are unchanged from the 2026-06-04 capture; only the quality_factor-amplified stress and cascade losses moved. No values were hand-edited — every figure is the deterministic engine output (see the diff in M-052-changes.md).

Deterministic run of CounterpartyNetwork on the 15-firm reinsurance graph — reproducible, requires no live firm data beyond the disclosed 10-K figures baked into FIRM_PROFILES and KNOWN_RELATIONSHIPS (python scripts/model_snapshots.py M-052 in InsModel; mechanics asserted by tests/test_counterparty_network.py, 40 tests across construction, exposure matrix, stress, cascade, concentration, and known-relationship validation).

Input: 15-firm graph (3 Tier-1: PRU/MET/APO; 12 Tier-2) · 18 external counterparty nodes · 40 edges · $296.2B total ceded exposure. Stress: Fortitude Re downgraded 2 notches (10% base haircut, 50% collateral credit). Cascade: Other Reinsurers downgraded 4 notches — chosen to exercise the contagion path, which routes through RGA (the one firm in the set that is also a named reinsurer).

The snapshot makes the model's signature features legible. Concentration is dominated by the synthetic residual node: "Other Reinsurers" is simultaneously the largest single edge ($45.3B from GA) and the largest aggregate counterparty ($114.0B, 38% of system exposure) — an artefact of the plug logic, not a real single name (Limitation 1). The largest real named counterparty is Fortitude Re at $49.4B. The system HHI of ~1,996 sits at the threshold the DOJ would call "highly concentrated" for markets, signalling that reinsurance recoverables in this peer set are not diffuse. The Fortitude Re 2-notch stress costs $3.42B across exactly three cedants, with collateral credit visibly halving the blow on the modco/funds-withheld portion and the quality_factor amplifying it for Fortitude Re's sub-1.0 credit quality (0.85 → ×1.075). The cascade demonstration shows the mechanism works but is small: a $20.9B direct hit propagates only $21.0M of second-order loss (0.1%), because the contagion path requires an impaired firm to also be a named reinsurer and only RGA qualifies (Limitation 3).

Captured 2026-06-06 · deterministic, no live data (scripts/model_snapshots.py M-052).

1. The "Other Reinsurers" residual plug dominates concentration and distorts every aggregate metric. It is the largest single edge ($45.3B) and the largest aggregate counterparty ($114.0B, ~38% of system exposure), yet it is a synthetic node that collapses each firm's entire unnamed reinsurance tail into one bucket. System HHI, top-3, and largest-single all reflect this artefact rather than a real counterparty. Any concentration read must explicitly exclude or footnote it.

2. Haircuts are an LGD proxy, not a default model. The downgrade→haircut schedule is a hard-coded deterministic curve. There is no probability of default, no transition matrix, no correlation between counterparty downgrades, and no time dimension — the model answers "if this name is downgraded N notches, what is the writedown" but not "how likely is that" or "what if two correlated names move together."

3. Cascade is single-hop and structurally near-inert in this peer set. The contagion fires only when a firm impaired by the direct event is itself named as a reinsurer to other firms. In the 15-firm graph only RGA satisfies that (the firm ticker coinciding with a reinsurer name); large counterparties like Athene appear as the external node "Athene (APO)" rather than the firm "APO", so a JXN→Athene loss never degrades the APO firm node. The result is that cascades are tiny (snapshot: $20.0M on a $19.9B direct event) and most stresses — including the canonical Fortitude Re case — produce zero cascade. The model under-states true reinsurance contagion.

4. Credit quality enters only as a coarse single-parameter haircut amplifier. As of the 2026-06-05 engine change (commit aa4d2eb / PR #75), the per-node 0–1 credit_quality scalar is consumed by the single-counterparty stress: it scales the effective haircut by quality_factor = 1 + 0.50 × (1 − credit_quality), so a weaker (lower-quality) counterparty now loses more than a strong one on the same notch shock. But this is a single linear amplifier, not a credit model: there is no PD/LGD term structure, no rating-transition matrix, and no PD-vs-LGD separation — the rating influences only the severity multiplier, not the probability or the recovery curve. The cascade path, moreover, still ignores the standing quality scalar (it is driven by notch count, collateral flag, and loss/assets). Turning credit quality into a true PD/LGD term structure remains unbuilt (the still-open part of INV-013's spirit).

5. Single point-in-time snapshot, no roll-forward. Exposures are FY2024 disclosed recoverables. There is no temporal evolution, no new-business accretion, and no novation/recapture dynamics. The graph is a still photograph.

6. Collateral credit is a flat 50% by structure string. Modco/funds-withheld edges get exactly half the haircut regardless of actual collateral adequacy, over-collateralisation, or asset quality of the withheld funds. The collateral flag is a binary substring match ("funds_withheld" in structure or "modco" in structure), so a partially collateralized structure is treated as fully collateralized.

7. No live firm-data path (BV-032). All figures derive from documented canonical inputs (FIRM_PROFILES disclosed figures + KNOWN_RELATIONSHIPS), not a live firm-data feed, and the firm-data path is divergent under BV-032. The exposure totals have not been independently 10-K-validated end to end; the known-relationship tests assert individual transcribed values (CRBG→Fortitude Re $24.1B, PRU→Wilton Re $7.5B, PFG→Talcott $18.3B) but not the completeness of each firm's full reinsurance program.

Remediation status (RAT-052-v1.0.0, 2026-06-06). Closed in this pass: the Output Snapshot was re-run + the gold baseline re-frozen against the current engine (scripts/model_snapshots.py M-052); the quality-driven loss is asserted by test_stress_collateralized_reduces_haircut; and a Tier-1 validation evidence pack was assembled at insightalm/modelling/validation_evidence/M-052/v1.0.0/README.md (COND-001) plus a change log at M-052-changes.md (COND-002).

Still genuine engine-builds (honest-conditional, not faked): unify external-counterparty identity with firm nodes and remove/exclude the "Other Reinsurers" residual plug from concentration metrics (INV-021); make LGD a true function of credit_quality via a PD/LGD transition-matrix term structure rather than the current single linear amplifier (deeper INV-013); add probability-of-default / correlated-downgrade scenarios (Limitation 2); and a disclosed-firm end-to-end 10-K back-test of program completeness — pending BV-032 firm-data, not fabricated (Limitation 7). These remain carried Limitations until built; they do not block COND-001/COND-002.

Engine source: - ecosystem/InsModel/Models/firmmodel/engines/counterparty_network.py — CounterpartyNetwork (insmodel.L3.counterparty_network), with CounterpartyNode, ReinsuranceEdge, the DOWNGRADE_HAIRCUTS schedule, the KNOWN_RELATIONSHIPS table, and COUNTERPARTY_CREDIT ratings. - firmmodel/config/firm_calibration_profiles.py — FIRM_PROFILES, TIER_1_FIRMS, TIER_2_FIRMS (disclosed total_assets_B / reinsurance_recoverables_M per firm). - firmmodel/governance/legacy_metadata/CounterpartyNetwork.yaml — component legacy metadata.

Tests: tests/test_counterparty_network.py — 40 tests across six classes (construction, exposure matrix, stress, cascade, concentration, known relationships); 40 passing. Snapshot: scripts/model_snapshots.py M-052.

Standards / supervisory frameworks: - NAIC Credit for Reinsurance Model Law (#785) / Regulation (#786) and Schedule S — the disclosure and collateral framework underlying ceded recoverables and collateralised (funds-withheld / modco) treatment. - NAIC RBC R3 reinsurance-credit-risk charge — the regulatory analogue to counterparty haircuts on recoverables (cross-reference to M-050 capital model). - IAIS Insurance Core Principle (ICP) 13 — Reinsurance and Other Forms of Risk Transfer (counterparty and concentration risk management). - Basel Committee counterparty-credit and large-exposure framework — source of the HHI concentration discipline and the single-name / aggregate-exposure concentration concepts applied here to reinsurance. - ASOP No. 56 — Modeling (cross-cutting: intended use, sensitivity, reliance, documentation).

Internal: - M-001 — engine-card depth exemplar. - M-050 — RBC / C-3 capital model (R3 reinsurance-credit charge cross-reference). - BV-032 — firm-data divergence (live-data path not used; deterministic inputs only).

Card change history. Code-side change history lives in git log of the component files.

• 2026-05-08 — stub created from registry data per Decision 023 Phase 5 / B-07.
• 2026-06-04 — Tier-1 hand-authoring of the Methodology, Key Assumptions and Their Justification, Output Snapshot, Limitations and Known Gaps, Validation Packet, and References sections from counterparty_network.py + CounterpartyNetwork.yaml legacy_metadata + FIRM_PROFILES / KNOWN_RELATIONSHIPS. Stub marker advanced to ``.
• 2026-06-05 — engine change: commit aa4d2eb / PR #75 added QUALITY_SENSITIVITY = 0.50 and a quality_factor that consumes per-node credit_quality in the single-counterparty stress loss math (previously the rating was carried but inert). The card narrative and Output Snapshot were authored against the pre-change engine and are pending re-stamp / re-run.
• 2026-06-06 (remediation of RAT-052-v1.0.0) — 1L remediation pass (Decision 053 charter §2.2). Re-ran scripts/model_snapshots.py M-052 against the current engine and re-froze the Output Snapshot gold: quality_factor moved stress_total_system_loss_M 3,182.10 → 3,420.76, cascade_direct_loss_M 19,945.62 → 20,942.91, cascade_secondary_loss_M 19.98 → 20.98, cascade_combined_loss_M 19,965.60 → 20,963.88; structural metrics unchanged. Removed the STALE banner. Moved the credit-quality-driven-loss Validation-Packet row to present (asserted by test_stress_collateralized_reduces_haircut). Assembled the Tier-1 validation evidence pack (validation_evidence/M-052/v1.0.0/README.md, closes COND-001) and the per-version change log (M-052-changes.md, closes COND-002). Reconciled registry documentation_pack flags to disk. No values were fabricated — every refreshed figure is deterministic engine output (§4 no-fabrication rule); the PD/LGD term structure, residual-plug removal, correlated-downgrade scenarios, and disclosed-firm back-test (BV-032) remain honest carried Limitations.
• 2026-06-06 — code-grounded documentation-accuracy pass against counterparty_network.py (lines 32–38, 354–366). Corrected the Methodology stress paragraph + operational note to the actual effective-haircut formula (base_haircut × collateral_factor × quality_factor, clamped ≤ 1.0) and removed the false "credit_quality is not an input to any loss number" claim; updated the Key Assumptions credit-quality row and added a QUALITY_SENSITIVITY row; rewrote Limitation 4 from "carried but inert" to "coarse single-parameter amplifier, not a PD/LGD term structure"; moved the Validation-Packet credit-quality-driven-loss row out of the absent block to "present-in-code, pending" with an honest sign-off requirement; added a STALE banner to the Output Snapshot (numbers retained, not edited — re-run is gated); added discrete Standards Coverage and Dependencies sections for 13-section structural alignment with M-001; noted gated/ratification items under Limitations. No model outputs, snapshot figures, back-test numbers, or validation results were fabricated or changed.