No real-time reasoning
Advisors had no support to interpret client risk, market shifts and internal guidance in a single flow. They held the conversation, then improvised the proposal.
Turning bank advisors back into advisors.
A leading Central European insurance group distributes unit-linked life insurance through a bancassurance channel: investment-linked policies sold and serviced by roughly 150 bank relationship managers. FlowX.AI built an AI investment assistant that runs the policy top-up end-to-end, a ten-step, human-in-the-loop workflow embedded directly in the bank’s policy front-end.
- Insurance
- Bancassurance
- Unit-linked life
- Human-in-the-loop
- FlowX.AI SaaS
Results in the first full month in production
- 0
- Sessions started
- 0
- Applications signed
- €0M
- Allocated to funds
- 0%
- Allocations fully AI-generated
What if an agentic AI solution could reason over real client-portfolio data inside a controlled, auditable, human-in-the-loop frame, and turn bank advisors back into advisors?
The catch is in the tooling. The bank’s policy front-end was built to conclude new policies. It has no in-app servicing for the everyday request that keeps coming back: a client who wants to top up an existing policy with a new premium, or change how that premium is invested. So today the work happens around the system, not inside it: data re-entered by hand, advisors leaning on a support department to push each case through, and fund recommendations following fixed, deterministic rules rather than the client’s real context.
The starting position
Stuck in a loop of manual re-entry and static advice.
Across roughly 150 relationship managers, every top-up, fund change or policy upgrade meant collecting the same customer data and pushing it through systems that were never designed to service an existing policy. There was no advisory layer to help the RM ask the right questions or recommend the right funds.
- ~0
- Bank relationship managers
- ~0
- Applications per year
- ~0h
- Analyst effort per case
Relationship managers, who sell many product lines, cannot realistically stay current on all twelve in-house funds, their performance trends, ESG profiles or shifting market exposures. Decisions leaned on tribal knowledge and a support desk; errors and rework were common; and each top-up restarted from scratch. Three uncomfortable truths about the starting state:
Knowledge locked away
Fund brochures, KIDs, term sheets and quarterly market reports all existed, but they were not machine-readable and not linked to the process. The advisor either remembered, guessed, or called support.
Stateless logic
Each top-up or change restarted from zero. No memory of the reasoning trail, no continuity, no compounding learning.
What changed
Four pain points, resolved inside the process.
The work no longer happens around the system. Each of the servicing pain points now has a concrete answer, embedded where the advisor already works.
- Pain point
The policy front-end has no in-app path to service a top-up or policy change. Requests are handled by hand, data is re-entered across systems, and advisors depend on a support department to move each case.
How we solved itA ten-step, human-in-the-loop FlowX.AI process embedded directly in the policy front-end runs the top-up end-to-end, from launch and client search to personal-data check and signed documents.
- Pain point
Static client advice: a thin profiling questionnaire and fund recommendations that follow fixed deterministic rules, with no portfolio context or market awareness.
How we solved itThe agent generates explainable allocations across the twelve in-house funds, grounded in the client’s risk profile, existing portfolio mix, the house view and the latest market reports.
- Pain point
Knowledge locked away: brochures, KIDs, term sheets and market reports exist but are not machine-readable or linked to the client interaction.
How we solved itA versioned knowledge base is built by scraping the in-house fund pages directly, with no hand-maintained PDFs, and the yearly investment-strategy document uploaded as the one exception.
- Pain point
An existing policy is not a clean slate: its investment option constrains what is even allowed, and the reallocation rules are genuinely complex.
How we solved itPolicy selection moved to the front of the process. The system reads the investment-strategy code to classify the policy across three options, then offers only the allocation paths that are actually permitted.
The assistant
What the AI investment assistant does.
It summarizes the client’s portfolio, reads the policy’s investment option to decide what is even allowed, captures a four-question risk profile, and proposes a fund allocation with euro amounts, percentages and a justification. Only summarized, non-identifying portfolio data ever reaches the model.
Smart portfolio capture & summarization
Pulls customer data, portfolio and policies, and shows a fund-level portfolio summary alongside per-policy detail. Captures outside holdings inline by investment type, and captures the top-up amount. No sensitive personal data is sent to the model.
Policy-aware allocation
Classifies the selected policy’s investment option (1, 2 or 3) and offers only the permitted allocation paths, for the top-up and, in parallel, for the existing funds. Warns the advisor in writing when a choice steps a client out of the managed strategy.
Explainable investment advisory
Builds a non-deterministic risk understanding from four questions, then recommends an allocation across the twelve in-house funds, anchored on the neutral house view and tilted by quarterly market reports. No chasing past performance, no competitor comparison. Each fund carries a name, amount, percentage and reasoning, all editable inline.
Compliance, audit & market intelligence
Every recommendation is traceable to its inputs, rationale and fund-data version, archived in a consistent format. The knowledge base is versioned and scraped from the in-house fund house; documents are generated and routed to e-signature; the flow is fully localized and deployed on FlowX.AI SaaS.
The hard part
Why an existing policy is not a clean slate.
A top-up lands on an existing policy, and that policy carries an investment option that decides what is allowed. The assistant compresses a genuinely complex rule set into a single, legible screen: the advisor sees only the options that are actually permitted, on three paths.
The workflow
Ten steps, four phases, one human in the loop.
The advisor can accept, edit or reject every recommendation, and every decision is archived with its inputs, rationale and fund-data version for audit. Here is the whole run, start to signature.
Phase 01
Start & find the client
- 1
Launch
A button inside the policy front-end starts the FlowX.AI process and opens the advisor’s request dashboard: filterable, searchable, with open cases resumable exactly where they were left.
- 2
Client search
Surname plus tax number, both mandatory before search activates, so no one can fish on a name alone. Every client view is logged.
Phase 02
Frame the case
- 3
Portfolio in one view
Fund-level summary, outside holdings editable inline, and the in-house portfolio as per-policy cards. The top-up amount is captured here.
- 4
Select policy & option
The system reads the strategy code to classify the policy as Option 1, 2 or 3.
- 5
Choose allocation
Only permitted paths are offered for the top-up and the existing funds; every choice is saved as an audit line.
Phase 03
Advise
- 6
Profiling
Four mandatory single-choice questions feed the non-deterministic risk understanding; the questions and the outside-holdings table print in full on the form.
- 7
Recommendation
Funds with percentages, euro amounts and justification, shown as two tables when reallocation applies.
- 8
Review & validate
Everything editable inline against static rules, with a live remaining / exceeded indicator.
Phase 04
Document & close
- 9
Check personal data
Retrieved data shown with editable fields and missing-mandatory flags.
- 10
Generate, sign, finish
Documents drafted, previewed and sent to e-signature. On signature the request becomes a read-only summary.
With new business everything is simple; when you start changing an existing policy, it always brings a problem. The aim was to streamline the whole process without compromising on flexibility.
Delivery
From kick-off to production.
The plan at kick-off was tight: discovery in two weeks, build in four, go-live after two weeks of testing. In reality the pilot went live about two months later. It is worth being precise about where the slip came from, because it did not come from the build.
Kick-off
Day one
On time. Scope, success criteria and ways of working agreed.
Discovery
Slipped on workshop scheduling and the open deployment decision. The SaaS deployment model was confirmed.
Build
Ran on FlowX.AI’s internal plan. Built largely against mock data while the client APIs were not yet ready.
Integrations
The recurring bottleneck. Backend APIs and the front-end integration arrived late and incomplete.
Testing
Extended to absorb the integration work as it landed.
FlowX.AI delivered its side, the process backbone, the AI agent for the top-up and the full portfolio reallocation, the knowledge base, the localization and the e-signature integration, largely on or ahead of its internal plan, working against mock data while it waited. The delays accumulated on the client side, where the bank’s backend APIs and the policy-system integration arrived late and proved hard to test.
The two open risks named on day one, environment readiness and integration readiness, were exactly the ones that materialized. The deployment-model question was resolved cleanly and early, which kept the FlowX.AI-controlled work moving even as the integration work lagged.
Outcomes
What the first month looked like, in detail.
Three lenses on the same production month: how much it was used, what it moved, and where the time went.
Usage & adoption
- 0%
- completion rate across sessions
- ~0
- sessions per advisor in the month
- ~0
- signed applications per advisor
6,000 sessions started and 3,000 applications signed in the month, about three sessions a day per advisor. Of the sessions that did not complete, 98% were auto-cancelled under the 14-day no-agreement rule and 2% were waiting on a digital signature inside the 7-day window; 350 sessions were still active beyond two hours.
Investment activity
- 0%
- top-up plus reallocation
- €0
- average allocation per session
- 0.0
- fund options reviewed on average
Reallocation now leads simple top-ups: 55% of completed sessions were a top-up plus reallocation versus 45% top-up only. Average allocation was around €3,000 per session, €9M in total for the month.
Time & automation
- ~0h
- advisor active time per application
- 0min
- fund selection, the longest step
- 0.0d
- average client decision time
Average advisor active time per application was about two hours across the advisor-controlled steps, with fund selection the longest single step. The average client decision time, from offer presented to agreement, was 2.4 days. Half of all completed fund allocations were generated end-to-end by the AI agent with no advisor input.
Why it matters
Giving the advisor their role back.
On the surface, this is a servicing-automation and AI-advisory pilot, measurable in advisor-hours saved and in how often the recommendation is accepted. Under the surface, it is the first flow where an AI reasons over real client-portfolio data inside a controlled, auditable, human-in-the-loop frame. Not AI that promises to behave, but a demonstrable design: only summarized, non-identifying portfolio data reaches the model; every recommendation carries its rationale and the archived fund-data version; and the advisor can always accept, edit or reject.
In depth, the story is about giving the advisor their role back. Instead of a manual data-relay dependent on a support desk, the RM becomes an advisor again. The assistant holds the fund knowledge, the market context and the compliance trail, so the free hour each day goes to the client.
And the insurer’s own knowledge, today trapped in PDFs and web pages, becomes a living input the system reuses every time. That pattern, portfolio plus profile plus house view into an explainable proposal with a full audit trail, is replicable across the group’s other servicing flows. The top-up pilot is the proof that the platform can be extended.
About FlowX.AI
The orchestration platform for regulated work.
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:
- Policy Onboarding
- Claims Processing
- Fraud Detection
- Reinsurance
- Underwriting Risk
- Complaints & Disputes
- Compliance
- and more
Next
Put an auditable agentinside your servicing flow.
Bring a regulated journey and we will show you a path to production, on your core, with the human in the loop and the audit trail intact.