Intelligent Insurance Claims Platform

AI-powered intelligent claims platform embedded where you work. Experience Glean's contextual agents integrated with AgentCore for intelligent processing, and state management—all hosted on AWS.

Comment

Inspiration

Insurance claims processing is broken. Endless forms, weeks of waiting, and manual routing waste everyone's time. We saw an opportunity to combine Glean's conversational AI with Amazon Bedrock AgentCore's autonomous agents to transform claims from a painful bureaucratic process into an intelligent, seamless experience.

What it does

An AI-native insurance claims platform with two intelligent portals:

Submitter Portal: Conversational claim filing through Glean chat or web forms. AI guides customers through a submission experience, extracts the relevant data from natural language/attachments, and intelligently routes claims to the optimal reviewer based on skills & workload metrics. While this occurs, a separate AgentCore agent does a data-driven review of the claim with additional context provided by Glean's enterprise knowledge graph.

Reviewer Dashboard: AI-powered analysis with review details, confidence scores (e.g., "94% confidence: Approve/Deny"), fraud detection indicators, and one-click approval/denial flows also powered by agents. Smart routing balances workload and expertise across reviewers.

The AI Agents:

  • Intake Agent (Strands SDK + AgentCore): Processes claims, validates policies, intelligently assigns to reviewers
  • Review Agent (Strands SDK + AgentCore): Analyzes claims using Amazon Nova, generates recommendations with transparent reasoning
  • Glean Conversational Agents: Two Glean Agents, one "Intake Agent", and another "Claims Insight & Management Agent" with natural language interface and enterprise context awareness.

How we built it

Multi-layered architecture

Frontend (Intelligent Insurance Claim Platform WebApps - Submitter & Reviewer Portals)
    ↓
Glean Claims Intake, Insights & Management Conversational Agents
    ↓
Glean Enterprise Knowledge Graph (Contextual Understanding & Knowledge Retrieval)
    ↓
Custom Glean Actions to AgentCore
    ↓
API Gateway + Lambda Functions (Orchestration Layer)
    ↓
Amazon Bedrock AgentCore Runtime
    ├── Intake Agent (Strands SDK)
    │   ├── Intelligent Claim Processing
    │   ├── Smart Reviewer Assignment (workload + expertise balancing)
    │   ├── Amazon Nova (LLM)
    │   └── Glean Enterprise Context
    └── Review Agent (Strands SDK)
        ├── Intelligent Claim Assessment
        ├── AI Recommendation Engine (confidence scoring)
        ├── Amazon Nova (LLM)
        └── Glean Enterprise Context
    ↓
┌──────────────────────────────────────────────────────────────┐
│  Data & State Layer                                          │
│  • DynamoDB (Claim Storage, State Management, & Audit Trail) │
│  • Glean Enterprise Context (Knowledge Retrieval)            │
│  • Amazon Bedrock (Model Inference - Amazon Nova)            │
└──────────────────────────────────────────────────────────────┘

Tech stack: Glean Agents, Glean Actions, Glean WebSDK, Amazon Bedrock AgentCore, AWS Strands Agents SDK, Amazon Nova Pro, AWS Lambda (Python 3.12), Amazon API Gateway, AWS Lambda, Amazon DynamoDB, AWS Secrets Manager, AWS CloudFormation.

Hosted version The hosted version includes all the above-mentioned services, but also includes AWS CloudFront, Amazon S3, Amazon Cognito, AWS Certificate Manager (ACM), and Amazon Route53 for hosting purposes.

One-command deployment: ./deploy.sh deploys the entire AWS system—7 Lambda functions, 2 AgentCore agents, API Gateway, DynamoDB, seeds sample data, and generates Glean-ready OpenAPI specs—in under 10 minutes. The Glean deployment steps requires Glean access, and provides what's needed to get those Agents & Actions deployed.

Challenges we ran into

1. Multi-Agent State Synchronization: Coordinating state between Glean agents, AgentCore runtime, and DynamoDB. Solved with stateless API design and session IDs passed through the entire chain.

2. Intelligent Reviewer Assignment: Balancing expertise, workload, and performance in real-time. Built a dynamic scoring algorithm that adjusts weights based on claim urgency and complexity.

3. Judges Without Glean Access: Judges may or may not have Glean accounts, so we built a bypass mode for direct AgentCore chat. However, the AgentCore agents were designed as backend orchestration engines, not customer-facing conversational agents. Their responses are more technical and less polished than Glean's conversational interface, which provides the ideal user experience with enterprise context awareness and beautiful embedded UI. That said, for completeness sake, we implemented this AgentCore direct functionality just in case.

Accomplishments that we're proud of

🏆 Seamless multi-agent integration across three frameworks (Glean, Strands SDK, AgentCore).

🎯 Close to Production-ready deployment with complete infrastructure-as-code, except for authentication implementation as this varies heavily between enterprises.

🤖 Intelligent automation with human oversight: AI handles 80% of work, humans make 100% of final decisions.

📊 Real-world applicability: Complete audit trail, fraud detection, workload balancing, scalable serverless architecture.

What we learned

Agent orchestration requires careful design of boundaries, communication patterns, and state management. Simple, stateless APIs between agents create the most robust systems.

Glean + AgentCore is powerful: Glean brings conversational agents, a world-class UI (WebSDK embedding, action calling with beautiful forms, etc), and enterprise knowledge; AgentCore brings the flexibility AWS is known for, autonomous decision-making, cross-service integration (Lambda, Dynamo, AgentCore Gateway, etc), and scalability. Together, they create powerful experiences.

Confidence scoring changes everything: Reviewers can prioritize low-confidence cases and fast-track high-confidence ones instead of blindly trusting or ignoring AI. But the reviewers stay in the drivers seat, with a full human-in-loop design.

What's next for Intelligent Insurance Claims Platform

Advanced Fraud Detection: Pattern recognition across historical claims and network analysis to detect organized fraud

Predictive Analytics: Claim volume forecasting, reviewer capacity planning, and cost prediction

Team Capacity Planning: Agents to accurately assess, and plan for hiring and time-off events to consistently lower case time-to-review (TTR).

Agentic Negotiation: AI agents that negotiate settlements within parameters with human approval for final agreements.

Continuous Learning: Feedback loop from reviewer decisions to be included in improvement of AI recommendations over time.

Built With

  • amazon-api-gateway
  • amazon-bedrock-agentcore
  • amazon-cognito
  • amazon-dynamodb
  • amazon-nova
  • amazon-nova-pro
  • amazon-route53
  • amazon-web-services
  • aws-certificate-manager-(acm)
  • aws-cloudformation
  • aws-cloudfront
  • aws-lambda-(python-3.12)
  • aws-secrets-manager
  • aws-strands-agents-sdk
  • glean-actions
  • glean-agents
  • glean-api
  • glean-websdk
  • html5
  • javascript
  • strands-agents-sdk
Share this project:

Updates