Inferensys

Integration

AI Integration for Duck Creek AI Copilot

Build and integrate custom AI copilots directly within the Duck Creek platform to provide adjusters and underwriters with contextual assistance, data lookup, and workflow guidance, reducing manual tasks and improving decision consistency.
Developer using AI copilot for code completion, IDE visible on laptop screen, casual programming moment at desk.
ARCHITECTURE FOR ADJUSTER AND UNDERWRITER ASSISTANCE

Where AI Copilots Fit in the Duck Creek Workflow

A practical blueprint for embedding contextual AI assistants directly into the Duck Creek platform to augment, not replace, existing adjuster and underwriter workflows.

An effective AI copilot for Duck Creek integrates at three key layers: the user interface, the workflow engine, and the data layer. For adjusters in Duck Creek Claims, this means embedding a chat or sidebar assistant within the claim file workspace that can access context from the active claim's exposures, activities, notes, and attached documents. For underwriters in Duck Creek Policy, the copilot surfaces within the submission or policy screen, grounded in the application data, prior history, and underwriting guidelines. The copilot acts as a real-time consultant, pulling from these sanctioned data sources to answer questions, draft correspondence, or suggest next steps without requiring the user to navigate away or run manual reports.

Implementation connects via Duck Creek's APIs and event framework. A typical pattern involves deploying a lightweight service that listens for events like ClaimViewed or ActivityCreated. This service fetches the relevant record context (e.g., claim number, policy details, recent notes) and makes a secure call to an LLM. The response is formatted as a suggested activity note, a draft letter using a Duck Creek Document Template, or a recommendation that can be approved and logged with a single click. Crucially, all copilot actions are routed through the same audit trails and approval workflows as manual actions, ensuring governance. For example, a copilot-suggested reserve change would create a task for supervisor approval in the workflow queue before being committed.

Rollout focuses on high-frequency, low-risk tasks first to build trust and demonstrate value. Initial use cases often include: summarizing long activity notes into a bulleted timeline, drafting standard coverage acknowledgment or status update letters, or performing rapid calculations (like rental day extensions) based on data in the file. This phased approach allows teams to refine prompts, establish human-in-the-loop guardrails, and measure impact on cycle time for specific tasks before expanding to more complex reasoning. The goal is not full automation, but to convert hours of manual review and composition into minutes of assisted verification, allowing experienced staff to focus on complex judgment and customer interaction.

AI COPILOT ARCHITECTURE

Key Integration Surfaces in Duck Creek

Core System APIs for Contextual Retrieval

An AI copilot's primary value is delivering relevant, actionable information. Integration with Duck Creek's core modules via their RESTful APIs is essential for grounding responses in live policy and claim data.

Key Integration Points:

  • Duck Creek Claims API: Retrieve claim details (FNOL data, exposures, reserves, activities, notes, documents) to answer adjuster questions about a specific case.
  • Duck Creek Policy API: Fetch policy information (coverages, limits, endorsements, insured details) to verify coverage and guide decisions.
  • Duck Creek Billing API: Access payment history and billing status to handle customer inquiries about premiums or payments.

The copilot uses these APIs to perform real-time lookups, ensuring its guidance is based on the current system state, not stale data. This requires secure service account authentication and careful API design to minimize latency for the end-user.

INTEGRATION PATTERNS

High-Value Use Cases for Duck Creek AI Copilots

Practical integration patterns for embedding AI directly into the Duck Creek platform, enabling adjusters, underwriters, and service agents to work faster and more accurately within their native workflows.

01

FNOL Triage & Data Capture

Integrate AI to automate the First Notice of Loss intake. Use speech-to-text and NLP to process claimant calls or chat transcripts, automatically populating the FNOL activity in Duck Creek Claims with structured loss details, coverage verification flags, and initial triage severity. Reduces manual data entry and speeds up assignment.

Minutes -> Seconds
Data capture time
02

Adjuster Copilot for Complex Claims

Embed a context-aware AI assistant directly in the adjuster's workspace. The copilot grounds its responses in the specific claim file, using Duck Creek's APIs to retrieve notes, exposures, and documents. It can draft complex correspondence, summarize lengthy medical records, and suggest next steps based on claim type and jurisdiction.

