💰 quantitative finance

Advanced Applications of Generative AI in Actuarial Science: Case Studies Beyond ChatGPT

This paper explores the transformative potential of generative AI in actuarial science by presenting four case studies—ranging from unstructured text analysis and automated market comparisons to image-based damage classification and legacy code migration—while also addressing the critical regulatory, security, and governance challenges of deploying these technologies in regulated insurance environments.

Original authors: Simon Hatzesberger, Iris Nonneman

Published 2026-04-21

📖 5 min read🧠 Deep dive

CC BY 4.0

Original authors: Simon Hatzesberger, Iris Nonneman

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine the world of insurance as a massive, old-fashioned library. For decades, the librarians (actuaries) have been doing their best work with a specific set of tools: spreadsheets, calculators, and piles of structured data. They are brilliant at crunching numbers, but they often struggle with the "messy" parts of the library: the handwritten notes in the margins, the torn pages, the blurry photos, and the thousands of annual reports stacked in the basement.

This paper is like a tour guide showing us how Generative AI (GenAI) is the new, super-intelligent robot assistant that can finally help these librarians organize the chaos. The authors, Simon and Iris, don't just talk about theory; they show four specific "missions" where they built these robots to solve real problems.

Here is a simple breakdown of their four adventures, using everyday analogies:

1. The Detective Reading the Fine Print (Claim Cost Prediction)

The Problem: When someone files an insurance claim, they often write a long, messy story about what happened (e.g., "I slipped on a wet floor while carrying a heavy box"). Traditional computers can't read this story; they only look at the numbers (age, salary, etc.).
The AI Solution: The authors taught a Large Language Model (LLM) to act like a super-detective. The robot reads the messy story and pulls out the important clues: "Oh, the injury was to the back, caused by lifting."
The Result: The robot turns that messy story into neat, organized data tags. When they fed these new tags into their prediction model, it became much better at guessing how much a claim would cost. It's like upgrading from a calculator that only knows numbers to a calculator that also understands the story behind the numbers.

2. The Speed-Reading Intern (Market Comparisons)

The Problem: Actuaries need to compare their company's financial health with competitors. This usually means manually reading hundreds of pages of annual reports from different companies to find specific numbers (like "Solvency Ratio" or "Discount Rates"). It's slow, boring, and prone to human error.
The AI Solution: They built a RAG (Retrieval-Augmented Generation) system. Think of this as a speed-reading intern who has memorized the entire library. When you ask, "What is Generali's solvency ratio?" the intern doesn't just guess; it instantly flips to the exact page in the report, reads the number, and writes it down in a perfect spreadsheet format.
The Result: They tested this on five different AI models. The best ones were nearly perfect at finding the right numbers in the right reports, turning a task that used to take days into one that takes minutes.

3. The Eye-Doctor for Cars (Car Damage Classification)

The Problem: When a car is damaged, a human has to look at the photo and decide: Is it a scratch? A dent? Is the glass shattered? Traditional computer vision (old-school AI) is good at spotting "a car," but it struggles to understand the context (e.g., "Is this a tiny scratch on the bumper or a shattered windshield?").
The AI Solution: They used a Vision-Enabled LLM. Imagine an AI that doesn't just "see" pixels but actually "understands" the image like a human. They taught it to look at car photos and describe exactly what's wrong and where.
The Result: By "fine-tuning" (giving the AI a crash course on car damage), it became almost as good as a human expert at classifying damage and even pointing out where the damage is (e.g., "Dent on the rear bumper"). It's like giving the AI a pair of glasses and a medical textbook.

4. The Bilingual Code Translator (Legacy Code Migration)

The Problem: Many insurance companies run on ancient computer code written in languages like R or COBOL. These are like ancient scrolls that only a few experts can read. Moving this code to modern languages (like Python) is dangerous; one small mistake can break the whole system.
The AI Solution: They created a Multi-Agent System. Instead of one robot doing the whole job, they built a team of five specialized robots working together:

The Analyst: Reads the old code to understand what it does.
The Translator: Rewrites the code in the new language.
The Tester: Runs the new code to see if it crashes.
The Fixer: If it crashes, the Fixer tells the Translator exactly what went wrong, and the Translator tries again.
The Reporter: Writes a summary of the whole process.
The Result: This team successfully translated complex financial code from R to Python, running it through a gauntlet of tests to ensure the math was exactly the same. It's like having a team of translators, editors, and fact-checkers working in a loop until the book is perfect.

