AG 55 Affiliated Reinsurance AAT

M-005 is the AG 55 reinsurance asset-adequacy model. Status: under_development. NAIC Actuarial Guideline 55 (effective for the 2025 valuation, with the first AAT reports due April 2026) sharpens asset-adequacy testing for blocks that are ceded to, or assumed under, asset-intensive reinsurance — most pointedly offshore and affiliated reinsurers using funds-withheld / modco structures where the economic risk and the supporting assets can diverge from the statutory credit taken. AG 55 asks the appointed actuary to test reserve adequacy on a basis that looks through the cession: it is asset adequacy testing (AAT) re-run with the reinsurance treaty and its supporting-asset posture made explicit.

The intended architecture is reuse, not reinvention: M-005 = the M-004 cash-flow testing core (insmodel.L4.cft_engine, CFTEngine) plus a reinsurance engine (insmodel.L4.reinsurance_engine, ReinsuranceEngine) plus the asset engine. The CFT engine projects asset and liability cash flows under prescribed scenarios (see M-004); the reinsurance engine transforms gross cash flows and reserves into net-of-reinsurance positions and computes the statutory reinsurance credit; the asset side supplies the supporting-asset projection that AG 55 wants tested.

What is built today (the reinsurance engine). firmmodel/engines/reinsurance_engine.py implements treaty-level cession mechanics, grounded in the code:

1. Treaty dispatch (calculate). For each treaty and period it builds a gross cash-flow dict (premium, benefit, reserve, prev_reserve) and dispatches to a handler by treaty_type: coinsurance, modco, yrt, quota_share, excess_of_loss.
2. Coinsurance / quota share (_apply_coinsurance). Cedes a fixed fraction of premium, benefit, and reserve; expense_allowance = ceded_premium × expense_allowance_rate (default 25%). Quota share calls the same code path.
3. Modified coinsurance (_apply_modco). Same proportional cession of premium/benefit/reserve, but the cedant retains the assets; a modco_adjustment = (ceded_reserve − ceded_prev_reserve) + ceded_reserve × rate / 12 captures the reserve change plus interest on the withheld reserve — the exact funds-withheld pattern AG 55 targets.
4. YRT (_apply_yrt). Mortality-risk-only cession: ceded_premium = sum_at_risk / 1000 × yrt_rate / 12; no ceded reserve.
5. Excess of loss (_apply_excess_of_loss). Per claim, ceded = max(0, min(claim − retention, treaty_limit − retention)).
6. Reinsurance credit (_compute_reinsurance_credit). credit = ceded_reserve × credit_quality, where credit_quality ∈ [0, 1] (1.0 = authorized/full credit, 0.0 = unauthorized without collateral). This is the lever that makes the counterparty's authorization status bite on the statutory balance sheet — the central AG 55 / Model-791 concern.
7. Capital relief (_compute_capital_relief, lines 459-461). net_rbc = max(0.0, gross_rbc − reinsurance_credit) (floored at 0); capital_relief_pct = min(1.0, reinsurance_credit / gross_rbc) (capped at full relief, returns 0.0 when gross_rbc == 0). Both bounds added per INV-027 (resolved 2026-06-04): cession cannot relieve more than 100% of the requirement, so the raw ratio is clamped to [0, 1].
8. Net cost of reinsurance (compute_net_cost_of_reinsurance). ceded_premium − expense_allowance − expected_ceded_claims.

