
This is not an academic debate. Ownership determines priorities — speed to production, auditability, budget allocation, and the hard trade-offs between automation and human judgment. When ownership is fuzzy, pilots die in meetings, integrations stall, and frontline teams ignore tools that were meant to help them. When ownership is explicit and aligned with outcomes, AI projects become repeatable capabilities that reduce cycle time, lower leakage, and preserve regulatory defensibility.
This article walks through the tradeoffs among IT, Underwriting, and Operations, explains why a single owner rarely fits all contexts, and recommends a pragmatic ownership model that balances accountability, domain expertise, and governance.
Why ownership matters now
Claims transformation projects require more than model training. They demand data plumbing, policy mapping, operator workflows, legal sign-off, logging for audits, and continuous monitoring for drift and fairness. That means success requires coordination across multiple functions. Ownership is the mechanism that keeps the work visible and decisions fast. Without it, priorities fragment: IT focuses on uptime and security, Underwriting focuses on risk tolerance and policy interpretation, and Operations focuses on throughput and customer experience. Each of those priorities is necessary — but without a single accountable function translating them into a roadmap, nothing ships consistently.
Beyond delivery, ownership signals who pays for run-rate costs: model inference, storage, and ongoing FinOps. It also signals who is responsible for governance — change control, red-team testing, retention rules — all of which are critical in regulated lines.
The IT case: fundamentals, security, and production rigor

IT is the natural guardian of enterprise infrastructure. When AI systems require on-premise deployment, VPCs, strict logging and encryption, or need to connect to legacy policy engines and billing systems, IT’s involvement is non-negotiable. IT brings operational rigor: SLA enforcement, patch cycles, disaster recovery, and secure identity and access control. Those elements are table stakes in insurance.
IT ownership works best when the primary risks are technical: model hosting, integration reliability, data residency, and enterprise logging. In these scenarios, IT can standardize deployment pipelines, ensure model versioning and rollback, and embed observability across the stack. This reduces operational surprises and helps InfoSec sign off.
But IT-led programs often drift toward a technology-first mindset. Without domain co-ownership, they can produce technically elegant systems that do not change the day-to-day decisions of adjusters or claims handlers. IT teams may also be risk-averse around product iteration, which can choke the rapid experimentation business teams need.
The Underwriting (and Risk) case: policy, risk appetite, and model guardrails
Underwriting and risk teams own the business definition of “acceptable outcome.” They set appetite, define thresholds for exceptions, and interpret coverage nuances that separate a correct decision from a damaging one. In scenarios where AI influences liability, coverage determinations, or settlement strategies, Underwriting must own decision boundaries and escalation rules.
When Underwriting leads, projects emphasize reasoned, auditable outcomes: which clause supported a decision, what exceptions were permitted, and how pricing or reserve recommendations were derived. That domain control is essential for regulatory examinations and for protecting loss ratios.
Underwriting-led ownership is strongest where the key risk is business risk — for example, when automation could materially change indemnity payments, create regulatory exposure, or shift portfolio mix. However, Underwriting teams may not be organized to run continuous product development. If they own AI too exclusively, projects can become overly conservative, producing rigid systems that require heavy manual override and thus fail to deliver efficiency gains.
The Operations case: outcomes, adoption, and workflow integration
Operations — the claims organization itself — lives closest to the business metrics that matter: time-to-first-action, straight-through processing, recontact rates, NPS, and adjuster capacity. Operational ownership aligns AI initiatives with the day-to-day problems adjusters and claim handlers face. When claims leaders own an AI program, the scope of work centers on embedding intelligence into workflows, minimizing friction for users, and measuring the direct impact on throughput and customer outcomes.
Operations ownership also drives adoption. A tool is more likely to be used if it is introduced, measured, and iterated by the people whose KPIs depend on it. Operations teams are typically better at change management for frontline staff: playbooks, training, and incentive alignment.
The limitation is that Operations may lack the technical bandwidth to build robust, secure systems from scratch. Their focus on immediate outcomes can also discount long-term concerns like model portability, FinOps discipline, or enterprise observability unless they partner tightly with IT and risk.
A single owner rarely suffices: the hybrid product model
In practice, the best outcomes come from a product-led operating model that borrows strengths from each function. Treat AI in claims as a product with a cross-functional product team: an executive sponsor in claims (who owns outcomes), a technical lead from IT (who owns infrastructure and reliability), and a risk/Underwriting partner (who owns policies, thresholds, and audit requirements).
This product model has three advantages. First, it aligns incentives: the claims sponsor owns the KPI slate and the backlog prioritization. Second, it injects technical discipline via IT: CI/CD, observability, and security are embedded in the delivery lifecycle. Third, it keeps risk controls live and woven into design — not retrofitted after deployment. When product owners are empowered with a clear budget and an agreed RACI for decision rights, teams move faster.
Practical RACI for AI in claims (example)
- Product sponsor (Claims Ops): own roadmap, prioritize use cases, measure KPIs.
- Tech lead (IT): own deployments, infra SLAs, monitoring, incident response.
- Risk/Underwriting: own policy-to-rule mapping, thresholds for automation, audit artifacts.
- Legal & Compliance: own change controls for customer communications and regulatory filings.
- Data Science/AI: own model development, evaluation, and testing; hand off reproducible artifacts.
- Business Users (Adjusters): own acceptance testing, feedback loops, and adoption metrics.
This RACI isn’t a bureaucratic straitjacket; it’s a pragmatic guide to who should approve what, who signs off on exceptions, and who funds ongoing costs.
Governance patterns that make ownership stick

