Every assumption explicit. Every calculation testable.
How Diorama turns a pile of pension documents into a working, auditable calculation engine — and why no existing platform can do the same.
The problem
Most platforms solve the wrong thing.
Standard pension platforms make one promise: bring your scheme, configure the tables, map the fields, and fit the rest into their model.
That works for the parts that are already standardised. It fails for the parts that actually matter: interpreting messy rules, reconciling conflicting source material, squeezing unusual benefit structures into someone else's abstraction.
The hard work doesn't disappear. It moves into awkward, expensive corners — bespoke patches, manual overrides, undocumented workarounds that no one can audit.
The old world
- Humans interpret everything
- Developers bespoke around it
- Schema-driven configuration
- Exceptions become patches
- Audit is an afterthought
- Cost resets per scheme
Diorama
- Engine-assisted extraction
- Structured rule basis
- Generated scheme logic
- Deterministic compute
- Audit trail by design
- Cost drops per scheme
The pipeline
Five stages from mess to engine.
The route to an auditable pension calculation engine is not obvious. A general-purpose AI tool won't give you one. A platform you can buy off the shelf won't either. Diorama exists because of a specific combination of domain knowledge, engineering discipline, and frontier model fluency.
Devour the evidence pack
Diorama takes the messy estate as input. Not a clean export. The actual documents as they exist: contradictory, incomplete, structured for humans rather than machines.
Convert mess into candidate structure
Frontier models read the prose, tables, matrices, and documentary fragments and produce structured candidates: typed rule proposals, factor table extracts, methodology choices, provenance back to source. This is where LLMs matter. They cut the manual labour of turning pension text into something an engine can work with.
Constrain and validate with engine knowledge
The raw model output is not the final answer. Diorama already knows what coherent pension logic looks like. It subjects extracted candidates to strong checks: required fields, coherent date logic, valid factor coverage, explicit methodology choices, contradictions across source material. Frontier models provide speed. The engine provides discipline.
Create the exact scheme logic
Once the basis is explicit and approved, Diorama creates the scheme-specific functionality: the structured calculation basis, validation rules, factor-table bindings, projection logic, calculation code path, test fixtures, reconciliation harness, and audit output. This is the part standard systems cannot do — they ask the team to adapt the scheme to the product. Diorama adapts itself to the scheme.
Produce deterministic results
After the scheme logic exists, the runtime is deliberately boring. No source-document reading. No hidden interpretation. No runtime guesswork. No LLM in the money path. Structured inputs, deterministic compute, replay against examples, auditable outputs. That is how you get both speed and control.
What you receive
Artefacts, not a platform.
You are not migrating into Diorama. The output lands in your existing codebase, in your existing conventions. Your team owns it from day one and makes subsequent changes using skills they already have.
Python modules
Calculation logic in your existing code conventions. Readable, maintainable, testable by your in-house team.
Excel proformas
Workbook outputs matching the format your actuaries and trustees already use for review and sign-off.
Regression harness
400+ assertions that re-implement each rule independently. Run on every rebuild. Drift surfaces before anything ships.
Clickable audit trail
Every figure on every page links to the deed rule and statutory source that authorises it.
Structured rule basis
The typed rule objects, factor table extracts, and methodology choices that form the approved scope of the engine.
Calculation pack
The same document your actuaries use for sign-off is what your engineering team uses for development.
See it on a real scheme.
Pick any figure on the audit trail and follow it back through the deed, the Act, the workbook cell, the line of code. We would like you to try.