We build the systems insurance should have had all along.

RegenAI InsurTech. Viola is its flagship platform. The team pairs insurance operators with AI engineers. Some have run underwriting desks and claims queues. Others build agent systems for a living. You can reach the company at connect@regeninsurtech.com. That pairing is deliberate rather than incidental. Insurance software has a long history of being built by people who have never worked a queue, which is how a product ends up technically correct and operationally wrong: the screen holds every field the data model needs and none of the ones the job needs. Putting the people who ran the desks next to the people building the agents is the correction, and it shows up in a platform organised around desks rather than modules. It also shows up in what the platform refuses to automate. The decisions that carry risk — pricing approvals, reserves, settlements — stay with people, because the operators on the team know which judgments are actually judgments and which are only habit. That line is harder to draw than it sounds, and drawing it wrong in either direction is costly: automate a real judgment and you inherit a liability, leave a habit manual and you have automated nothing.

AI-native, and that was the founding bet. Generative and agentic AI changed what was buildable. The obvious move was to wrap AI around an existing core. We built the core itself AI-first instead, from the first line of code. Multi-agent intelligence orchestrates the entire policy lifecycle, from first submission to final settlement. Wrapping is the cheaper path and it caps out quickly, because the legacy core still dictates the sequence: an assistant can summarise a file but cannot change how the file moves. Building the core AI-first means the agents are the workflow rather than a layer above it, so intake, rating, document analysis, and claims decisions run in parallel instead of queuing behind one another. The bet carried real risk. Building a core from scratch means competing on ground where incumbents have thirty years of accumulated edge cases, and it only pays off if the architecture advantage compounds faster than that. The wager was that it does, because every transaction feeds back into the platform’s intelligence rather than merely into its database.

Viola is built for MGAs and program administrators, carriers, and digital insurers. What they have in common is ambition constrained by tooling. An MGA wants a new program live this quarter, not next year. A carrier wants to retire a legacy core without betting the book on a migration. A program administrator wants one source of truth across a high-volume auto book. Viola is designed for all three. One platform can serve three different shapes of operation because products, rates, and rules are configuration rather than a bespoke build, and because adoption can start with a single desk. An insurer can deploy where the pain is, keep the rest of the estate, and expand once it has earned the expansion. The three also share a constraint that is easy to miss: none of them can afford a migration that puts the in-force book at risk. That is why the platform is API-first and deployable module by module rather than as a cutover, and why a partial deployment reads and writes the same record as the rest of the estate.

To give insurers the speed, flexibility, and intelligence to compete without waiting on legacy vendors or six-month projects. In practice that means four things. Automate complex workflows end to end. Cut operating cost and vendor dependency. Open new markets in days rather than months. Return teams to strategy, judgment, and customers. The fourth is the one the other three exist to serve. Most insurance operations lose their best people to work that is not really theirs: re-keying data between systems, chasing a vendor ticket, assembling a file before anyone can judge it. Removing that work is not an efficiency argument alone, it is what puts underwriters back on risk and adjusters back on claims. The three that serve it are measurable in a way the fourth is not. Automation shows up in cycle time, cost shows up in the vendor line, market entry shows up on a calendar. Whether the work got better is harder to instrument, which is exactly why it is stated as the mission rather than left implied. It is also the one an operator can answer immediately. Ask an underwriter how much of last week went on risk rather than on assembling files, and the number arrives without a dashboard.

Nothing consequential happens in the dark. Nothing irreversible happens without a person’s hand on it. Rates are versioned and approval-gated. Privileged actions are logged. Access is role-based. Human gates sit on the decisions that carry risk. The principle is simple: insurance operations should be fast, intelligent, and fully in the operator’s control. In practice accountability is structural rather than promised. A rate version cannot price a policy until it has passed draft, review, and approve, and it is frozen once approved, so the pricing evidence is a by-product of pricing rather than something reconstructed later. The Concierge is role-aware, account-scoped, and asks for confirmation before it acts, so the same standard applies to conversational actions.

An insurer being able to change its own operation without asking permission from its software. Concretely, that means four things. Automate complex workflows end to end. Cut operating cost and vendor dependency. Open new markets in days rather than months. Return teams to strategy, judgment, and customers. The test is whether a change needs a vendor ticket. In Viola, products, rates, and rules are configuration. The measure of it is a new state going live in five working days: rate tables imported, factors and rules configured, actuarial review, version approved and scheduled, first policy bound. None of those days is spent waiting on a release window. Autonomy does not mean ungoverned, though; every one of those changes still carries an approval trail.

The people who run the queues sit beside the people who build the agents. Adjusters and underwriters shape the product directly, not through a requirements document passed down a chain. Part of the founding team spent years inside insurance operations, watching good people fight bad systems. That experience is why the platform is organised around desks rather than modules. The distinction is not cosmetic. Modules mirror the vendor’s internal structure; desks mirror the way the work actually moves, which is where the handoffs go wrong. A requirements document also loses exactly the detail that matters most, the small friction an experienced adjuster has stopped noticing because they have worked around it for years, and that detail only surfaces when the two sit together.

Shipping what removes friction today instead of promising what arrives next year. Every feature has to earn its place by making a real desk faster, a real decision cleaner, or a real cost lower. The platform improves with every policy it writes, and each release is judged on that standard rather than on how it demonstrates. Those are different tests and they pull in different directions. A feature that demonstrates well shows a capability; a feature that works well removes a step. The second is harder to put on a slide and is usually what an operator actually notices. Holding to it is also why the roadmap is stated in terms of what is live now, personal auto today and commercial lines next, rather than what is planned.