1 sprint
Typical PoC timeline
03

Document Intelligence for Supplements

Connect AI document processing services to Duck Creek's document management layer. Automatically extract line items, parts, and labor rates from repair estimates, medical bills, and police reports. Compare against initial appraisals to flag discrepancies, missed items, and potential supplements for adjuster review, posting findings directly to the claim file.

Batch -> Real-time
Review workflow
04

Reserve Setting & Financial Monitoring

Integrate predictive AI models with the claim's financials module. Models analyze claim facts, notes, and historical patterns to provide initial and ongoing reserve recommendations. Outputs are delivered via API to pre-populate reserve screens in Duck Creek with model reasoning, flagging high-uncertainty claims for manual review.

05

Subrogation & Recovery Identification

Augment Duck Creek's rules engine with AI to automate subrogation spotting. After each activity update, an AI service analyzes loss descriptions and third-party data to identify potential liable parties. It can automatically create subrogation activities, draft initial demand letters, and set diary dates for follow-up, all within the native workflow.

Same day
Identification lead time
06

Customer Portal Virtual Assistant

Embed an AI-powered virtual assistant in Duck Creek Customer Engagement portals. The assistant uses real-time policy and claim context via APIs to answer status questions, guide document uploads, explain coverages, and collect information for supplements—logging all interactions back to the claim activity log for a unified audit trail.

DUCK CREEK AI COPILOT IMPLEMENTATION

Example Copilot Workflows and Triggers

These are concrete examples of how a custom AI copilot can be integrated into the Duck Creek Claims and Policy workflows. Each workflow details the trigger, the data context pulled from Duck Creek, the AI action, and the resulting system update or human review point.

Trigger: A new claim is created via the Duck Creek Customer Engagement portal, IVR, or agent desktop.

Context Pulled:

  • Claim exposure details (loss type, date, location)
  • Related policy data (coverage, limits, deductibles)
  • Initial contact report (first-party statement)
  • Any uploaded documents (photos, police report)

AI Agent Action:

  1. Uses a multi-step orchestration to:
    • Classify the loss severity (Low/Medium/High/Complex) based on loss type, coverage, and initial details.
    • Extract key entities (names, addresses, VIN, property address) from unstructured text and documents.
    • Perform an initial coverage check against the policy's active forms.
    • Predict optimal assignment based on adjuster expertise, current workload, and jurisdiction.

System Update / Next Step:

  • The copilot populates the Claim.Exposure and Claim.InvolvedParty records with extracted data.
  • It sets the Claim.ComplexityScore and Claim.RecommendedAssignment fields.
  • It triggers a Duck Creek Workflow Automation rule to either:
    • Auto-assign low-complexity claims and create the first diary activity.
    • Route to a supervisor queue for manual assignment of medium/high complexity claims, with the AI's recommendation and reasoning attached.

Human Review Point: Assignment and complexity scoring for all non-low severity claims are presented to a supervisor for approval before the workflow proceeds.

BLUEPRINT FOR A PRODUCTION COPILOT

Implementation Architecture: Connecting AI to Duck Creek

A technical guide for integrating a custom AI copilot into the Duck Creek platform, connecting to its data model, APIs, and user workflows.

A production-ready AI copilot for Duck Creek integrates at three key layers: the data layer, the API/event layer, and the user interface layer. At the data layer, the copilot requires secure, read-only access to core Duck Creek objects—Claims, Policies, Parties, Activities, and Financial Transactions—via the platform's REST APIs or a replicated data store. This provides the context needed for grounded responses. At the API layer, the integration listens for events (like a claim assignment or a diary note creation) via webhooks or message queues, triggering the copilot to generate summaries or recommendations. At the UI layer, the assistant is embedded as a web component within the Duck Creek Author, Express, or Customer Engagement portals, allowing adjusters and underwriters to interact via a chat interface without leaving their workflow.

The core implementation involves an orchestration service that sits between Duck Creek and your AI models. This service handles: 1) Context Building, by querying the relevant Duck Creek APIs to assemble a complete view of the active claim or policy; 2) Prompt Engineering, injecting this context and role-specific guidelines (e.g., "You are a senior auto adjuster at ACME Insurance") into the LLM call; 3) Tool Calling, where the copilot can execute approved actions—like creating a follow-up Activity, drafting a correspondence template, or looking up a parts code—via secured API calls back to Duck Creek. All interactions are logged with full audit trails, linking copilot suggestions to the user, session, and source data records for governance.

