A corporate health insurer managing coverage for nearly 200,000 insured persons ran one of its most critical workflows on copy-paste, Excel macros and six people doing daily gymnastics. FlowX.AI built a ten-step agentic workflow that handles email intake, encryption before AI, intent extraction, core-CRM lookup, column mapping, anomaly detection and human review, all without sensitive data ever leaving the controlled perimeter unencrypted.
Validated results from pre-production
What if 25 hours of daily work shrank to three, by knowing exactly what to automate and what not to?
The old way ran on copy-paste. Open the email, download whatever showed up (standard Excel, non-standard Excel, a PDF, a phone photo of an ID card), verify national ID numbers line by line, paste into an internal validation Excel, generate a .txt, upload to the core CRM, watch the whole file get rejected if any line errored, fix it, reupload, then email the client back with the updated payment notification. Each file an addition, a removal or a change to a corporate health policy, and each carrying personal data that ruled out sending anything to a third-party LLM.
One of the insurer’s most critical workflows, adding, removing and changing corporate health policies, ran entirely by hand across a six-person team near saturation. Four uncomfortable truths defined the starting state.
Years of trying to convince corporate clients, companies with tens, hundreds or thousands of employees, to send portfolio updates in a standard format had not worked. Every month, the same companies send the same messy data: non-standard spreadsheets, PDFs, phone photos of ID cards, sometimes two files, sometimes none.
Volume was growing. Headcount could not grow with it. The six-person team was near saturation.
The core CRM exposed a single import API that rejected the entire file if it found an error on any line out of 600. There was no pre-validation API and no ID-check API. Every error was discovered after the upload, after the rejection, after the rework.
The workflow handled national ID numbers on nearly 200,000 insured persons. Whatever AI looked like here, it had to work without exposing that data to a third-party model. GDPR was a first-class requirement.
The team no longer does the data-relay. Each structural pressure now has a concrete answer, built to work with the systems and the inbox that already existed.
Six people perform daily copy-paste gymnastics across emails, spreadsheets and macros, with the team near saturation and no headcount available to scale.
A ten-step agentic workflow handles the process end-to-end: intake, mapping, write-back and client confirmation, leaving humans to review confidence-scored output, not raw data.
Format chaos: non-standard spreadsheets, PDFs, phone photos, and private data like national IDs pasted into email bodies.
Scope refinement. In scope: emails with a policy number in the subject or body, plus parsable spreadsheets. Out of scope: PDFs, phone photos and missing policy numbers, which trigger automatic replies asking for the right format.
The core CRM rejects whole files over a single line error, and offers no pre-validation API.
The AI Mapper validates every line against the core CRM’s ground truth, pulled in advance, before write-back. The error loop now returns only the erroring lines, not the whole file.
Personal data on nearly 200,000 insured persons ruled out a send-everything-to-the-LLM approach.
No national ID leaves the controlled perimeter unencrypted: regex sanitization of email bodies, column-level encryption of attachments before the AI sees the file, and local decryption after.
It reads the inbox, grounds every line in the core CRM’s truth, scores its own confidence, and hands a human a clean queue to approve. Raw data is never what a person reviews.
Parses each inbound email, requires a policy number in the subject or body, and accepts parsable spreadsheets. Messy formats, PDFs, phone photos, a missing policy number, trigger automatic replies asking for the right format, so only clean cases enter the pipeline.
The AI Mapper pulls the policy’s ground truth from the core CRM in advance (client, valid categories, packages, subgroups, current insured list) and aligns every client-side column to a valid value, so nothing is guessed.
Identifies the operation on each line (add, remove or update), detects duplicates, and outputs reasoning and a confidence score per line, all computed on anonymized data.
A review dashboard surfaces every line with its confidence score, duplicate highlights and inline edits. Save and send writes to the core CRM, retries only the erroring lines (never the whole file), and auto-generates the client confirmation email.
The workflow handles national ID numbers on nearly 200,000 insured persons, which ruled out any send-everything-to-the-LLM approach. The answer: make sure no identifier ever reaches the model in the clear, on three moves.
From an email landing in the mailbox to a confirmation sent back to the client, with the model working only on anonymized data and a person approving the result.
Tokenize the email
A regex scans the body for national-ID patterns, tokenizes every match, and stores the mapping in encrypted local storage.
Hand the AI a clean email
The model sees a clean email: subject, sanitized body and attachment list, nothing more.
Read intent
The AI Analyser identifies intent (add, remove, update), extracts the policy number, and flags attachment passwords.
Pull ground truth
The core-CRM API returns the policy’s ground truth: client, valid categories, packages, subgroups and current insured list.
Parse attachments
Attachments are downloaded and parsed programmatically to identify sensitive columns.
Encrypt sensitive columns
National-ID columns are encrypted before the AI sees the file.
Map on anonymized data
The AI Mapper aligns client-side columns to valid values, identifies operations per line, detects duplicates, and outputs reasoning and confidence per line.
Restore & create tasks
Tokens are swapped back locally. Per-policy task creation follows: one email touching three policies becomes three tasks.
Human review
The policy review dashboard surfaces every line with confidence scores, duplicate highlights and inline edits.
Save, send & confirm
Save and send writes to the core CRM, retries only error lines (not whole files), and auto-generates the client confirmation email.
We weren’t going to teach an AI to handle every kind of mess. We had to make it easier for clients to be disciplined than to be sloppy, and let the architecture do the rest. The clean cases now run through in minutes. The messy ones land in a manual queue, slower by design. The harder question isn’t whether we extend this to claims and underwriting. It’s which one we pick first.
Five months from contract to a validated pre-production system, go-live one sign-off away. The architecture was scoped to work with what existed, rather than waiting for the partner system to add APIs or for clients to change behavior.
Month 1
Contract signed, dev kick-off. Scope refined to a smaller MVP: nail the disciplined cases first.
Month 2
The insurer’s APIs ready. FlowX.AI build complete in four weeks.
Month 3
Pilot go-live with manual approval. End-to-end testing on real data.
Month 4
Hypercare: mailbox sanitization and AI calibration against real client patterns.
Month 5
Pre-production validated, core-CRM integration confirmed. Go-live one sign-off away.
The build ran against the core CRM’s import API, the insurer’s email infrastructure and the existing six-person team’s workflow. FlowX.AI’s own build was complete in four weeks; the rest of the timeline went to the client-side APIs coming online, real-data testing and calibration.
The first-month scope refinement chose the low-hanging fruit with the greatest impact: a smaller MVP that nails the disciplined cases, with discipline-shaping side effects on everything else.
Three lenses on the same result: the time it gave back, the money it protects, and the quality and compliance the architecture now enforces.
Daily processing time fell 88%, from 25 hours to 3. Across a month that is 550 hours down to 66, and per file, 30 minutes down to 5.
€144,100 in validated annual benefit: €87,000 in labor savings, €7,900 in error correction avoided, €13,200 in revenue leakage protected, and €36,000 in new revenue from referrals.
Correctness and compliance are enforced by the architecture, not by people remembering to check.
The policy-admin agent is the foundation. It is the first implementation where AI processes real insured-person data without breaching GDPR: local encryption before any model request, local decryption after. That pattern is replicable across every operational flow that touches personal data, claims reimbursement, individual underwriting, retail policy changes. The same connector, the same encryption layer, the same dashboard model, all reusable.
Six months after go-live, the joint team will evaluate the system against a three-layer framework agreed at the start: AI accuracy (70% of requests processed end-to-end without human field-level intervention immediately, 90%+ as the AI learns per-client patterns, 100% on the green cases with a human in the loop only for exceptions), operational efficiency (ten minutes end-to-end for 90% of cases), and ecosystem discipline (source emails carrying a policy number, from a ~50% baseline to 80%+ within six months).
That last layer is the quiet one. The architecture is teaching the market what good inputs look like: clients sending PDFs get automatic replies asking for spreadsheets, clients without a policy number get asked for one. Incomplete requests slow down while disciplined ones speed up. That is the thing that cannot be bought by hiring more people, an architecture that slowly and consistently educates the market.
We are the enterprise orchestration platform that enables regulated institutions to deploy deterministic, zero-hallucination agentic workflows on top of legacy infrastructure. Insurers run critical customer and operations journeys on FlowX.AI, including:
Bring a regulated journey and we will show you a path to production, on your core, with personal data encrypted before the model, the human in the loop and the audit trail intact.