The "But Wait..." Section (Risks and Rules)

The authors are very careful to warn us that while these robots are amazing, they aren't magic wands. They come with serious risks:

The "Hallucination" Risk: Sometimes the AI makes up facts confidently. In insurance, a made-up number can cost millions.
The "Dual-Use" Risk: The same AI that helps detect fraud can also be used by scammers to create fake photos of car damage or forged documents.
The "Black Box" Risk: Regulators want to know why a decision was made. If an AI changes its mind slightly every time you ask it the same question (non-determinism), it's hard to prove it's fair.

The Bottom Line

The paper concludes with a powerful quote from a past insurance leader: "AI won't replace actuaries, but actuaries with AI will replace actuaries without AI."

Think of it this way: The AI is the ultimate power tool. It can cut through the noise, read the fine print, and translate ancient languages. But it still needs a skilled human (the actuary) to hold the tool, aim it correctly, and make sure the final building is safe and sound. The future of insurance isn't about humans vs. machines; it's about humans with machines.

1. Problem Statement

The actuarial profession is transitioning from traditional statistical modeling (e.g., GLMs) to advanced machine learning and deep learning. However, a significant gap remains in leveraging unstructured data (text, images, legacy code) and automating complex, multi-step workflows. While Generative AI (GenAI) offers transformative potential, its application in regulated insurance environments is hindered by:

Data Silos: Valuable insights trapped in unstructured formats (claim descriptions, annual reports, images) are often ignored by traditional tabular models.
Operational Inefficiency: Manual extraction of financial data and migration of legacy code (e.g., R to Python) are error-prone and labor-intensive.
Risk & Governance: The "dual-use" nature of GenAI (beneficial vs. harmful), non-determinism, hallucination, and regulatory compliance (e.g., EU AI Act, GDPR) pose significant barriers to deployment.

The paper aims to bridge this gap by presenting four fully implemented, end-to-end case studies that demonstrate practical, high-value applications of GenAI in actuarial science, moving beyond theoretical chatbots to production-ready systems.

2. Methodology

The authors utilize a case-study approach, implementing four distinct GenAI architectures using Python, Jupyter Notebooks, and various Large Language Models (LLMs). The methodologies are grounded in specific techniques:

Case Study 1: LLM-Extracted Features for Claim Cost Prediction

Technique: Feature Extraction via Structured Outputs.
Process:
1. Input: Unstructured text descriptions from workers' compensation claims.
2. Processing: An LLM (GPT-4o mini) is prompted via the Structured Outputs API to extract specific entities (injured body parts, cause of injury, count).
3. Normalization: A deterministic codebook (regex rules) maps free-form LLM outputs to fixed categorical bins (e.g., 8 anatomical regions).
4. Modeling: These new features are combined with tabular data and fed into a Gradient Boosting Regressor.
Validation: Stratified 4-fold Cross-Validation and a held-out test set, comparing against a baseline tabular-only model.

Case Study 2: Automated Market Comparison via RAG

Technique: Retrieval-Augmented Generation (RAG) with Structured Outputs.
Process:
1. Preprocessing: PDF annual reports are chunked (2k chars, 300-char overlap) and vectorized using text-embedding-3-large.
2. Retrieval: User queries (e.g., "Solvency II ratio") are embedded; top-k relevant chunks are retrieved via cosine similarity.
3. Generation: An LLM (benchmarked across 5 models: GPT-4.1, GPT-5.4, Claude Sonnet, etc.) generates responses constrained by Pydantic schemas (JSON) to ensure machine-readable output.
Validation: Deterministic evaluation against manually extracted "ground truth" values from 2025 annual reports (AXA, Generali, Zurich).

Case Study 3: Car Damage Classification with Vision-Enabled LLMs

Technique: Fine-Tuning Vision-Enabled LLMs.
Process:
1. Baseline: Comparison of a Convolutional Neural Network (CNN) vs. a pre-trained GPT-4o (zero-shot).
2. Fine-Tuning: GPT-4o is fine-tuned on a dataset of 1,500 labeled car damage images.
3. Output: The model predicts damage class (e.g., "glass shatter") and location (e.g., "windshield") using Structured Outputs.
Validation: Accuracy and Weighted F1 Score on a held-out test set.

