The autonomy decision: where underwriters judge and where agents execute

One of the most significant changes in this era of AI isn't a specific capability. It's a new dimension in how software works: autonomy.

For most of computing history, software was reactive. You came to it. You told it what to do. You operated it. Every action required a human to initiate it -- open the submission, populate the fields, run the model, generate the quote. The system waited.

That constraint shaped everything downstream. McKinsey estimates 30-40% of underwriting time goes to administrative tasks like rekeying data and manually executing analyses. hx's own research puts the figure at 42% across underwriter time at major carriers, with underwriting assistants spending up to 80% of their time on rekeying alone. Pricing teams iterated models over weeks. Portfolio visibility arrived quarterly when exposures changed continuously.

AI agents change the premise. You set objectives and boundaries. Agents plan, execute, and report back. The system acts.

Think of it as a slider

At one end, full manual control. You invoke every action. The system waits. This is where high-touch specialty underwriting lives: complex risks, bespoke terms, relationship-driven negotiations. The human expertise is the product.

At the other end, agent-led execution. You define goals and constraints. Agents handle the rest and surface results. This is where algorithmic underwriting and straight-through processing already work for standard risks.

The interesting zone is the middle. You keep manual control of high-stakes decisions. You delegate routine, rules-based, data-heavy tasks to agents. Expert judgment stays central, but agents handle the execution mechanics around it.

You don't pick one position for everything. A specialty underwriter might configure agents to fully handle submissions under £50k that fit clear appetite, prepare drafts for mid-range submissions, and escalate everything above £250k or outside guidelines. The position shifts based on complexity and stakes.

Agents collapse the stack

Traditional underwriting workflows are fragmented. Underwriters bounce between email, Excel, the rating tool, the policy admin system, and back to email. Each transition means manual data transfer, context switching, and re-validation.

Agents operate across all of those systems. Instead of an underwriter manually executing nine separate steps to get from submission to quote, the agent handles extraction, population, initial pricing, and drafting. The underwriter reviews a complete package and decides.

This matters for actuarial teams too. Instead of exporting data from one system, transforming it in R or Python, running models, then manually transferring outputs back into production, agents can execute that entire pipeline and surface results for validation. Model iteration cycles that took weeks can compress to hours.

The tracking problem

When agents operate autonomously in a regulated industry, you need to know what they're doing, how they're deciding, and whether they're producing value.

Every agent action needs full context: what triggered it, what data it used, what logic it applied, what it produced. When an agent drafts a quote, you should see which pricing model it applied, how it handled missing data, which appetite rules it checked. This creates a complete audit trail as a native property of the system, not as documentation assembled after the fact.

You also need to measure whether agents are actually delivering. Throughput (how many submissions triaged, how many quotes prepared). Quality (how often underwriters override agent decisions, and what patterns emerge in those overrides). Consistency (are agents applying models uniformly, catching appetite breaches reliably, escalating the right cases).

Regulators, reinsurers, and internal compliance all need proof of how decisions were made. When an agent makes a decision autonomously, the reasoning has to be captured as it executes. Reconstructing it after the fact isn't good enough.

What this looks like in practice

hx was built around this kind of controlled autonomy. The platform lets you define which tasks agents handle autonomously and which require human approval, with different thresholds by line of business, submission size, or risk complexity.

Every agent action gets captured with full context automatically. You see agent activity alongside human activity in the same view, with throughput, quality, and consistency metrics surfacing continuously rather than through manual reporting.

When an agent drafts a quote or flags a concern, the system shows its working: which model, which inputs, which rules, why. Underwriters trust the output because they can see the process. When they override a decision, that correction feeds back into the system, improving future performance while keeping humans in control.

For actuaries, agents can run entire pricing iteration cycles, generate performance reports, and prepare model deployment packages without leaving the platform. The actuary focuses on interpreting outputs, validating assumptions, and deciding what goes to production.

Where to start

Map your current workflows.

Where do underwriters spend time on data gathering versus actual risk judgment? Which tasks follow clear rules versus requiring interpretation? Which activities create bottlenecks when volume spikes? Where do consistency issues show up across team members?

Rules-based, high-volume, low-judgment work gets delegated to agents with proper boundaries and tracking. Complex judgment, high-stakes decisions, and relationship management stay under direct human control.

Most work falls somewhere in between. Agents prepare, surface, flag. Humans review, adjust, approve.

The carriers that move fastest will be the ones who figure out where to set these boundaries for each workflow, build the tracking to prove it's working, and redirect expert time from routine execution to the judgment calls that actually drive profitability.