AI is reshaping every industry, but insurance is especially exposed because it is among the most data intensive. The question for COOs and CIOs is no longer what agentic AI can do but what decisions they must make to transform their core system so it’s capable of scaling and capturing the technology’s full benefits. It is a unique opportunity for insurance tech leaders to guide the agentic transformation, and choosing the right core modernization archetype is vitally important.
By now, most insurance companies are at least piloting agentic AI solutions. Many are starting to scale them, and a few industry leaders are already reaping clear, measurable benefits. Based on BCG experience, commercial property and casualty insurance, for example, can drastically cut underwriting cycles from 10 to 20 days to 1 to 2 days, while claims can benefit from a significant increase in straight-through processing of up to 70% to 90%, as well as contributing to material improvement in loss ratio. Given this potential, many industry leaders are looking for ways to incorporate agentic elements into the core.
The Three Archetypes for Core Modernization
There are three primary ways to transform core systems by integrating agentic elements: keeping an existing core plus an agentic platform, using a “skinny core” plus an agentic platform, and choosing a unified agentic core. Each archetype captures value at a different pace, and each carries its own level of transformation risk.
Existing Core Plus Agentic Platform. This approach keeps the legacy core largely unchanged while deploying an agentic layer that connects securely to core systems and data.
- Advantage: The fastest route to impact with the least amount of disruption, since the legacy core stays untouched.
- Tradeoff: Legacy core and integration complexity constrain benefits, and duplicate orchestration layers tend to build up over time.
Skinny Core Plus Agentic Platform. This archetype reduces core scope by moving customer interaction, workflow orchestration, business logic and rules, automated decision making, document processing, and partner orchestration to the agentic platform. Raw data, financial processing, reinsurance accounting, regulatory reporting, and the audit trail stay in the core, integrating with the data platform.
- Advantage: Captures most AI-enabled value without waiting for full core replacement.
- Tradeoff: Transition complexity related to architectural choices (such as what to retain, shift, or replace) and the adaptation of data structures and integrators.
Unified Agentic Core. With this approach, deterministic core and agentic capabilities are designed and deployed together as a single AI-native stack integrated with the existing data platform.
- Advantage: Creates the most future-proof, AI-native architecture, with core and agents designed as one system rather than two.
- Tradeoff: Involves the highest transformation effort and risk, requiring broader core redesign, stronger engineering capacity, and a longer path to value.
Vendors that offer core system platforms for insurance companies are already rolling out agentic capabilities. For example, in August 2026, Guidewire introduced an agentic framework that gives insurers the tools to build and run their own AI agents on the Guidewire Cloud Platform. Duck Creek took a similar route, launching an agentic AI platform built on an insurance-specific intelligence layer with fine-tuned language models, machine learning, and rule-based reasoning grounded in each carrier’s own data and configurations.
This activity might tempt insurers to wait for vendors to build platform models that suit them. Yet there are three arguments against waiting:
- The vendor rollout of AI-enabled platforms could be too slow.
- Those who build the operational and data foundation first will have a competitive advantage.
- A vendor platform built for general use won’t include an insurer’s own data ontology.
Making the Case for the Unified Agentic Core
Of the three archetypes, only the unified agentic core solves the underlying integration problems with existing systems and data platforms. While the alternatives do provide a temporary productivity boost as agents help developers build faster, they add extra layers on an existing landscape. With the unified agentic core approach there is one system rather than two or more that must be integrated, with deterministic components and agentic (probabilistic) components operating on the same substrate.
Of the three archetypes, only the unified agentic core solves the underlying integration problems with existing systems and data platforms.
Some advantages of a unified agentic core include:
- Faster iteration because process changes occur at a single configuration point
- Shared learning because agents accumulate knowledge from the same data assets that support transactional processing
- Lower run costs because the unified agentic core requires fewer redundant layers for high availability
- Robust control because governance and human-in-the-loop gates are embedded end to end
Solving the Orchestration Problem
For the unified agentic core to function effectively, insurance companies need to orchestrate agents to ensure they follow the right sequence of actions at a specific time and don’t act independently. This is especially true when processes require coordination across multiple agents. Underwriting integrates external data, risk assessment, pricing, and acceptance decisions. Claims management coordinates first notice of loss (FNOL), triage, damage assessment, fraud detection, settlement, and recovery.
Without an orchestration layer, autonomous agents may contradict one another, duplicate efforts, or stall waiting for inputs that no one anticipated providing. Agentic orchestration addresses this through a three-tier control hierarchy:
- An orchestrator (the “brain”) is a meta-agent that governs process flow. It knows the overall state of a process (a claim, an underwriting submission, or a customer request, for instance) and decides which agent to activate, in what sequence, with what inputs.
- Specialist agents manage specific subprocesses (including FNOL, damage assessment, liability evaluation, and reserve management), each with autonomy bounded to its own perimeter.
- Subagents and capabilities execute granular tasks such as extracting text from a document, calling an external API, and calculating a reimbursement value.
This three-tier design allows for the reuse of agents across business units and lines of business (for example, an insurer can share a claims triage specialist agent across different lines of business), supports auditing at every stage gate, and adds human oversight where compliance or risk requires it without slowing the overall process.
Following the Process Blueprint
The mechanism that makes this hierarchy functional is the process blueprint, a central concept in the unified agentic core architecture. The blueprint defines the structural boundaries of execution: which stages exist in a process, what must happen before moving between stages, which agents can be used at each stage, and what outputs are expected.
The process blueprint is the single point of configuration for workflows and agents, defining when execution must follow fixed rules (such as with mandatory stage gates, certified calculations, and auditable outputs) and when agents have autonomy (such as with ambiguity management and personalized customer dialogue).
The blueprint is an executable artifact. The platform reads it at runtime, feeds the application database (which maintains the authoritative state of each process instance, capturing both deterministic transitions and agentic actions), and is verified by the audit trail. It serves as the contract between business logic and agentic execution.
Building the Data Ontology
In addition to implementing the unified agentic core, tech leaders need to ensure all the agents are speaking the same language. Otherwise, each agent speaks its own dialect, giving different meanings to the same set of concepts. Data will be transformed at every handoff, meaning will be lost in translation, and errors will propagate.
Tech leaders need to ensure all the agents are speaking the same language. Otherwise, each agent speaks its own dialect, giving different meanings to the same set of concepts.
Without a shared language, how can a fraud detection agent know that a “car” in a submission corresponds to the same “vehicle” in motor vehicle registration authority data and is the same “auto” in the customer’s claim report? How can a pricing agent know that the coverage it is evaluating already has an associated exclusion in the system of record?
Insurance ontology is the answer. It provides a shared, machine-readable representation of the insurance domain. Some examples include entities (policy, risk, claim, party, coverage, and premium), relationships between entities (a policy contains one or more coverages, a claim belongs to a policy, a party may be either the insured or the claimant), attributes (types, constraints, and units of measure), and business rules (coverage cannot exceed a given limit, and a claim must be notified within a certain number of days of the loss event).
The ontology is a living data infrastructure that evolves with the business and with the knowledge that agents accumulate over time. It is governed as code and can be maintained by segregating it across sub business domains. For example, a product may be represented differently from a customer’s perspective than from an engineering perspective, with each view defining a unique set of subobjects and attributes. Because the ontology is deeply embedded in the core and constantly evolving, it’s not something that can easily be outsourced.
While the need for a common language is intuitive, it’s worth summarizing the profound benefits of having one:
- Shared Comprehensibility. Regardless of who built it, each agent uses the same definitions of basic concepts, eliminating manual transformation between systems and drastically reducing integration bugs.
- Contextual Reasoning. An agent reasons over semantically rich concepts, not raw data. This improves reasoning quality and reduces hallucinations.
- Embedded Governance. A good ontology embeds compliance rules (such as the EU’s General Data Protection Regulation) as constraints on data or relationships. An agent attempting to access personal data outside its authorized scope is blocked not by an external firewall but by the structure of the data itself.
- Continuous Improvement. When agents learn from experience, they do so over a shared vocabulary. Insights accumulated by a motor fraud detection agent propagate automatically to the property fraud detection agent, because both operate on the same concept of “claim fraud pattern.”
For COOs, CIOs, and other technology leaders, the business case for agentic-driven core transformation is no longer in question. The shift is already underway, and the window to shape what gets built will remain open for months, not years.
In the face of this time pressure, tech leaders should recognize that they own two key decisions related to this transformation that cannot be outsourced. The first is choosing the right architecture. Although building a unified agentic core involves more effort and risk, broader core redesign, stronger engineering capacity, and a longer route to value than other approaches, we believe it is the best long-term option for most insurers. The second decision is building and managing the data ontology. Making the correct choices in the next few months will put the organization on a clear path to success.
