3rd Party Reinsurance

External reinsurance capacity via the hook-based integration system

Overview

While the Backstop Pool acts as a protocol-wide safety net, 3rd Party Reinsurance is a syndicate-level feature. It allows individual syndicates to partner with external capital providers - similar to how traditional reinsurers back Lloyd's syndicates.

Key difference:

2-Phase Capacity Model

When a policy quote is reserved against a syndicate, the protocol performs a sequential capacity check:

1. Phase 1 - LP Share Capacity: The system first attempts to fulfil the requested coverage using the syndicate's available LP capital
2. Phase 2 - Reinsurance Overflow: If LP capacity is insufficient, and a reinsuranceHook is configured, the shortfall is passed to the external reinsurer

Effective capacity formula:

$\text{effectiveCapacity} = \text{managedAssets} + \text{hook.availableCapacity()}$

The Reinsurance Hook

The integration is managed via the IReinsuranceHook interface. Syndicates connect to external reinsurers by setting a hook address:

// Syndicate manager connects to a reinsurer
syndicate.setReinsuranceHook(hookAddress);

Hook Interface

Premium Revenue Sharing

When premiums are earned on policies backed by 3rd party reinsurance, the revenue is shared proportionally between the syndicate LPs and the reinsurer:

The split is determined by the proportion of coverage backed by reinsurance. For example, if a $100K policy has$60K backed by LP capital and $40K backed by the reinsurer, the reinsurer receives 40% of the premium.

Loss Splitting And The Live Claim Waterfall

When a claim is filed on a reinsured policy, losses are shared using the same proportional split:

The RiskManager routes reinsured claims through ReinsuranceClaimsModule, which calculates:

• syndicatePortion: the share charged to the policy's underwriter
• reinsurancePortion: the share the hook is expected to fund

That split is then passed into the same payout waterfall used by every claim:

If a policy is not reinsured, step 2 is skipped entirely.

Risk Point Efficiency

A key benefit of 3rd party reinsurance is reduced risk point consumption. The protocol's risk budgeting system only counts LP-exposed capital against a syndicate's risk limits:

Types of Reinsurance Systems

The hook interface is model-agnostic. The protocol only validates that syndicatePortion + reinsurancePortion ≤ totalClaim - it imposes no constraints on how the hook splits losses. This means a single hook contract can implement any of the following traditional reinsurance structures:

Quota Share (Proportional)

The simplest model. The reinsurer takes a fixed percentage of every policy - both premiums and losses are split at the same ratio.

// Hook logic
function calculateLossSplit(uint256 totalLoss, uint256)
    external view returns (uint256, uint256)
{
    uint256 reinsured = (totalLoss * quotaShareBps) / 10000;
    return (totalLoss - reinsured, reinsured);
}

Best for: Syndicates seeking predictable, proportional risk sharing across all policies.

Excess of Loss (XoL)

The syndicate absorbs all losses up to a retention threshold. The reinsurer only pays for losses above that threshold, up to an optional cap.

function calculateLossSplit(uint256 totalLoss, uint256)
    external view returns (uint256, uint256)
{
    if (totalLoss <= retention) return (totalLoss, 0);
    uint256 excess = totalLoss - retention;
    if (limit > 0 && excess > limit) excess = limit;
    return (totalLoss - excess, excess);
}

Best for: Syndicates comfortable absorbing routine claims but needing protection against large, catastrophic losses.

Stop Loss (Aggregate XoL)

Similar to XoL but operates on cumulative losses over a period rather than individual claims. The hook tracks total losses and only triggers once the aggregate exceeds a threshold.

function calculateLossSplit(uint256 totalLoss, uint256)
    external view returns (uint256, uint256)
{
    if (aggregateLosses + totalLoss <= aggregateRetention) {
        aggregateLosses += totalLoss;
        return (totalLoss, 0);
    }
    uint256 syndicateShare = aggregateRetention > aggregateLosses
        ? aggregateRetention - aggregateLosses : 0;
    aggregateLosses += totalLoss;
    return (syndicateShare, totalLoss - syndicateShare);
}

Best for: Syndicates wanting unlimited individual-claim exposure but capping their total annual loss.

Surplus Share

A proportional model where the reinsurer only participates on policies that exceed the syndicate's line size (retained capacity). Small policies are 100% retained by the syndicate.

function calculateLossSplit(uint256 totalLoss, uint256 syndicateCapacity)
    external view returns (uint256, uint256)
{
    if (syndicateCapacity >= totalLoss) return (totalLoss, 0);
    return (syndicateCapacity, totalLoss - syndicateCapacity);
}

Best for: Syndicates wanting to fully retain small risks while ceding large exposures to a reinsurer.

Facultative (Per-Risk)

A per-policy arrangement where the hook can accept or reject individual risks. The hook maintains an internal registry of which policies it covers and at what split.

function calculateLossSplit(uint256 totalLoss, uint256)
    external view returns (uint256, uint256)
{
    uint256 cededPct = policyAgreements[currentPolicyId];
    if (cededPct == 0) return (totalLoss, 0); // Not covered
    uint256 reinsured = (totalLoss * cededPct) / 10000;
    return (totalLoss - reinsured, reinsured);
}

Best for: Reinsurers who want selective underwriting - choosing specific risks rather than blanket coverage.

Debt Settlement & Monitoring

When a reinsurance hook cannot pay its claim portion (e.g. the reinsurer is undercapitalized), the protocol doesn't halt — it substitutes liquidity from the Backstop Pool and/or Treasury, then records the shortfall as a receivable against the hook.

This is managed by the ReinsuranceSettlementModule — an on-chain receivables ledger.

How Substitution Works

The substitution keeps the claim moving, but it does not guarantee that the claimant is always made whole in one transaction. If hook + underwriter + backstop + treasury liquidity are still insufficient, the unpaid remainder becomes claimant debt.

Repaying Hook Debt

Hooks (or any third party) can repay debt at any time. Repayments are routed backstop-first:

// Hook repays $20K of outstanding debt
settlementModule.repayHookDebt(hookAddress, 20_000e6);
// → $20K to backstop first, remainder to treasury

This is an accounting and settlement mechanism, not automatic enforcement. If the hook is uncollateralized, the protocol can record what it owes but cannot force payment on-chain.

Collateralized Hooks

If you deploy reinsurance with the escrow / unwind stack, the security model improves materially:

• reserved capacity plus outstanding debt lock collateral inside escrow
• owners can only withdraw excess collateral
• an unwind manager can seize collateral and route proceeds into repayHookDebt(...)

Without that escrowed collateral path, third-party reinsurance remains a credit exposure rather than a hard on-chain guarantee.

Epoch-Based Monitoring

The module tracks accruals and repayments in monitoring epochs (default: 1 day) for audit and reconciliation:

Lifecycle

Reservation

When capacity is reserved, the reinsurance hook locks the corresponding external capital:

Tracking

Every reservation and policy tracks a reinsuredAmount / reinsuredPortion field, maintaining a clear record of how much liability sits with the reinsurer vs. the syndicate LPs.

Next Steps