Peer-to-peer insurance has an actuarial credibility problem. The pitch is elegant: pool members share each other’s losses, keep the surplus, and eliminate the insurer’s profit margin. The practice has been mixed. Friendsurance (Germany) pivoted to B2B insurance management software after failing to scale P2P. Guevara (UK cycling, home insurance) shut down in 2017. Bought By Many restructured away from P2P pooling. The intuition about community risk-sharing is sound; the implementations have not been.

The gap has usually been design. A P2P pool needs contribution rates that are fair, sustainable, and — if you want to make a proper actuarial argument — provably better than each member going it alone. “Better than going it alone” has a precise definition: the pool should weakly reduce each member’s ruin probability. Denuit, Flores-Contró, and Robert (arXiv:2603.29530, March 2026) prove that a linear allocation rule — a simple, pre-specified matrix of who absorbs what fraction of whose claims — can achieve this guarantee. insurance-optimise v0.6.0 implements their framework as LinearRiskSharingPool.

The model

Each participant $i$ has a classical Cramér-Lundberg surplus:

\[U_i(t) = u_i + c_i t - S_i(t)\]

where $u_i$ is initial capital, $c_i = (1 + \eta_i) \lambda_i b_i$ is the premium income rate (safety loading $\eta_i$), and $S_i(t)$ is a compound Poisson claims process with intensity $\lambda_i$ and mean severity $b_i$.

In the pool, claims are redistributed at claim time via an $n \times n$ allocation matrix $A = (a_{i,j})$. Participant $i$ absorbs fraction $a_{i,j}$ of each claim generated by participant $j$. The pooled claims process for participant $i$ is the sum of contributions from all $j$, weighted by the allocation matrix.

The paper identifies four conditions under which pooling weakly reduces infinite-time ruin probability for every participant:

  1. Budget balance: $\sum_i a_{i,j} = 1$ for all $j$ — the full loss is redistributed, nothing leaks.
  2. Actuarial fairness: $\lambda_i b_i = \sum_j \lambda_j a_{i,j} b_j$ for all $i$ — the expected claim rate is unchanged per participant after pooling.
  3. Capacity: $a_{i,j} b_j \leq b_i$ for all $i, j$ — no single transfer exceeds the recipient’s mean claim capacity.
  4. Scale family: claim severities are of the form $Y_{i,k} \overset{d}{=} b_i W$, where $W$ is a common non-negative random variable with $E[W] = 1$.

The fourth condition is the restrictive one. It is satisfied by exponential, gamma with fixed shape, and lognormal with fixed $\sigma^2$. It is not satisfied by Pareto. In practice, UK motor severity is not well-described by any of these distributions without transformation.

The proof runs through convex order: the pooled claim for participant $i$ is less than or equal in convex order to the standalone claim, and ruin probability — being a Laplace-transform-based functional of the aggregate loss process — is monotone in convex order for compound Poisson processes. The result is theoretically tight.

The simplest allocation rule that works

The mean-proportional rule allocates proportionally to expected loss load:

\[a_i^{\text{np}} = \frac{\lambda_i b_i}{\sum_k \lambda_k b_k}\]

This satisfies budget balance and actuarial fairness by construction. Whether it satisfies the capacity condition depends on the heterogeneity of participants — if one participant has a mean claim ten times larger than another, the capacity condition may bind.

The library provides a constructor for this:

import numpy as np
from insurance_optimise import LinearRiskSharingPool

# Three-participant pool (from paper Example 3.4.1)
# lambda: claim intensities; b: mean claim sizes; eta: safety loadings
pool = LinearRiskSharingPool.mean_proportional(
    claim_intensities=np.array([2.0, 1.0, 3.0]),
    claim_means=np.array([2.0, 0.5, 1.0]),
    safety_loadings=np.array([0.4, 0.4, 0.4]),
    initial_capital=np.array([1.0, 1.0, 1.0]),
)

# Check the four conditions before proceeding
validation = pool.validate_conditions()
print(validation)
# ValidationResult(budget_balance=True, actuarial_fairness=True,
#                  capacity=True, violation_magnitudes=...)

# Ruin probabilities with and without pooling
psi_pool = pool.ruin_probability(method='cramerlundberg', claim_dist='exponential')
psi_solo = pool.ruin_probability_standalone(method='cramerlundberg', claim_dist='exponential')
improvement = pool.ruin_improvement()

print("Pooled ruin probabilities:     ", np.round(psi_pool, 4))
print("Standalone ruin probabilities: ", np.round(psi_solo, 4))
print("Improvement (pp):              ", np.round(improvement, 4))

For lognormal severity (the more realistic case), the Cramér-Lundberg closed form no longer applies and you fall through to simulation:

pool_ln = LinearRiskSharingPool.mean_proportional(
    claim_intensities=np.array([2.0, 1.0, 3.0]),
    claim_means=np.array([1.649, 2.718, 1.221]),  # paper Example 3.4.2
    safety_loadings=np.array([0.4, 0.4, 0.4]),
)