Case Study 4: Legacy Code Migration via Multi-Agent Systems (MAS)

Technique: Agentic AI with Feedback Loops.
Process: A sequential workflow orchestrated via LangGraph involving five specialized agents:
1. R Analysis Agent: Parses source code and logic.
2. Translation Agent: Converts R to Python (incorporating domain mappings like data.frame $\to$ pandas).
3. Compilation Agent: Checks syntax.
4. Test Runner Agent: Executes pre-written test suites against ground-truth values.
5. Report Agent: Generates migration reports.
Mechanism: If tests fail, the system triggers a retry loop, feeding error traces back to the Translation Agent for iterative refinement (self-debugging).

3. Key Contributions

Empirical Evidence of GenAI in Actuarial Workflows: The paper moves beyond theory to provide reproducible, end-to-end implementations (available on GitHub) for real-world actuarial problems.
Quantifiable Performance Gains:
- Demonstrated that LLM-extracted features significantly improve predictive accuracy in claim modeling.
- Validated that RAG pipelines can achieve near-perfect accuracy in extracting complex financial data from unstructured reports.
- Showed that fine-tuned vision LLMs can match or exceed traditional CNNs while providing richer contextual data (location, severity).
Architectural Patterns for Reliability:
- Structured Outputs: Proven essential for converting LLM "hallucinations" into machine-readable, schema-compliant data.
- Deterministic Codebooks: A method to normalize LLM outputs for downstream statistical modeling.
- Multi-Agent Feedback Loops: A robust pattern for complex tasks (code migration) where iterative self-correction is required.
Comprehensive Risk Framework: The paper provides a detailed taxonomy of risks (Regulatory, Security, Dual-Use, Non-Determinism, Privacy) and proposes specific governance controls (e.g., human-in-the-loop, version pinning, sandboxing).

4. Results

Claim Cost Prediction (Case 1): The enhanced model (LLM features + tabular) achieved an 18.2% reduction in RMSE and a 114.5% increase in $R^2$ on the test set compared to the baseline. Feature importance analysis confirmed LLM-derived categories (body part, cause) were highly predictive.
Market Comparison (Case 2):
- Solvency Ratios & Discount Rates: 100% pass rate across all 5 benchmarked models.
- Financial Strength Ratings: High pass rates (98.3% for Claude Sonnet 4.6, 100% for GPT-4.1/5.4), though smaller models struggled with entity ambiguity.
- Stability: Results were stable across 20 runs per model-aspect combination when using temperature 0.0.
Car Damage Classification (Case 3):
- Fine-tuned GPT-4o: Achieved 0.880 Accuracy and 0.880 Weighted F1, outperforming the non-fine-tuned GPT-4o (0.823/0.825) and matching the CNN baseline (0.837/0.835).
- Contextual Capability: Successfully identified damage locations (e.g., "rear bumper"), a task CNNs cannot perform without specific bounding box training.
Code Migration (Case 4):
- Success Rate: 100% pass rate for both simple (Chain-Ladder) and complex (GLM Bootstrap) R-to-Python migrations across 10 repeated runs.
- Efficiency: The feedback loop successfully resolved errors; the complex example required a mean of 1.2 retries.
- Consistency: While code text varied slightly due to LLM non-determinism, all outputs were functionally equivalent and passed the ground-truth test suite.

5. Significance

Practical Adoption: The paper serves as a "how-to" guide for actuaries, demonstrating that GenAI is not just a novelty but a tool that can immediately improve accuracy, efficiency, and data utilization.
Bridging the Gap: It effectively bridges the gap between the "black box" nature of GenAI and the "white box" requirements of actuarial science by introducing validation layers (ground truth testing, structured outputs, human review).
Governance Blueprint: By explicitly addressing the "dual-use" risk (e.g., fraud via synthetic images) and non-determinism, the paper provides a necessary framework for responsible AI deployment in highly regulated insurance sectors.
Future Direction: It establishes the viability of Multi-Agent Systems for complex, multi-step actuarial tasks, suggesting a shift from single-model prompting to collaborative, autonomous workflows.

In conclusion, the paper argues that while GenAI introduces new risks, its integration into actuarial workflows—supported by rigorous validation, structured outputs, and human oversight—offers a pathway to significantly enhanced predictive modeling, operational automation, and strategic insight.