Rollout should follow a phased, use-case-driven approach. Start with a read-only contextual Q&A agent in a single portal, allowing users to ask natural language questions about the claim in front of them (e.g., "Summarize the latest medical report" or "What's the current reserve?"). Next, introduce assistive drafting for frequent, time-consuming tasks like composing complex coverage letters or summarizing a 50-page police report. Finally, pilot prescriptive workflows, where the copilot suggests next-best-actions—such as "Flag for subrogation based on the police report narrative"—which require a human-in-the-loop approval step before any system-of-record update is made. This controlled progression builds trust and allows for monitoring of AI-assisted decision quality.

Governance is critical. Implement role-based access control (RBAC) so the copilot's knowledge and suggested actions are scoped to the user's permissions within Duck Creek. Establish a prompt management and versioning system to ensure consistency and allow for rapid iteration. Finally, create a feedback loop where user approvals/rejections of copilot suggestions are used to retrain or refine the underlying models. This architecture ensures the AI copilot augments—rather than disrupts—the proven Duck Creek workflows your team relies on, turning it from a novelty into a daily productivity driver. For related patterns on grounding AI in insurance data, see our guide on AI Integration for Insurance Document Management.

INTEGRATION PATTERNS

Code and Payload Examples

Ingest and Process FNOL Documents

When a claimant uploads a police report or estimate via the Duck Creek portal, a webhook triggers an AI service to extract structured data. The extracted fields are validated against policy and claim context before being posted back to the claim file, reducing manual data entry.

python
# Example: Webhook handler for document processing
import json
from inference_systems_client import ClaimsAIClient

def handle_document_webhook(request):
    """Process document from Duck Creek Document Management."""
    payload = request.json
    claim_id = payload.get('claimNumber')
    doc_url = payload.get('documentUrl')
    doc_type = payload.get('documentType')  # e.g., 'PoliceReport', 'Estimate'

    # Call AI extraction service
    ai_client = ClaimsAIClient()
    extraction_result = ai_client.extract_claim_data(
        document_url=doc_url,
        doc_type=doc_type,
        claim_context={'claimId': claim_id}
    )

    # Map extracted data to Duck Creek API payload
    dc_payload = {
        "claim": claim_id,
        "transaction": "AI_DATA_INGEST",
        "fields": [
            {"fieldName": "lossDescription", "value": extraction_result.get('description')},
            {"fieldName": "otherParty", "value": extraction_result.get('otherDriver')},
            {"fieldName": "pointOfImpact", "value": extraction_result.get('damageLocation')}
        ]
    }
    # Post to Duck Creek Claims API to update the claim
    post_to_duckcreek_api('/api/claims/update', dc_payload)
    return json.dumps({"status": "processed", "claim": claim_id})
AI COPILOT INTEGRATION FOR DUCK CREEK ADJUSTERS

Realistic Time Savings and Operational Impact

How integrating a custom AI copilot into the Duck Creek Claims interface changes daily workflows for adjusters and underwriters, based on typical implementation outcomes.

Workflow / TaskBefore AI IntegrationAfter AI IntegrationImplementation Notes

First Notice of Loss (FNOL) Data Entry

Manual form filling from call notes or PDFs (15-25 mins)

AI auto-populates fields from uploaded documents (5-8 mins)

Copilot extracts data from police reports, photos, and emails via Duck Creek APIs

Claim File Summarization

Adjuster manually reviews 50+ activity notes (30-45 mins)

AI generates a chronological summary on demand (Instant)

Summary is grounded in claim system data and appended as a diary note

Coverage Verification & Questions

Manual policy document lookup and cross-reference (10-20 mins)

AI answers natural language questions with cited policy clauses (1-2 mins)

Copilot queries the Duck Creek Policy data model via secure tool-calling

Correspondence Drafting (e.g., coverage denial)

Manual drafting based on templates and claim specifics (20-30 mins)

AI drafts a compliant, personalized letter for review (5 mins)

Adjuster reviews, edits, and approves; audit trail maintained

Reserve Setting Recommendation