psi_sim = pool_ln.ruin_probability(
    method='simulation',
    n_sim=10_000,
    claim_dist='lognormal',
    claim_dist_params={'sigma': 1.0},
    seed=42,
)

If the default mean-proportional allocation is not good enough — perhaps the capacity condition fails for some participant pairs — optimal_allocation() uses SLSQP to find the matrix $A$ that maximises the minimum ruin probability improvement across participants, subject to all three testable conditions:

optimised_pool = pool.optimal_allocation(
    objective='max_min_improvement',
    capacity_slack=0.0,
)
# Returns a new LinearRiskSharingPool instance with the optimised A matrix

The optimiser handles up to about $n = 20$ participants tractably. Above that, the $n^2$ variable space makes SLSQP slow.

The UK market context

The paper’s intended use case is “locally organised, member-financed schemes including funeral insurance, health insurance, and agricultural coverage in low-income environments.” That is not Laka or Dinghy. But the theoretical machinery applies to any pool where you can specify an allocation matrix and collect contributions.

Laka (London, founded 2017) operates the closest thing in the UK to the paper’s model: members only pay in months where the pool had claims; Laka takes a margin only on settled claims. The pool absorbs claims from the whole member cohort. Laka was partially acquired by Allianz Direct in March 2025 — which says something about the commercial pressure on pure P2P models even when they work technically.

Dinghy (freelancer equipment insurance) uses a stop-loss backed P2P structure. Neither firm, as far as we are aware, uses formal Cramér-Lundberg analysis internally. The pricing is contribution-rate intuition rather than proven ruin reduction.

LinearRiskSharingPool gives these designs an actuarial foundation. If you are a mutual or P2P insurer who needs to demonstrate to the FCA under Consumer Duty that your pool design is sustainable and fair to members, audit_trail() returns a JSON-serialisable record of the allocation matrix, the conditions satisfied, and the ruin improvement for each participant:

trail = pool.audit_trail()
# {
#   'allocation_matrix': [[...], ...],
#   'conditions': {'budget_balance': True, 'actuarial_fairness': True, 'capacity': True},
#   'ruin_improvement': [0.0341, 0.0218, 0.0289],
#   'parameters': {'claim_intensities': [...], 'claim_means': [...], ...}
# }

What P2P insurance has usually got wrong

Guevara and Friendsurance had adverse selection problems that no amount of allocation-matrix optimisation would have fixed. When the pool is too small and self-selected for high-risk members (or: the low-risk members who joined to save money left as soon as the pool had claims), the actuarial fairness condition fails because the actual claim intensities diverge from the ones the pool was designed for.

The Cramér-Lundberg model assumes independent participants with stationary claim processes. Real P2P pools have correlated claims (cycling insurance: all members ride in the same city, all vulnerable to the same spate of thefts), dynamic membership (new members join after claims are low; leave after claims are high), and participants who update their behaviour based on their pool balance. None of these are in the paper. Proposition 3.8 guarantees ruin improvement under the stated assumptions; it does not guarantee it when the assumptions break.

The scale family condition (condition 4) is also more restrictive than it looks. UK motor severity in personal lines has a thick right tail — Pareto-like, not exponential or fixed-shape gamma. You can fit a lognormal with a common $\sigma^2$, but the assumption that this is the same across all participant types in a heterogeneous pool is heroic. In practice, you will simulate rather than use the closed form, and the ruin improvement guarantee becomes empirical rather than proven.

Who should use this

This is a specialist tool. LinearRiskSharingPool is useful if you are:

It is not useful if you are a standard personal lines insurer running a Poisson-GLM pricing model. The Cramér-Lundberg framework is a different actuarial tradition — classical ruin theory, not frequency-severity modelling — and the two traditions are solving different problems.

P2P insurance has failed more than it has succeeded. The mathematical foundation is not what was missing in those failures. But for the firms that do get the commercial and adverse-selection problems right — and Laka shows it is possible, at least until the traditional insurer acquisition — having the actuarial theory formalized in code is a real advantage.

References

Denuit, M., Flores-Contró, J. M., and Robert, C. Y. (2026). ‘Linear Risk Sharing in Community-Based Insurance.’ arXiv:2603.29530.

Denuit, M. and Robert, C. Y. (2021). ‘Actuarial Comparisons for Aggregate Claims with Randomly Right-Censored Lifetimes.’ Insurance: Mathematics and Economics 102, 44–55.

Asmussen, S. and Albrecher, H. (2010). Ruin Probabilities (2nd ed.). World Scientific.

p2p-insurancemutualrisk-sharingcramer-lundbergruin-probabilityinsurance-optimisearXiv-2603-29530DenuitFlores-ContróRobertcommunity-insurancelakalinear-allocation

Library documentation

Related reading

Back to all articles