Who builds the Agentic Actuary?

We recently had the privilege of taking a prospective client through the ByteCat platform. This is exciting for both parties: we get to show off and validate our thinking, and clients get to explore what is possible with a modern technology stack.

This time was no different. We were deep in the demonstration and had already generated a couple of "oh-wow" moments. While we were stepping through the platform's agentic AI capabilities, however, the client asked: "Wait, am I supposed to understand how to maintain all this?"

In my mind there's a simple answer to this question (it's yes, by the way), but the blunt phrasing, and my blunt response, made me pause again on what I believe is a critical inflection point for the actuarial profession.

It's widely expected that the world is about to change.

The nature of traditional actuarial work makes it an ideal candidate for agentic AI transformation. Anything that is repeatable, rule-driven, or part of a defined calculation chain can and will become agent-executable. Think data preparation and cleaning, assumption basis calibration, model run execution and reconciliation, and the updating of standard reports.

If a domain of knowledge can be documented, its associated processes are potential targets for agent execution. Think about model maintenance and validation: if an agent is taught how a product is structured and how a model is defined, the agent can make changes to the model, identify gaps, and fix issues.

This implies that actuaries will spend more time validating results, applying judgement, and generating insights, while agents do most of the grunt work. These agents will need to be tailored to an insurer's unique products, processes, and technical landscape.

Who builds these agents?

The knee-jerk response is that AI solutions are, by nature, software solutions, and are therefore the responsibility of the IT function to build and maintain, with users providing the requirements. There is merit to this point: setting up robust agentic AI solutions requires careful integration into the IT landscape (orchestration frameworks, CI/CD pipelines, tool-calling infrastructure, and more), work that simply doesn't fit inside the actuarial function.

The problem is that judgement cannot be outsourced. As agents take on larger portions of core work, actuaries must understand how those agents are designed and monitored, and must be able to change them throughout their lifetimes. The output of an agent is signed off by actuarial, and the operation needs to be owned by them, too.

Actuaries as agentic AI engineers

Actuaries therefore need to be fully comfortable with their AI toolsets, not just the use and operation of them, but the logic, rules, and constraints the agents follow. This might look like a step-change from today, but it isn't a new principle. Projection models are already designed, reviewed, and signed off by actuaries. Agents are the same kind of asset. They must be built, reviewed, and owned inside the actuarial function, and actuaries need to start thinking of themselves as agentic AI engineers.

A generic agentic engineer designs, builds, and maintains intelligent systems made up of autonomous agents that reason, plan, and use tools to act towards goals with minimal intervention. But the actuary's version of this role is narrower and sharper. Actuaries will not build the orchestration engine, the deployment pipeline, or the observability platform: that is infrastructure, and it belongs with IT. What actuaries build is the agent mind: the knowledge the agent encodes, the rules and constraints it must obey, the definitions of what "correct" means, and the guardrails that keep it inside actuarial control. In practice that means:

• Actuaries will design the agent process and workflow. Where do humans stay in the loop? Where does the agent have autonomy?
• Actuaries will define the agent's knowledge, the rules it must adhere to, and the skills it may use.
• Actuaries will define what evaluation and observability must capture: the test vectors, the correctness oracle, the definition of model drift, and the pass/fail thresholds. They will not own the monitoring stack, but they will decide what it is required to measure and what a failure looks like.
• Actuaries will design guardrails that satisfy actuarial controls, not just generic safety.
• Actuaries will own ultimate accountability for the accuracy of the agentic work product.

In short: actuaries author and monitor the mind, not the plumbing.

The conundrum

For actuaries to own the mind, however, agentic solutions need to be designed to allow for this ownership. In practice this will mean:

• Auditability of the work the agent performs.
• Justification and traceability of the decisions it makes: every output must be explainable back to the rule, assumption, or input that produced it.
• The ability to test changes to the agent mind at scale. Because agent behaviour is non-deterministic, a change must be validated across many simulated runs to measure its effect on reliability.
• Transparency of operating parameters, and the ability for actuaries to maintain and change them, not merely read them.
• Agent harnesses that satisfy IT general controls (ITGCs) while also enabling actuarial governance and maintainability.
• Deep integration with the existing processes and applications.

This is where the design of the software matters as much as the skill of the actuary. As Lance argued in our previous article, software platforms need to become agent-native, not just have agent capability bolted on at the surface. An agent integrated shallowly can be operated, but it cannot be governed to this standard: the auditability, traceability, and parameter control simply aren't reachable from the outside. If actuaries are to genuinely own these agents, the control surface must be built into the execution core from the start.

Back to the question at hand

So, will actuaries have to maintain "all this"? Yes. Not the agent infrastructure, but the agent mind: the knowledge, the rules, the guardrails, and the accountability. This is the only way agentic outputs can be brought under actuarial governance and control.

That is a real shift in the profession: the grunt work moves to the agents; what stays, and grows, is the judgement, the design of how these systems reason, and the responsibility for what they produce. Actuaries will need to build genuinely new skills to do this, not to become software engineers, but to become fluent enough in how agents are designed, governed, and evolved to own them with the same authority they own their models and results today. The function that builds this capability doesn't shrink as agents take on more. It moves up the value chain.

A closing question to ponder: how will you need to alter your actuarial function to incorporate these new responsibilities?