Build a multi-agent system that triages, reviews, and adjudicates insurance claims — using the same Agentic Loop, Routing, and Parallelization patterns from today's slides.
⏱ 35 minutes
What You'll Build
You'll run a multi-agent claims processing system where AI agents coordinate automatically to triage, review, and adjudicate 6 insurance claims — life, health, motor, and travel.
🧠 Workshop Concepts in Action
This lab brings together three patterns from the workshop:
The Agentic Loop — Observe (load claims) → Plan (triage them) → Act (review) → Reflect (adjudicate decisions)
Routing — A Triage Agent classifies each claim and sends it to the right processing path
Parallelization — Medical Reviewer and Fraud Analyst examine the same claim at the same time
The Multi-Agent Architecture
Step
What you do
Duration
Pattern
Step 1
Install Strands SDK & explore your first agent
8 min
Agentic Loop
Step 2
Build a Triage Agent that classifies claims
8 min
Routing
Step 3
Run parallel Medical + Fraud reviews
10 min
Parallelization
Step 4
Run the full pipeline — all patterns combined
9 min
All three
Setup: Download Lab Files
All the code and sample data are pre-built for you. You just need to download and install.
💡 Why pre-built code?
The goal here is to understand how multiple AI agents coordinate to process insurance claims. The code is ready so you can focus on observing the agent behaviors — how they triage, review, and adjudicate — not debugging Python.
▶ 🎓 "What prompt created this code?"
Here's the prompt that was used to generate agentic_claims_processor.py with Kiro. This is the kind of prompt you could write after completing this workshop:
THE PROMPT THAT BUILT THIS LAB
Build a multi-agent insurance claims processing system using the Strands Agents SDK with Amazon Bedrock.
The system should process 6 insurance claims (life, health, motor, travel) from JSON files in sample-data/claims/ and validate them against policy limits (CSV) and adjudication rules (JSON).
Create 4 agents:
1. TRIAGE AGENT — Classifies each claim by type, priority (high >$100K / standard / low <$5K), red flags (early claim, full sum claimed, missing docs), and routes to the right review path
2. MEDICAL REVIEWER — Validates diagnosis appropriateness, cost reasonableness against typical ranges, policy coverage, waiting periods, and pre-existing condition risk
3. FRAUD ANALYST — Checks policy age, claim-to-sum-assured ratio, known fraud indicators, documentation completeness, and timing patterns. Outputs a risk score.
4. ADJUDICATOR — Synthesizes medical + fraud reviews into final decisions: APPROVE ✅ / FLAG ⚠️ / DECLINE 🔴, ensuring MAS Fair Dealing Guidelines compliance
Each agent should have @tool-decorated functions for its capabilities. Run medical and fraud reviews in parallel using ThreadPoolExecutor. The pipeline should follow the Agentic Loop: OBSERVE (load claims) → PLAN (triage) → ACT (parallel reviews) → REFLECT (adjudicate decisions).
Use BedrockModel with us.anthropic.claude-sonnet-4-20250514-v1:0 in us-west-2. Save the final report as markdown.
All amounts in SGD. Use AnyCompany Insurance as the company name. Include Singapore regulatory context (MAS, PDPA).
The full picture: This prompt uses techniques from across the workshop — understanding what Bedrock models can do, structured prompting with personas, specific output formats, guardrails, and agentic patterns (routing, parallelization, the agentic loop).
💡 Why --break-system-packages? The Kiro server runs Ubuntu 24.04 which blocks system-wide pip installs by default. Since we're running commands manually in the terminal here, we need this flag. It's safe for our workshop environment.
Every agent follows: Observe (receive input) → Plan (decide what tools to use) → Act (call tools, generate output) → Reflect (check results, retry if needed). Watch for this loop in the terminal output.
Run the first script to see a simple agent in action:
KIRO PROMPT — Ask Kiro to run this
Run python3 lab4-agentic-claims/step1_explore_agents.py and show me the output
👀 What to watch for:
The agent decides on its own to call list_all_claims first — you didn't tell it to
It then reasons about the results to answer your questions
If it needs more detail, it might call read_claim for a specific claim — that's the Reflect → Act again loop
This is the same Observe → Plan → Act → Reflect cycle from the slides!
🔬 Explore: Ask your own questions
Open step1_explore_agents.py in Kiro. Change the question at the bottom of the file to something else:
IDEAS — Try changing the agent's question to:
• "What is the total value of all claims combined?"
• "Which claims are death claims or critical illness?"
• "Read claim CLM-2025-0003 and tell me if anything looks suspicious"
• "Which claims have policies less than 12 months old?"
✅ Checkpoint: You've seen an agent autonomously decide which tools to call, process the results, and answer your question. This is the Agentic Loop in action.
Step 2: The Triage Agent
📖 Pattern: Routing
A Triage Agent classifies each claim and sends it to the right processing path. Think of it as the claims intake desk — it reads each claim, assesses priority and risk, and routes it to the appropriate review team. This is the Routing pattern: classify → route → process.
Run the triage agent:
KIRO PROMPT
Run python3 lab4-agentic-claims/step2_triage_agent.py and show me the output
👀 What to watch for:
The Triage Agent checks each policy's status and age — it uses the check_policy_status tool multiple times
It applies adjudication rules (amount thresholds, early claim flags) to decide the route
CLM-2025-0003 (Death claim, $500K, 7-month policy) should be routed to enhanced review
CLM-2025-0005 (Back surgery, 5-month policy) should be flagged — early claim + pre-existing risk
CLM-2025-0004 (Motor, $4,200) might get auto-approved — low value, no red flags
🎓 Connection to Your Work
💡
This triage pattern applies to any classification task in insurance: routing customer service inquiries, classifying underwriting applications by risk tier, or prioritizing policy renewals. The agent reads the data, applies rules, and decides the path — no hardcoded if/else needed.
✅ Checkpoint: You've seen the Routing pattern — one agent classifying 6 claims into different processing paths based on business rules.
Step 3: Parallel Reviews
📖 Pattern: Parallelization
Two specialist agents review the same claim at the same time — a Medical Reviewer checks the diagnosis and costs, while a Fraud Analyst checks for suspicious patterns. Then an Adjudicator combines their findings into a single decision. This is like a claims committee meeting, but in seconds.
Run the parallel review on a suspicious claim (Roberto Santos — Death Claim, $500K, 7-month policy):
KIRO PROMPT
Run python3 lab4-agentic-claims/step3_parallel_review.py and show me the output
👀 What to watch for:
Both reviews start at the same time — you'll see "Starting parallel reviews..." then both complete
The Medical Reviewer validates the cause of death (Acute MI) and checks if it's medically consistent
The Fraud Analyst flags multiple red flags: policy only 7 months old, full sum assured claimed, death claim on young policy
The Adjudicator combines both views — it should recommend FLAG or require investigation given the fraud indicators, while noting MAS Fair Dealing obligations
Check the output file: output/parallel_review_report.md
🔬 Explore: Try a different claim
Open step3_parallel_review.py and change the TARGET_CLAIM variable to review a different claim:
✅ Checkpoint: You've seen Parallelization — two agents reviewing the same claim simultaneously, then an adjudicator synthesizing their findings. Check output/parallel_review_report.md for the full report.
Step 4: The Full Pipeline (All Patterns Combined)
🎯 Everything together
This script combines all three patterns into one pipeline:
OBSERVE — Load all 6 claims
PLAN (Routing) — Triage Agent classifies and routes each claim
ACT (Parallelization) — Medical + Fraud agents review each claim in parallel
REFLECT (Adjudication) — Adjudicator synthesizes all reviews into final decisions
Run the full pipeline:
KIRO PROMPT
Run python3 lab4-agentic-claims/agentic_claims_processor.py and show me the output
⏱ This takes 2-3 minutes — the system is making multiple calls to Amazon Bedrock for each agent. Watch the terminal output to see each step of the Agentic Loop in real time.
👀 What to watch for in the output:
OBSERVE — Lists all 6 claims with amounts and policy ages
PLAN — Triage classifies each claim (watch for different routes)
ACT — For each claim, medical + fraud reviews run in parallel
REFLECT — Adjudicator produces final decisions for all 6 claims
Report — Check output/claims_processing_report.md for the full report
Expected Results
Claim
Expected Decision
Why
CLM-2025-0001 (Tan Wei Ming)
APPROVE ✅
5-year policy, confirmed cancer diagnosis, amount within range
Death claim on 7-month policy, full sum claimed — investigate
CLM-2025-0004 (David Ng)
APPROVE ✅
Low-value motor claim, panel workshop, complete docs
CLM-2025-0005 (Priya Ramasamy)
FLAG ⚠️
5-month policy, possible pre-existing condition, high cost
CLM-2025-0006 (Jason Ong)
APPROVE ✅
Travel medical within covered period, reasonable cost
✅ Final Checkpoint: Open output/claims_processing_report.md and verify:
All 6 claims have decisions
The death claim (CLM-2025-0003) is flagged for investigation
The back surgery claim (CLM-2025-0005) is flagged for pre-existing condition review
There's an executive summary with totals, MAS compliance notes, and action items
Reflection: What Just Happened?
🧠 Compare: Manual vs Agentic approach
Manual Claims Process
Agentic (this lab)
Approach
Claims officer reviews one at a time
Agents coordinated automatically
Steps
Triage → medical review → fraud check → decision (sequential)
4 agents, routing + parallel execution
Human role
Human drives every step
You pressed "run" — agents did the rest
Scalability
~20 claims/day per officer
Works for 200 claims the same way
Consistency
Varies by officer experience
Same rules, same agents, every time
Compliance
Manual checklist
Built into agent prompts
The 4 Agents You Ran
Agent
Role
Tools it uses
Pattern
Triage Officer
Classify & route claims
read_claim, check_policy, check_documents
Routing
Medical Reviewer
Diagnosis, cost, coverage
read_claim, check_policy, validate_medical
Parallelization
Fraud Analyst
Risk scoring, indicators
read_claim, check_policy, check_fraud_indicators
Parallelization
Adjudicator
Synthesize & decide
save_report
Agentic Loop
💡
Key insight: Each agent has a clear role, specific tools, and focused instructions. This is the same principle as persona-based prompting — but now each persona is an independent agent that can be tested, improved, and reused separately. The Medical Reviewer doesn't know about fraud; the Fraud Analyst doesn't assess medical validity. Separation of concerns — just like good software design.
🎉 What You Accomplished
⚡ Ran a multi-agent claims processing system using Strands Agents SDK + Amazon Bedrock
🗺️ Saw Routing in action — one agent triaging claims into different paths
🔀 Saw Parallelization — two specialist agents reviewing the same claim simultaneously
🔄 Saw the Agentic Loop — agents autonomously deciding which tools to call and when
🎯 Saw Adjudication — a senior agent synthesizing multiple reviews into final decisions
📊 Generated a complete claims processing report with decisions for 6 claims
This is how agentic AI can transform claims operations — from days of manual review to minutes of automated, consistent, auditable processing.
🔗 Connection to Lab 3: Agent Design Canvas
This lab is the realized version of a claims processing canvas. Every section of the canvas maps to something in the code:
Agent Identity → Role became the system_prompt for each agent
Workflow → Pattern became Triage (Routing) + ThreadPoolExecutor (Parallelization)
Data → Inputs became @tool functions like read_claim()
Guardrails → Escalate when became fraud indicators and threshold checks
Open agent-design-canvas-claims.md in the lab folder to see the full canvas that produced this code.
⭐ Bonus: Customize the Agents
If you finish early, try these modifications. Ask Kiro to help you make changes:
IDEA 1 — Add a new specialist agent
Open lab4-agentic-claims/agentic_claims_processor.py and add a "Customer Experience" agent that drafts a personalized communication letter to each claimant explaining the decision, next steps, and timeline. Have it run after the adjudicator makes its decision.
IDEA 2 — Change the triage rules
Modify the Triage Agent's system prompt to add a new route: if a claim involves a hospital that is NOT on AnyCompany's panel list (only Mount Elizabeth, SGH, and Tan Tock Seng are panel hospitals), route it to an "Out-of-Panel Review" path that checks if the costs are reasonable compared to panel rates.
IDEA 3 — Add your own claim
Create a new claim_007.json in lab4-agentic-claims/sample-data/claims/ for a critical illness claim (Stage 1 breast cancer) on a policy that's 3 years old, sum assured $200,000. Make sure all documents are complete. Run the pipeline again and see how the agents handle it — it should be approved.