What is built (the AG 55 AAT orchestrator, #2421, 2026-06-07). The piece that makes this AG 55 rather than treaty accounting — running the net-of-reinsurance cash flows through the CFT engine under prescribed scenarios, looking through to the supporting-asset posture backing the ceded block, and producing an adequacy verdict — is now wired as firmmodel/engines/ag55_engine.py (AG55Engine, insmodel.L4.ag55_engine, v1.0.0). It is an orchestrator: no new actuarial primitive, composing the three tested component engines and reducing their outputs to one ag55_results_v1 row per treaty.

Composition pipeline (per treaty):

1. ReinsuranceEngine → ceded/net reserve and the statutory reinsurance credit. The AG-55-defining quantity is the unsecured shortfall = ceded_reserve − reinsurance_credit (NAIC Model-791 credit haircut: authorized → full credit, unauthorized/uncollateralized → 0). This is the reserve the supporting (collateral / modco) assets must adequately back. The credit is taken straight from ReinsuranceEngine._compute_reinsurance_credit — no reimplementation.

2. AssetEngine → sizes/composes the supporting-asset value backing the ceded block. When a treaty declares an explicit supporting-asset portfolio (asset_value / coupon_rate / maturity_years rows) the orchestrator uses it directly; otherwise it falls back to general_account_ratio × (net + credit-haircut reserve) as a proxy bond.

3. CFTEngine (the AG-53 core reused by M-004) → runs the 7 prescribed NAIC interest-rate scenarios on the supporting-asset cash flows vs. the net-of-reinsurance liability cash flows (the unsecured shortfall plus net benefits less net premiums, amortised over the projection horizon). Returns adequacy_ratio and worst_scenario_surplus.

Reduction to ag55_results_v1. AG55Engine.calculate(data, engine_context=…) returns one row per treaty: treaty_id, treaty_type, gross_reserve, ceded_reserve, net_reserve, reinsurance_credit, unsecured_shortfall, credit_quality, supporting_asset_value, supporting_asset_adequacy_ratio, supporting_asset_worst_surplus, net_adequacy_ratio, net_worst_surplus, ag55_passed, ag55_adequacy_ratio. The pass test is the AG-55 net-of-reinsurance worst-case-surplus ≥ 0 rule across all 7 scenarios AND the unsecured shortfall fully asset-backed — precisely the net-aware overlay that M-004's inherited aat_results_v1 lacks.

Conceptual soundness. AG-55 is by definition a net-of-reinsurance asset- adequacy overlay on the standard AAT/CFT framework — it does not invent a new projection. M-005 reuses the AAT machinery (CFTEngine, already validated for M-004) applied to the credit-haircut reserve and the supporting assets; the unsecured_shortfall = ceded_reserve − reinsurance_credit identity is exactly NAIC Model-791 credit-for-reinsurance, already implemented in ReinsuranceEngine._compute_reinsurance_credit. Each of the three component engines has a passing test suite and a stable ENGINE_CONTRACT, so the orchestrator's correctness reduces to (a) wiring and (b) the net-vs-gross pass overlay — both deterministic and tested (tests/test_ag55_engine.py, 9 tests).

Earlier roadmap note (superseded by #2421). Prior to this build there was no orchestrator composing CFTEngine + ReinsuranceEngine + asset engine and no AG-55 output contract; the reinsurance engine ran standalone (snapshot below remains the reinsurance-leg illustration). That gap is now closed by AG55Engine + ag55_results_v1.

Registry-declared assumptions vs. card-bound parameters. The registry entry does declare assumptions: [A-001, A-002, A-090, A-091, A-100] for M-005. These are inherited from the shared engine substrate, not the treaty-level parameters tabled above:

• A-001 Base mortality table (2017 CSO Loaded) and A-002 Mortality improvement scale (MP-2021) — feed the CFT/cash-flow core (shared with M-001 / M-004) that AG-55 will run net-of-reinsurance; they do not parameterize the cession mechanics themselves.
• A-090 Credit spread curve (AAA-CCC) (FRED ICE BofA OAS) and A-091 Spread term structure (linear interpolation of observed OAS) — feed the supporting-asset / asset-engine leg (the funds-withheld / modco portfolio AG-55 asks to test); not yet exercised because the asset look-through is roadmap.
• A-100 Netting benefit assumption (full netting within ISDA master) — relevant to net-of-reinsurance counterparty exposure.

So the registry bindings are real but sit on the CFT + asset legs that are not yet wired (see Limitations #1, #4); the per-treaty cession parameters in the table above (cession %, credit quality, expense allowance, modco rate, YRT rate, retention/limit) are engine ENGINE_CONTRACT defaults and treaty inputs, which do not map to ratified A-NNN registry entries. The divergence is therefore expected: declared-but-not-yet-card-bound assumptions belong to the unbuilt integration, and the live reinsurance leg uses contract parameters that are not registry assumptions.

Engine-level modelling simplifications. Per the engine's own legacy metadata, additional modelling assumptions hold: treaty terms are static over the projection (no mid-period amendment or recapture), cession percentages apply uniformly across the block, the credit-quality factor is constant (no credit deterioration / migration), and all flows are end-of-period (no intra-period timing). Each of these is a simplification relative to a full AG 55 stress of an offshore affiliate — see Limitations.

Deterministic single-treaty run of ReinsuranceEngine v1.0.0 (the reinsurance leg only of M-005) — reproducible, requires no live firm data (python scripts/model_snapshots.py M-005 in InsModel once registered; the underlying cession mechanics are asserted by tests/test_reinsurance_engine.py).

Input: asset-intensive coinsurance block ceded to an offshore / partially- authorized affiliate · gross premium $100,000 · benefit $60,000 · reserve $500,000 · gross_rbc $40,000 · cession 90% · credit_quality 0.80 · 1 period. The CFT/asset adequacy legs (M-004) are not run here.

The AG-55-relevant signal is the credit haircut: a 90% cession produces a $450,000 ceded reserve, but the partially-authorized (0.80) offshore affiliate yields only $360,000 of statutory reinsurance credit — a $90,000 unsecured shortfall that an authorized, fully-collateralized counterparty would not carry. This is precisely the exposure AG 55 asks the actuary to test for adequacy. What the snapshot does not show — because it is not built — is that shortfall and the net-of-reinsurance cash flows run through the CFT engine under prescribed scenarios to an adequacy opinion.

Captured 2026-06-04 (reflects INV-027 clamped capital_relief_pct / floored net_rbc) · deterministic, no live data.

1. DS-047 firm-data binding is DEFERRED (the primary build limitation). The orchestrator is built and tested, but it runs on parameterized / declared treaty + supporting-asset inputs, identical to how every other InsModel engine test runs — not against real NAIC AG-55 Form B state-DOI disclosures (DS-047). A firm-calibrated AG-55 run against real disclosures is a follow-on data-binding task; it is not fabricated here, it is honestly absent. Until DS-047 is wired, the engine's outputs are illustrative of the mechanics, not a firm-specific AG-55 opinion.
2. First AG 55 AAT reports are due April 2026. AG 55 is effective for the 2025 valuation. The orchestrator now exists ahead of that window; the remaining gating work for a real filing is the DS-047 firm-data binding (#1).
3. Status remains under_development pending 2L re-review. The 1L build clears RAT-005 COND-001/002 (the missing orchestrator + reinsurance-aware contract, INV-004), but per Decision 052 the final AG-55 pass thresholds and the net-of-reinsurance pass rule are subject to 2L effective challenge — 1L does not gate the state transition or issue the ratification verdict.
4. The 7 prescribed scenarios are the simplified deterministic NY-7 set inherited from CFTEngine, not a full stochastic ESG. Adequacy under tail scenarios beyond the seven NAIC Model-822 shifts (level, ±100/200/300 bps) is not tested.
5. Supporting-asset-value fallback is a proxy. When a treaty declares no explicit collateral portfolio, the supporting asset value is derived as general_account_ratio × (net + credit-haircut reserve) expressed as a single proxy bond. This may over- or understate the real backing; the proxy path is a modelling simplification, not the funds-withheld / modco portfolio look-through a real treaty would supply.
6. credit_quality is treaty-declared, not independently re-derived. The authorized / collateralized factor in [0, 1] is an input, not recomputed from counterparty financials; counterparty downgrade / migration / default dynamics are out of scope (would route to M-055 / a counterparty-credit model).
7. Static treaties; no recapture or credit deterioration. Treaty terms are fixed over the projection, the credit-quality factor is constant (no migration / downgrade / default path), and recapture provisions are not modelled — all of which are central to stressing an offshore affiliate.
8. Retrocession, experience refunds, sliding-scale commissions absent. Per the engine's own limitations list; these features of real asset-intensive treaties are not implemented.
9. capital_relief_pct clamping — RESOLVED (INV-027, 2026-06-04). Previously capital_relief_pct was the raw ratio reinsurance_credit / gross_rbc, which in the canonical run was 360,000 / 40,000 = 9.0 (uncapped, because gross_rbc $40K is far below ceded_reserve $450K) — not a usable fraction. The engine now computes capital_relief_pct = min(1.0, reinsurance_credit / gross_rbc) and floors net_rbc at max(0.0, gross_rbc − reinsurance_credit) (reinsurance_engine.py lines 459-461). The field is now safely in [0, 1] and the canonical snapshot value is 1.00 (full relief). No live defect remains; this note is retained as change provenance.
10. Registry-declared assumptions bind the CFT + asset legs, not the cession mechanics. The registry declares [A-001, A-002, A-090, A-091, A-100] and [DS-047]. A-001/A-002 drive the net liability CFs and A-090/A-091 the supporting-asset spreads/discounting through the now-wired CFT leg; the live reinsurance-leg parameters (cession %, credit quality, expense allowance, modco/YRT rates, retention/limit) are engine ENGINE_CONTRACT defaults and treaty inputs, not ratified A-NNN entries. See Key Assumptions for the full reconciliation.
11. Firm-data path divergent (BV-032). The build and tests use a MagicMock data provider on parameterized inputs; no 10-K-derived figures are claimed and no live firm data is used (see #1, DS-047 deferred).

Tracked for ratification (2L, Decision 052): the AG-55 net-of-reinsurance pass thresholds and pass rule (the effective challenge over ag55_passed and the worst-case-surplus ≥ 0 + shortfall-backed test); the DS-047 firm-data binding for a firm-specific AG-55 opinion; and static-treaty / recapture / credit-deterioration modelling (Limitations #5, #6, #7). The orchestrator + reinsurance-aware contract (INV-004 / RAT-005 COND-001/002) are built by this 1L pass (#2421).

Regulatory: - NAIC Actuarial Guideline 55 (AG 55) — asset adequacy testing focused on reinsurance ceded/assumed, esp. asset-intensive, offshore, and affiliated reinsurance; effective 2025 valuation, first AAT reports due April 2026. - NAIC Actuarial Guideline 53 (AG 53) — asset adequacy / complex-asset testing reused as the CFT core (see M-004). - NAIC Model Regulation 791 (Credit for Reinsurance) — statutory reinsurance credit; authorized vs unauthorized / collateralized treatment. - NAIC Model Regulation 822 (Actuarial Opinion and Memorandum) — prescribed interest-rate scenarios used by the CFT core. - SSAP No. 61R — statutory accounting for life/A&H reinsurance. - ASOP No. 7 / No. 22 — cash-flow analysis and asset-adequacy opinions. - ASOP No. 56 — Modeling.

Source code: - AG-55 orchestrator: ecosystem/InsModel/Models/firmmodel/engines/ag55_engine.py (AG55Engine, insmodel.L4.ag55_engine, v1.0.0; governance model_id M-005) — composes the three engines below and emits ag55_results_v1. Tests: ecosystem/InsModel/Models/tests/test_ag55_engine.py (13 = 9 acceptance + 4 sensitivity/cross-check regressions, COND-001(c)). Sensitivity generator: ecosystem/InsModel/Models/scripts/validate_ag55_sensitivity.py. Legacy metadata: firmmodel/governance/legacy_metadata/AG55Engine.yaml. - Reinsurance engine: ecosystem/InsModel/Models/firmmodel/engines/reinsurance_engine.py (ReinsuranceEngine, insmodel.L4.reinsurance_engine, v1.0.0; governance model_id M-901). - CFT core (reused): ecosystem/InsModel/Models/firmmodel/engines/cft_engine.py (CFTEngine, insmodel.L4.cft_engine, v1.0.0) — see M-004. - Tests: ecosystem/InsModel/Models/tests/test_reinsurance_engine.py. - Legacy metadata: firmmodel/governance/legacy_metadata/ReinsuranceEngine.yaml.

Other: - Tiller & Tiller (2015) Life, Health, and Annuity Reinsurance, 4th ed. - AAA Practice Note: Reinsurance Accounting (2019).

Canonical going-forward change log: M-005-changes.md (Keep-a-Changelog format, versioned with the ReinsuranceEngine class version; created 2026-06-06, closing RAT-005-v1.0.0 COND-003). Code-side change history lives in git log of the component files; release notes in ecosystem/InsModel/CHANGELOG.md.

Pre-baseline authorship history of this card:

• 2026-05-08 — stub created from registry data per Decision 023 Phase 5 / B-07.
• 2026-05-09 — Tier-1 hand-authoring of Methodology, Key Assumptions and Their Justification, Output Snapshot, Limitations and Known Gaps, Validation Packet, and References from ReinsuranceEngine legacy_metadata + engine source
• registry entry. Stub marker advanced to ``.
• 2026-06-04 — documentation pass reflecting the INV-027 engine fix (reinsurance_engine.py lines 459-461): capital_relief_pct clamped to [0, 1] and net_rbc floored at 0. Output Snapshot updated (capital_relief_pct 9.00 → 1.00 capped; added net_rbc 0.00 row); Limitation #7 recast from live defect to resolved provenance note; Methodology §7 updated to the clamped formulas.
• 2026-06-06 — documentation-only consistency pass: added a dedicated Standards Coverage section (13-section gold-standard shape, cross-referencing registry regulatory_frameworks + cited AG-53 / Model-791); reconciled the Key Assumptions prose and Limitation #8 with the registry-declared [A-001, A-002, A-090, A-091, A-100] bindings (mapped to the unwired CFT + asset legs); added a tracked-for-ratification note for the unbuilt AG-55 orchestrator and supporting-asset / static-treaty items.
• 2026-06-07 — AG-55 AAT orchestrator BUILT (1L, Decision 053, build issue #2421). New engine AG55Engine (insmodel.L4.ag55_engine) composes ReinsuranceEngine + AssetEngine + CFTEngine and emits the registered ag55_results_v1 contract (one row per treaty); 9 acceptance tests pass. Closes RAT-005 COND-001/002 (INV-004 — missing orchestrator + reinsurance-aware contract) and unblocks M-055. Card updated: Description, Output contracts (aat_results_v1 → ag55_results_v1), Methodology (composition pipeline + conceptual soundness), Limitations (recast roadmap → build-honest: DS-047 binding deferred, NY-7 deterministic scenarios, supporting-asset proxy, treaty-declared credit quality), Validation Packet (orchestrator tests + pack). Status stays under_development pending 2L re-review (1L does not gate the state transition or issue the ratification verdict, per Decision 052).
• 2026-06-29 — 1L COND-001(c) doc-integrity reconciliation (LG-005-08, RAT-005-v1.0.3). The COND-001(c) SUBSTANCE (top-3 sensitivity + a composition cross-check within 1e-9) is already delivered and on InsModel main (PR #92): tests/test_ag55_engine.py now has 13 tests (9 + 4 standing sensitivity/cross-check regressions, #10–#13) — re-run → 13 passed; the generator scripts/validate_ag55_sensitivity.py is present and regenerates sensitivity_and_cross_check.md; and the M-005 snapshot runs clean (LG-005-10 fixed). This pass reconciles the card Validation Packet to that reality (the gap LG-005-08 flagged): corrected the AG-55 test count 9 → 13, added a dedicated Sensitivity + cross-check (COND-001(c)) row surfacing sensitivity_and_cross_check.md + the 4 regression tests + the 1e-9 cross-check tolerance, stated the EXTERNAL worked-example back-test deferral as an explicit DS-047-gated carve-out, added a clean-snapshot row, and fixed the stale "(9)" in the source-code reference. Documentation-only — no engine code, output, or model state changed; status stays under_development pending 2L re-review.