Manual analysis of similar historical claims (15-25 mins)

AI provides initial reserve range with reasoning (Instant)

Model uses internal claims data; adjuster sets final reserve

Subrogation Potential Flagging

Periodic manual review or rule-based alerts (Next-day)

AI scores each new claim at FNOL for recovery likelihood (Real-time)

Score appears in adjuster workspace; high-potential claims are routed

Regulatory & Compliance Check

Manual checklist review for state-specific requirements (10-15 mins)

AI highlights required actions based on claim attributes (Instant)

Integrated with Duck Creek's rules engine for state/line-of-business logic

ARCHITECTING FOR CONTROL AND CONFIDENCE

Governance, Security, and Phased Rollout

A production-grade AI copilot integration requires deliberate controls for data security, decision auditability, and incremental user adoption.

Integrating an AI copilot into Duck Creek Claims or Policy requires a zero-trust data architecture. AI services should never have direct, persistent access to your Duck Creek databases. Instead, all interactions are mediated through secure, purpose-built APIs that enforce role-based access control (RBAC) from Duck Creek's user context. For example, an adjuster's copilot session should only be able to query claims data for which they are the assigned handler. All tool calls—whether fetching a policy document via the Duck Creek API or writing a summary note back to a claim—must be logged with a full audit trail linking the AI action to the initiating user, session, and timestamp for compliance and explainability.

A phased rollout is critical for user adoption and risk management. Start with a read-only pilot for a small group of adjusters, focusing on low-risk assistance like rapid policy lookups, claims history summarization, and FAQ retrieval from internal guides. This builds trust without altering core data. Phase two introduces assisted writing, where the copilot drafts activity notes or customer correspondence based on adjuster direction, requiring a human review and approval step before posting to the claim file. The final phase enables prescriptive guidance, where the copilot suggests next-best-actions (e.g., 'schedule an inspection' or 'request a police report') based on claim analysis, but always as a recommendation that requires an adjuster's explicit approval to execute.

Governance is managed through a centralized prompt management layer that sits between Duck Creek and the LLM. This layer injects company-specific guidelines, compliance rules, and claim handling procedures into every copilot interaction, ensuring all generated advice is grounded in your organization's standards. Performance and safety are monitored via a dedicated dashboard tracking metrics like tool call accuracy, user acceptance rates of suggestions, and manual override frequency. This allows for continuous refinement of the copilot's instructions and a clear off-ramp to human-only workflows if any anomaly is detected, ensuring the integration enhances—never disrupts—your core claims operations.

IMPLEMENTATION GUIDE

Frequently Asked Questions

Practical questions for technical teams planning to build and deploy a custom AI copilot within the Duck Creek platform.

A secure integration typically uses a middleware layer (an integration service) deployed in your cloud environment. This service acts as a bridge:

  1. Authentication: The service authenticates to Duck Creek using OAuth 2.0 client credentials, scoped to the specific APIs needed (e.g., Policy, Claim, Contact APIs).
  2. Data Retrieval: When a copilot request is made (e.g., from a custom UI component), the service calls Duck Creek APIs to fetch the relevant policy, claim, or contact context.
  3. AI Orchestration: The service formats this context into a prompt, calls your chosen AI model (e.g., via Azure OpenAI, AWS Bedrock), and applies any necessary grounding from your internal knowledge base.
  4. Audit & Logging: All requests and responses are logged with user IDs, timestamps, and the specific Duck Creek records accessed for full auditability.

Key Security Pattern: The AI service never has direct, persistent access to Duck Creek. It operates with a least-privilege service account, and all data in transit is encrypted. User context (the adjuster's permissions) is enforced by your middleware, which only requests data the user is authorized to see.

Prasad Kumkar

About the author

Prasad Kumkar

CEO & MD, Inference Systems

Prasad Kumkar is the CEO & MD of Inference Systems and writes about AI systems architecture, LLM infrastructure, model serving, evaluation, and production deployment. Over 5+ years, he has worked across computer vision models, L5 autonomous vehicle systems, and LLM research, with a focus on taking complex AI ideas into real-world engineering systems.

His work and writing cover AI systems, large language models, AI agents, multimodal systems, autonomous systems, inference optimization, RAG, evaluation, and production AI engineering.