Agents Are Becoming The New Interface To Your Software. In Risk Modeling, The Real Design Question Is The Cage.

In recent weeks, OpenAI's Dots and Meta's Muse have placed an agent between people and the applications they use. LLM platforms seem to become the new operating system, domain-specific agents the new apps, and the products most exposed are those whose value lives in the interface rather than underneath it. 

That is a question every software vendor now has to answer, including us. Our financial and risk modeling platform, Neuroine, is exactly the kind of tool where a person sets parameters, launches runs, and reads reports, which an agent can do just as well. So we took the question literally and asked what an agent could do inside a modeling platform, and what has to surround it for a regulated insurer to accept it. Here is what we learned.

If a modelling platform's value were its interface, an agent would replace it. Ours sits elsewhere: versioned models, configurable and reproducible runs, GPU execution, and the governance that lets a risk function sign off on what comes out. None of that is a screen. 

Take GPU execution. Risk simulations, whether they project financial trajectories, run stress tests or model portfolios of activities and commitments, rest on a very large number of independent cases. That massively parallel structure suits NVIDIA GPUs well: Neuroine is built on CUDA and its ecosystem of libraries, including cuRAND for the random number generation behind Monte Carlo and stochastic scenarios, so that each scenario can run in parallel across thousands of cores. It also matters for the agent. One that relaunches runs and compares their outputs in a loop is only useful if those runs come back quickly. 

We also drew a second conclusion. If agents are going to operate software on people's behalf, then the best place for one in a regulated function is inside the platform, with the platform's own controls around it, rather than outside it holding a copy of the keys. 

Most "AI in actuarial software" announcements describe an assistant that answers questions about the tool. On Neuroine, the agent does something different: it works inside the tool, with the same action surface as a human modeler. It writes and explains model code, analyses simulation results, builds a dashboard from a single prompt, and when something breaks, it debugs the way a developer would: it sets breakpoints, relaunches, reads the results and loops until it finds the cause. 

The difference between a chatbot and an agent is not the model; it is what the model can touch. Neuroine's toolset is complete: code editor, debugger, run interfaces, dashboard builder, automated stress tests, and model flow visualization. We rebuilt each of these features as a tool the agent can call, so it can pilot the platform, scan databases and codebases, launch runs, and analyze the results. An agentic harness, in the same family as the tools developers use to code with AI, orchestrates it, and we configured it precisely to give the agent that full set of tools. 

Two things follow, and both surprise clients in demos. 

The first is how little domain-specific training it needs. The agent runs on a general-purpose model, not one specialized in asset-liability management. Asked to build a dashboard from the key KPIs of an ALM model, it produces a credible business dashboard. Asked to write the pitch for top management on a liquidity model it has never seen, it returns a well-sequenced analysis. The value comes less from the model than from the access we gave it. That access includes actuarial skills, written as simple files (.md) that explain to the agent how to work on Neuroine: they are part of the toolset, not a specialized model. 

The second is that the protocol is a small part of the work. MCP, the standard that lets an agent call a tool, is the format of the exchange. Making an agent effective across a complex piece of software means handing it a large, coherent set of tools, not a single key. Building complete software for humans is already a big job. Building its agent twin, with every function reachable and consistent, is a second one. 

Technically, nothing stops the agent from running fully on its own. We chose not to let it. In regulated, critical functions for an insurer, capability is the easy part. 

An agent that holds the same rights as a human raises the question we wrote about in our work on agentic control towers: who decided it could act, and can you stop it? On Neuroine, the answer is built in at four levels. 

• Containment: the agent cannot leave Neuroine, and within Neuroine, it cannot leave the workspace in which it was invoked. 
• Isolation: it runs on infrastructure disconnected from the internet, with no search function, so it cannot reach services that nobody authorized. 
• Human validation: the agent completes the task, explains what it found or changed, and the human decides whether to push the modifications. This is by design, not a technical limit. 
• Traceability: everything the agent touches is recorded, on top of the platform's versioning of data, code, and results. 

The effect on the client's own governance is worth noting. A SaaS platform already undergoes an IT security assessment, including how it connects to the company's databases and consolidation tools. The agent adds a new dimension to that same process: what rights does it hold, how is it authenticated, and how do those rights propagate? A second, compliance-oriented layer follows: which model is used, under which contractual terms, whether any data leaves the perimeter, and how it all fits the EU AI Act and the company's internal AI framework. This is not a new process. It is the existing one, extended to an actor that can decide.

The part of the work the agent takes first is the repetitive one: reconfiguring runs, launching them, and comparing outputs to fill tables. What it gives back is time for the part that has always been the actuary's: choosing which stress test matters, drawing the lesson from a historical crisis and deciding to replay it, judging whether an analysis holds, and signing off. 

The written analysis the agent produces is a first draft, and it is the actuary who reviews, challenges, and sharpens it. That is why the validation step sits where it does. The model stays owned by the people accountable for it.