Three governance practices prevent ownership from becoming merely a slide on a strategy deck.
First, codify policy as code. Business rules, redaction requirements, and escalation thresholds should be encoded so the Supervisor layer can enforce them automatically. This reduces debates over “what the rule said” and generates auditable evidence for examiners.
Second, require provenance for every action. Each recommendation should carry the data sources, model version, confidence score, and link to the policy clause. This provenance is essential for both internal QA and external examiners.
Third, instrument continuous evaluation. Ownership is not a one-time handover. Teams should define acceptance gates (both quality and risk), run canary releases, and keep a Critic process that samples outputs to detect drift or bias. These evaluation loops show whether the product is healthy and who must intervene when it is not.
For a practical blueprint on turning demos into production-grade orchestration, see this walkthrough of agentic orchestration patterns. (internal link)
Real tradeoffs when ownership is misaligned
When IT owns a program without sufficient commercial sponsorship, the outcome is often a technically robust system that nobody uses. When Underwriting insists on owning everything, teams can get stuck in lengthy approval cycles that prevent iteration and learning. When Operations claims ownership without IT or Risk in the loop, deployments can expose the firm to outages, compliance lapses, or unexpected spend.
One common failure pattern: a pilot built with good intentions that automates a small part of the process but lacks a path to connect to the claims platform and the policy library. The pilot shows accuracy, but months later it remains in a sandbox because nobody funded the integration work. Ownership ambiguity caused the stall.
Who should sign the ROI check?
A practical way to decide ownership is to ask: who benefits most if the project hits its KPIs? If the primary value is operational (faster FNOL handling, fewer touches), claims/operations should sponsor the program and commit budget. If the primary value is reduced loss, reserve accuracy, or portfolio tilt, Underwriting should lead. If the program’s main risk is technical (infrastructure, scale, security), IT should be the operational steward with a business sponsor.
Often, the clearest path is co-funding: Operations funds the product roadmap and feature prioritization; IT funds the shared platform and core infrastructure; Risk underwrites the compliance and retention costs. Co-funding creates a natural governance forum and aligns incentives.
Starting small, scaling fast: an ownership playbook
Begin with a narrow, measurable use case owned by claims ops (for example, automated FNOL triage). Embed IT in day one to scope integration work. Engage Underwriting and Compliance to define minimal guardrails. Run a 30/60/90 plan: pilot in a controlled geography or product line, measure KPI deltas, then scale with templates and contracts.
Maintain a “pattern catalog” so each new use case does not reinvent integration, provenance, or governance work. Over time, the catalog turns into a platform that reduces time to value for subsequent launches.
If you want a practical 90-day plan for moving from pilot to production in claims, our playbook on policy-as-code and orchestration shows the patterns insurers use to operationalize these roles. (internal link)
Final word: ownership is about outcomes, not org charts
The right owner for AI in claims is less about org charts and more about accountability for outcomes. Whoever owns it must be empowered to prioritize, funded to act, and connected to the teams that manage risk and run infrastructure. Treat AI as a product: give it a sponsor in claims, build with IT discipline, and bake governance into the code. That is the most reliable route from promising pilot to repeatable advantage.
For industry perspectives on scaling AI in insurance and practical implementation guidance, the BCG analysis of generative AI in claims is a useful frame for potential efficiency gains, and PwC’s research explains how AI shifts operating models across underwriting, claims, and customer care. Schedule a strategy call with A21.ai.

