Automating Insurance Claims Processing with AI and Conductor
One of the biggest bottlenecks for the insurance industry is the sheer number of claims to process. The manual approach is expensive and time-consuming, requiring human operations to verify the documents, cross-check against the insurance policy, and follow up with the claimant, before the claim can be approved.
These process inefficiencies translate to a poor claims experience for customers, leading to dissatisfaction and ultimately driving customers to switch insurers. What if there were a way to effectively automate all that work so that claims processing can be completed in mere days or hours, reducing customer churn?
In this guide, we will explore how to wield LLMs (large language models) and orchestration to streamline manual business processes like insurance claims. Read on to learn the benefits, technical implementation details, and a demo example that you can try out in Orkes Conductor.
The solution: AI meets orchestration
The insurance industry is not new to automation. Rules-based automation approaches like RPA involved tons of pre-planning and data preparation, which meant that once the process was set in place, new changes could not be easily made. These early automation approaches were more rigid and limited, and could not easily scale to handle complex cases or exceptions.
Automating complexity
By leveraging the natural language capabilities of LLMs, the claims processing pipeline can be more effortlessly automated without having to predefine hundreds of rules across different policy wordings. Using prompt engineering, an LLM can act as an insurance representative to evaluate whether a claim can be approved. Here is an LLM-generated evaluation, which correctly identifies potential issues without any explicit business rules set:
The claim description mentions leukemia, which is a type of cancer. The doctor's report indicates tumors detected in blood, which is consistent with leukemia. However, the stage of cancer is not explicitly mentioned, and the policy covers only stage 3 and 4 cancer. The required documents (medical bill and doctor's report) are present, but the stage information is missing, which creates some uncertainty. The probability [of approval] is relatively high but not certain due to the lack of specific staging information.
Automating distributed systems
Reviewing the claim details is just one step in the insurance processing pipeline. This is where orchestration comes into play. Orkes Conductor is a fully-managed orchestration platform that coordinates disparate components and systems into an automated workflow or business process. Even if the supporting documents are uploaded on a system separate from customer details, or if the payment processing service resides on a different platform from the claims portal, an orchestration engine transforms these friction points into a well-oiled flow.
These are some key highlights of Orkes Conductor:
- Integration—Connect different services and data sources, including legacy systems, through a cloud-based middleware platform.
- Visibility—Track the status of your processes, easily recover from failures, and gain in-depth metrics on performance.
- AI capabilities—Use in-built features to natively add LLM-powered components to your processes.
Now, let’s walk through an example insurance claims flow built in Orkes Conductor.
Insurance claims processing flow
The claims processing flow can be distilled into three main steps:
- Data extraction from multiple sources—capture the claim details, supporting documents, and relevant policy documents.
- Claims assessment—review the data to determine if the claim meets the criteria for approval, using AI or human reviewers.
- Outcome processing—execute the approval decision, like kicking off a payments flow and notifying the claimant.
As the orchestrator unit, Orkes Conductor acts as the execution engine that drives all the core components of the insurance claims process.
1. Data extraction from multiple sources
With a suite of over 20 system tasks, Orkes Conductor supports retrieving data from many sources: through API endpoints, from data lakes, SQL databases, vector databases in a RAG system, and more. This enables you to automatically plug disparate data sources into business processes without any manual imports.
2. AI-powered claim assessment
The claim description mentions leukemia, which is a type of cancer. The doctor's report indicates tumors detected in blood, which is consistent with leukemia. However, the stage of cancer is not explicitly mentioned, and the policy covers only stage 3 and 4 cancer. The required documents (medical bill and doctor's report) are present, but the stage information is missing, which creates some uncertainty. The probability [of approval] is relatively high but not certain due to the lack of specific staging information.
As previously demonstrated, LLMs possess the capability to naturally parse text without requiring deep technical work. Leveraging prompt engineering, the LLM can be easily tuned to output accurate claim assessments. Even if the insurance policy changes, an LLM-powered solution will intelligently reason through any claims scenario. Here is a simplified prompt template that produced the claims assessment above:
You are an insurance claims assessor who needs to calculate the probability of approving a claim.
This is the policy statement: "${policy-statement}".
These are the supporting docs: "${docs}".
This is the claims description: "${claims-description}".
Orkes Conductor makes it easy to scale LLM-driven processes with its AI Prompt Studio and code-free AI/LLM integrations and tasks. With the Orkes’ AI Prompt Studio, you can securely craft and test reusable prompts for the claims assessment workflow. By replacing the prompt variables like ${policy-statement} with the required information extracted in step 1, the LLM can predictably handle complex or edge cases—combining the strengths of AI-powered flexibility with guardrails.
Orkes’ suite of LLM integrations provides access to the latest AI models from all major LLM providers, like OpenAI, Amazon Bedrock, and Anthropic. With all these choices at your fingertips, Orkes’ modular workflow approach makes it easy to test and switch between any AI model to find the most effective one for your use case — in this case, an insurance claims flow.
Bring all of these together by using Orkes’ built-in LLM tasks, which provides chat completions, embedding retrievals, and more without needing to add extra code.
Human-in-the-loop
Even with guardrails for AI models, adding human review checkpoints further mitigates the risks of AI miscalculation. After the AI-driven claims assessment is completed, the process can then trigger a human review for final approval of the insurance payout. The AI-generated assessment provides a detailed summary for the human assessor to investigate, speeding up the process.
In Orkes, our human-in-the-loop features allow you to seamlessly integrate these human touchpoints with both your backend process and your frontend claims review portal. This ensures an audit trail of all actions taken, while guaranteeing that businesses don’t have to migrate to different portal just to enjoy these benefits.
3. Business decision post-actions
Finally, once the decision has been made, the workflow can route either to an early termination in the case of rejection, or to a post-processing sequence like a payout initiation and outcome notification. Orkes’ orchestration engine facilitates coordination across different microservices, internal services, and other third-party integrations like Stripe and Sendgrid.
Integration with your tech stack
Integrate the workflow into your existing portal for claims processing. Run it as a server job. Trigger the claims process from an event-driven system. Whatever your system architecture requires, Orkes Conductor brings the flexibility to fit with your existing processes rather than force you to migrate.
Try it out in Conductor
Now, here’s how you can try out a working AI-powered insurance claims processing workflow for yourself in Conductor.
Prerequisites:
Create an account in our free Developer Playground.
Step 1: Create the insurance claim workflow
- Log in to Developer Playground.
- In Definitions > Workflow, select + Define workflow.
- Paste the following workflow JSON into the Code tab on the right-side panel:
{
"createTime": 1744263984129,
"updateTime": 1744871696379,
"name": "insurance-claim",
"description": "Insurance claim workflow",
"version": 1,
"tasks": [
{
"name": "collate-details",
"taskReferenceName": "collate-details_ref",
"inputParameters": {},
"type": "FORK_JOIN",
"decisionCases": {},
"defaultCase": [],
"forkTasks": [
[
{
"name": "get-customer-details",
"taskReferenceName": "get-customer-details_ref",
"inputParameters": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"connectionTimeOut": 3000,
"readTimeOut": "3000",
"accept": "application/json",
"contentType": "application/json"
},
"type": "HTTP"
},
{
"name": "get-claims-details",
"taskReferenceName": "get-claims-details_ref",
"inputParameters": {
"expression": "// Function to randomly pick an item from the array\n(function getRandomItem(arr) {\n const items = [\n { id: 1, name: \"Jane\", claims: \"stage 3 stomach cancer\" },\n { id: 2, name: \"Jen\", claims: \"stage 0 breast cancer\" },\n { id: 3, name: \"John\", claims: \"stage 4 leukemia\" },\n { id: 4, name: \"Jim\", claims: \"hyperthyroidism \" },\n { id: 4, name: \"Jeff\", claims: \"leukemia \" },\n { id: 4, name: \"June\", claims: \"stage 4 flu \" }\n ];\n\n const randomIndex = Math.floor(Math.random() * items.length);\n return items[randomIndex];\n}\n)();",
"evaluatorType": "graaljs"
},
"type": "INLINE"
}
],
[
{
"name": "get-policy-details",
"taskReferenceName": "get-policy-details_ref",
"inputParameters": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"connectionTimeOut": 3000,
"readTimeOut": "3000",
"accept": "application/json",
"contentType": "application/json"
},
"type": "HTTP"
},
{
"name": "get-coverage-statement",
"taskReferenceName": "get-coverage-statement_ref",
"inputParameters": {
"coverageStatement": "Critical illness cover of USD 200,000.00 for stage 3 and 4 cancer. To make a successful claim, the following documents are required: (1) medical bill and (2) doctor's report. If any documents are missing, the claim cannot be processed."
},
"type": "SET_VARIABLE"
}
],
[
{
"name": "get-supporting-docs",
"taskReferenceName": "get-supporting-docs_ref",
"inputParameters": {
"expression": "// Function to randomly pick an item from the array\n(function getRandomItem(arr) {\n const items = [\n { receipt: \"x-ray scan - USD 4000 consult USD 7000 total USD 11000\", report: \"Doctor Lee 15/03/25 Tumours detected in blood. Suspected stage 4 cancer. Patient is referred for further treatment.\" },\n { receipt: \"x-ray scan - USD 4000 consult USD 7000 total USD 11000\", report: \"Doctor Lee 15/03/25 Tumours detected in blood. Suspected stage 1 cancer. Patient is referred for further treatment.\" },\n { receipt: \"x-ray scan - USD 4000 consult USD 7000 total USD 11000\", report: \"Doctor Lee 15/03/25 Tumours detected in blood. Patient is referred for follow-up.\" },\n { receipt: \"\", report: \"\" }\n ];\n\n const randomIndex = Math.floor(Math.random() * items.length);\n return items[randomIndex];\n}\n)();",
"evaluatorType": "graaljs"
},
"type": "INLINE"
}
]
],
"startDelay": 0,
"joinOn": []
},
{
"name": "join_on_collate",
"taskReferenceName": "join_on_collate_ref",
"inputParameters": {},
"type": "JOIN",
"forkTasks": [],
"joinOn": [
"get-customer-details_ref",
"get-policy-details_ref"
],
"optional": false
},
{
"name": "get-approval-probability",
"taskReferenceName": "get-approval-probability_ref",
"inputParameters": {
"llmProvider": "AnthropicClaude",
"model": "claude-3-5-sonnet-20240620",
"promptName": "determine-insurance-claim-probability",
"promptVariables": {
"claims-description": "${get-claims-details_ref.output.result.claims}",
"policy-statement": "${workflow.variables.coverageStatement}",
"docs": "${get-supporting-docs_ref.output.result}"
}
},
"type": "LLM_TEXT_COMPLETE"
},
{
"name": "ai-decider",
"taskReferenceName": "ai-decider_ref",
"inputParameters": {
"probabilityValue": "${get-approval-probability_ref.output.result.probability}"
},
"type": "SWITCH",
"decisionCases": {
"0.0": [
{
"name": "send-refile-claim-notification",
"taskReferenceName": "send-refile-claim-notification_ref",
"inputParameters": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"accept": "application/json",
"contentType": "application/json",
"encode": true
},
"type": "HTTP"
},
{
"name": "terminate_2",
"taskReferenceName": "terminate_ref_2",
"inputParameters": {
"terminationStatus": "COMPLETED",
"terminationReason": "Claim did not pass LLM validation check. Need to refile for claims processing."
},
"type": "TERMINATE"
}
]
},
"defaultCase": [
{
"name": "approve-claim-payout",
"taskReferenceName": "approve-claim-payout_ref",
"inputParameters": {
"__humanTaskDefinition": {
"assignmentCompletionStrategy": "LEAVE_OPEN",
"displayName": "Approve Claim",
"userFormTemplate": {
"name": "InsuranceClaims",
"version": 1
},
"assignments": [
{
"assignee": {
"user": "ACME",
"userType": "EXTERNAL_GROUP"
},
"slaMinutes": 0
}
],
"taskTriggers": []
},
"claimDescription": "${get-claims-details_ref.output.result.claims}",
"coverageStatement": "${workflow.variables.coverageStatement}",
"probability": "${get-approval-probability_ref.output.result.probability}",
"aiSummary": "${get-approval-probability_ref.output.result.reason}",
"approval": false
},
"type": "HUMAN"
},
{
"name": "approved",
"taskReferenceName": "approved_ref",
"inputParameters": {
"approval": "${approve-claim-payout_ref.output.approval}"
},
"type": "SWITCH",
"decisionCases": {
"true": [
{
"name": "process-payment",
"taskReferenceName": "process-payment_ref",
"inputParameters": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"connectionTimeOut": 3000,
"readTimeOut": "3000",
"accept": "application/json",
"contentType": "application/json"
},
"type": "HTTP"
},
{
"name": "send-success-notification",
"taskReferenceName": "send-success-notification_ref",
"inputParameters": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"connectionTimeOut": 3000,
"readTimeOut": "3000",
"accept": "application/json",
"contentType": "application/json"
},
"type": "HTTP"
}
]
},
"defaultCase": [
{
"name": "send-not-approved-notification",
"taskReferenceName": "send-not-approved-notification_ref",
"inputParameters": {
"uri": "https://orkes-api-tester.orkesconductor.com/api",
"method": "GET",
"connectionTimeOut": 3000,
"readTimeOut": "3000",
"accept": "application/json",
"contentType": "application/json"
},
"type": "HTTP"
},
{
"name": "terminate_1",
"taskReferenceName": "terminate_ref_1",
"inputParameters": {
"terminationStatus": "COMPLETED",
"terminationReason": "Claim has not been approved by human agent."
},
"type": "TERMINATE"
}
],
"evaluatorType": "value-param",
"expression": "approval"
}
],
"evaluatorType": "value-param",
"expression": "probabilityValue"
}
],
"inputParameters": [
"policyNumber",
"customerId",
"supportingDocs"
],
"outputParameters": {},
"failureWorkflow": "",
"schemaVersion": 2,
"restartable": true,
"timeoutPolicy": "ALERT_ONLY",
"timeoutSeconds": 0,
"variables": {},
"inputTemplate": {},
"enforceSchema": true
}
- Save the workflow.
Step 2: Add LLM integrations and models
-
Go to Integrations and select + New integration.
-
In the AI/LLM section, add your desired LLM provider.
Note: In the workflow that you’ve just created, the
get-approval-probabilitytask makes use of Anthropic Claude’s Sonnet 3.5, but you can choose any LLM provider and simply modify the workflow task later. -
Return to Integrations and add your LLM models to your newly-added integration.
For detailed steps on adding LLM integrations, refer to the documentation.
Step 3: Add the AI prompt
-
Go to Definitions > AI Prompts and select + Add AI prompt.
-
In the Code tab, paste the following JSON:
{ "createTime": 1744715996941, "updateTime": 1744906103023, "name": "determine-insurance-claim-probability", "template": "You are an insurance claims assessor who needs to calculate the probability of approving a claim.\n\nThis is the policy statement: \"${policy-statement}\".\n\nThese are the supporting docs: \"${docs}\".\n\nThis is the claims description: \"${claims-description}\".\n\nFormat your response ONLY as a JSON object with the following structure:\n<valid>\n{\n \"probability\": \"A numerical probability between 0.0 - 1.0. \",\n \"reason\": \"A reason for the probability.\"\n}\n</valid>\n\nDo not wrap the JSON object in markdown. Do use quotation marks in the JSON object.\n<invalid>\n{probability=0.0, reason=The claim description mentions 'stage 5 cancer', which does not match the policy coverage for stage 3 and 4 cancer. Additionally, the provided documents confirm stage 3 cancer, further disqualifying the claim from approval.}\n</invalid>\n\n<invalid>\n```json\n{\n \"probability\": 0.0,\n \"reason\": \"The claim description mentions 'stage 5 cancer', which does not match the policy coverage for stage 3 and 4 cancer. Additionally, the provided documents confirm stage 3 cancer, further disqualifying the claim from approval.\"\n}\n```\n</invalid>", "description": "Determine the probability of approving a claim based on a policy statement and a claim description", "variables": [ "docs", "claims-description", "policy-statement" ], "integrations": [], "tags": [] } -
Return to the Form tab, and add any AI models you wish to use with this prompt.
Note: In the workflow that you’ve just created, the
get-approval-probabilitytask makes use of Anthropic Claude’s Sonnet 3.5, but you can add any LLM provider here and simply modify the workflow task later. -
Save the AI prompt.
Optional: Modify the AI prompt
The prompt should look something like this:
You are an insurance claims assessor who needs to calculate the probability of approving a claim.
This is the policy statement: "${policy-statement}".
These are the supporting docs: "${docs}".
This is the claims description: "${claims-description}".
Format your response ONLY as a JSON object with the following structure:
<valid>
{
"probability": "A numerical probability between 0.0 - 1.0. ",
"reason": "A reason for the probability."
}
</valid>
Do not wrap the JSON object in markdown. Do use quotation marks in the JSON object.
<invalid>
{probability=0.0, reason=The claim description mentions 'stage 5 cancer', which does not match the policy coverage for stage 3 and 4 cancer. Additionally, the provided documents confirm stage 3 cancer, further disqualifying the claim from approval.}
</invalid>
<invalid>
/```json
{
"probability": 0.0,
"reason": "The claim description mentions 'stage 5 cancer', which does not match the policy coverage for stage 3 and 4 cancer. Additionally, the provided documents confirm stage 3 cancer, further disqualifying the claim from approval."
}
/```
</invalid>
To modify the prompt, here are some guidelines to steer the LLM to respond with a well-structured JSON output:
- Unambiguously establish the role of the LLM as an insurance claims assessor.
- Precisely describe the expected input and output formats.
- Make sure the output has the exact fields expected by the subsequent tasks in the workflow.
- Provide clear examples of the output.
- Emphasize fairness and adherence to the provided policies.
- Make sure that missing inputs are properly handled.
Optional: Modify the workflow
If you wish to use other LLM providers than Anthropic Claude, make sure to modify the get-approval-probability task.
- Return to your insurance claim workflow and select the get-approval-probability task in the visual diagram.
- In the Task tab, modify the LLM provider and Model fields.
- Save the workflow.
Step 4: Add the user form for the Human task
The user form serves as the interface for human assessors to evaluate and approve the payout. Orkes Conductor makes it easy to integrate and deploy these user forms on your own user portals through our extensive suite of APIs and SDKs.
- Go to Definitions > User Forms and select + New form.
- In the Code tab, paste the following JSON:
{ "createTime": 1744816361848, "updateTime": 1744816643214, "name": "InsuranceClaims", "version": 1, "jsonSchema": { "$schema": "http://json-schema.org/draft-07/schema", "properties": { "claimDescription": { "type": "string" }, "coverageStatement": { "type": "string" }, "probability": { "type": "string" }, "aiSummary": { "type": "string" }, "approval": { "type": "boolean" } } }, "templateUI": { "type": "VerticalLayout", "elements": [ { "type": "Control", "scope": "#/properties/claimDescription", "label": "Claim Description", "options": { "readonly": true } }, { "type": "Control", "scope": "#/properties/coverageStatement", "label": "Coverage Statement", "options": { "readonly": true } }, { "type": "Control", "scope": "#/properties/probability", "label": "Probability", "options": { "readonly": true } }, { "type": "Control", "scope": "#/properties/aiSummary", "label": "AI Summary", "options": { "readonly": true } }, { "type": "Control", "scope": "#/properties/approval", "label": "Approve?", "options": { "default": false } } ] } } - Save the user form.
Running the workflow
Now that all your Conductor resources are ready, let’s run the workflow to experience the power of AI in automating claims processing.
To run the workflow:
- In Definitions > Workflow, select your insurance claim workflow.
- Select the Run tab in the right-side panel and select Run Workflow.
Upon running the workflow, you will be redirected to the workflow execution details page. Use the visual diagram to follow the workflow progression.
Intelligent automation in action
In the workflow execution details page, select the get-approval-probability task and then its Output tab. The LLM will provide an approval probability along with its reasoning.
In this instance, the probability of approval is 0, since the required supporting documents are missing. With workflow orchestration, the process then automatically progresses to notify the claimant to supplement the missing documents without needing additional human review.
Let’s trigger another execution to examine how a different scenario might play out.
In this instance, the probability is non-zero since all the supporting documents are present. However, the supporting evidence is a little vague and may require further follow-up. This is where the workflow benefits greatly from human oversight. Since there is a chance for approval, the workflow routes to a human-in-the-loop task, where a human assessor can review the AI-generated assessment summary to make the final decision.
Try it out yourself by going to Executions > Human Tasks and selecting the pending execution. You can claim the task, check the approve button to approve it (or leave it unchecked to reject it), and complete the task.
When you return to the workflow executions details page (in Executions > Workflow), the workflow will have progressed to the next steps depending on your choice. This is the power of Orkes Conductor, combining both orchestration and AI capabilities to build automated processes that scale.
Extending the workflow
While the data extraction, payment processing, and notification steps are mock tasks, they can be easily replaced with real data sources and services. Go a step further by switching out the mock tasks with real tasks for your own needs, or request a demo for Orkes Conductor to learn more about how orchestration can accelerate your business processes.
Summary
Slow, outdated insurance claims processes can be modernized by investing in the latest technology for AI and orchestration. Using Orkes Conductor to scale AI-automated processes offers a multitude of benefits:
- AI automation and agility—Easily add and upgrade AI-driven components to your processes for intelligent automation.
- Integration with existing systems—Use Orkes as the middleware platform to integrate legacy systems, third-party applications, and other components in your business ecosystem.
- Enhanced governance and monitoring—Built-in monitoring and state tracking dashboards to get global visibility and auditability into processes and performance.
- Human-in-the-loop oversight—Seamlessly add human oversight to processes and integrate them with frontend interfaces for your intended users.
- Fast, scalable performance—Build and run processes on a performant orchestration engine that powers the biggest players across industries, like Netflix, Tesla, and American Express.
More AI-powered use cases
- Building production-ready GenAI applications with Conductor and Amazon Bedrock
- Agentic coding interview
- Article summarizer
- AI-powered document classification system
- Retrieval augmented generation (RAG) system
- Multilingual translation with LLMs
—
Conductor is an enterprise-grade Unified Application Platform for process automation, API and microservices orchestration, agentic workflows, and more. Check out the full set of features, or try it yourself using our free Developer Playground.
