Every few years, life insurance modelling circles back to a familiar idea: “Surely we can build this ourselves now?”

Open-source languages are mature. Cloud infrastructure is cheap and elastic. Numerical libraries are faster than ever. On the surface, the case for fully open-source financial modelling feels stronger than it ever has.

And yet, time and again, large-scale internal build attempts quietly stall, get re-scoped, or end up re-introducing vendor platforms through the back door. This isn’t because open source has failed actuarial modelling. It’s because life insurance modelling turns out to be much more than code.

What Internal Build Attempts Teach Us

Most insurers who seriously explore fully open-source modelling learn similar lessons, but usually the hard way.

The first phase is energising. Small teams build fast. Logic is transparent. Changes happen in days rather than months. The models feel alive in a way vendor platforms sometimes don’t. Then scale arrives.
Suddenly, the problem is no longer “Can we calculate this?” but “Can we explain this six months later?” Versioning, documentation, reproducibility, controls, and audit trails start to dominate development time.

The original modellers become de facto platform engineers. New joiners struggle to understand implicit design choices. Enhancements compete with urgent fixes. Over time, ownership shifts from empowerment to obligation.

The most revealing moment often comes when key people move roles or leave. What looked like organisational capability turns out to be individual memory. At that point, the firm hasn’t eliminated vendor risk, it has simply internalised it, or worse still, outsourced it to a team of consultants who will probably suffer the same challenges as an internal team, but at a higher cost to the organisation.

Why Life Insurance Modelling Punishes Fragility

Unlike many analytics domains, life insurance modelling is long-lived. Models don’t exist for months or even years – they persist for decades, across assumption changes, regulatory shifts, and business transformation.

That longevity places a premium on things that open-source enthusiasm often undervalues at first – institutional resilience, shared understanding, controlled evolution, and the ability to defend results under pressure.
Fully bespoke stacks can be brilliant, but they are also fragile. And fragility scales badly.

Why Closed Black Boxes Aren’t the Answer Either

Of course, the opposite extreme hasn’t aged well either. Closed vendor platforms that obscure logic, limit extensibility, and slow experimentation solve governance problems by suppressing curiosity. They are stable but often at the cost of insight.

This is why the future isn’t binary.

The Blended Model: A Best of Both Extremes

The more durable path is a deliberately blended one: platforms that provide structure, execution discipline, and governance, combined with open-source components where flexibility and innovation genuinely add value.

This is where Mo.net fits naturally into the modern modelling estate. Rather than asking firms to choose between total control and total abstraction, it allows actuarial logic to remain visible and owned, while removing the need to reinvent execution frameworks, scaling, and operational plumbing.

Open-source tools thrive alongside this approach, powering data preparation, exploratory analysis, visualisation, and research, without being forced to shoulder the full burden of production-grade actuarial infrastructure. The result is not purity, but sustainability.

Why AI Raises the Stakes and the Risks

AI-enabled modelling makes this distinction even sharper, since AI thrives on structure, consistency, and scale. It needs models that are understandable, data that is well-organised, and environments that support fast iteration. Ironically, this makes fully bespoke open-source estates harder to support with AI, not easier.

When every model behaves slightly differently, when assumptions are implicit rather than formalised, and when performance limits iteration, AI becomes unreliable or superficial. Instead of accelerating insight, it amplifies inconsistency.

Platforms that provide a consistent modelling framework while allowing firms to own and extend logic create far better conditions for AI to assist with navigation, comparison, scenario exploration, and explanation. In this sense, AI does not reward maximal freedom. It rewards disciplined openness.

A More Mature End State

The future of life insurance modelling is not fully open source, and it is not fully proprietary. It’s an ecosystem.
One where stable platforms carry institutional weight, open-source tools accelerate thinking, and AI shortens the distance between question and understanding without undermining governance or resilience.

Fully open-source modelling is an appealing idea. But a blended approach, which is pragmatic, intentional, and designed for longevity, is far more likely to survive contact with reality.

The Model We Owned… Until We Didn’t

A small, highly capable team builds an internal open-source life insurance model to solve a very real problem. It’s fast. It’s transparent. Everyone involved understands exactly how it works. Early results are impressive, and the model quickly gains credibility.

Then the model gets used.

More products are added. More scenarios are requested. Controls are layered in. Documentation becomes “Something we’ll tidy up later”. The original developers become the only people who truly understand how changes ripple through the system.
A few years on, the business is relying on the model for decisions that matter – capital deployment, reinsurance strategy, pricing direction. At the same time, the team that built it has shrunk, moved on, or been reassigned.

Suddenly, “We own the model” means:

– Only two people can safely change it
– Every enhancement carries delivery risk
– Audit questions take weeks, not days
– Nobody is quite sure which assumptions are truly standardised

At that point, the organisation hasn’t eliminated vendor dependency.
It has simply become its own vendor – without a roadmap, without formal support, and without anyone whose full-time job is to keep the platform healthy.

And quietly, conversations begin about whether a “lightweight external solution” might reduce risk.