🛠️ Lab 2: Build a Claims Triage Skill

Build an AI agent that reads insurance claim documents, classifies them, and routes to the right processing track — all triggered automatically when a PDF lands in a folder.

⏱ 45 minutes

Exercise Overview

In this exercise, you'll build a working claims triage agent using the Kiro automation stack. The agent reads claim PDFs, extracts key information, classifies the claim type and complexity, and routes it to the appropriate processing track — straight-through for simple claims, or human adjuster queue for complex ones.

📦 Download starter files first

This lab uses real PDF claim documents. Download and extract the starter pack into your workspace:
  1. Download: lab2-claims-triage.zip
  2. Extract into your Kiro workspace root (you should see a lab2-claims-triage/ folder)
  3. Install the PDF converter dependency — paste this into Kiro chat:
    PROMPT — Copy & paste into Kiro
    Set up Python for the PDF converter. Run these commands in order: 1. sudo apt install -y python3-pip python3.12-venv 2. python3 -m venv .venv 3. .venv/bin/pip install -r lab2-claims-triage/requirements.txt
💡 What you'll build

A three-layer automation stack for claims triage:
  • Steering — Global rules for AnyCompany Insurance (you'll create this first)
  • Skill — Claims triage expertise that activates on demand
  • Hook — Auto-triggers when a claim PDF arrives in the intake folder
  • Routing — Classifies and routes claims to different processing paths
📁 File structure

.kiro/steering/anycompany-insurance-rules.mdGlobal rules (Step 1)
.kiro/skills/claims-triage/SKILL.mdClaims triage skill (Step 2)
.kiro/hooks/claims-intake.jsonPDF trigger hook (Step 3)
lab2-claims-triage/Starter pack — claim PDFs + converter script
lab2-claims-triage/extracted/Converted markdown files (generated by script)
📄 What's in the starter pack

claim-simple-001.pdfSimple outpatient claim — SGD $380
claim-standard-002.pdfStandard hospitalization — SGD $18,500
claim-complex-003.pdfComplex CI claim with fraud indicators — SGD $250,000
pdf_to_md.pyPDF → Markdown converter script
requirements.txtPython dependencies (pymupdf)
StepWhat you doDuration
Step 1Create a steering file — global rules for every agent interaction5 min
Step 2Build the Claims Triage SKILL.md10 min
Step 3Create a hook — one-click trigger for claims triage7 min
Step 4Verify triage results & iterate on the skill10 min
Step 5Add routing — classify & route to different paths13 min

Step 1: Create the Steering File

Steering files are always-on rules that apply to every conversation in your project. Think of them as the "company policy" that every AI agent must follow — regardless of what task it's doing.

💡 Why this matters for insurance: In claims processing, you need consistent rules across every interaction — correct currency, no personal data leakage, proper risk classifications, and regulatory compliance. Steering files enforce these rules automatically so individual skills don't need to repeat them.

Let's create the steering file by prompting Kiro. Copy the prompt below and paste it into Kiro chat — Kiro will create the file for you:

PROMPT — Copy & paste into Kiro
Create the steering file at .kiro/steering/anycompany-insurance-rules.md with the following content. Use inclusion: always in the frontmatter. # AnyCompany Insurance — Global Rules ## Company Context - Company name: AnyCompany Insurance - Primary market: Singapore - Regulator: MAS (Monetary Authority of Singapore) - Currency: SGD (Singapore Dollars) unless a specific market is referenced ## Data Protection - Never include personally identifiable information (PII) in outputs - Use [REDACTED] for names, NRIC, policy numbers, and contact details - Comply with PDPA (Personal Data Protection Act) requirements - Medical information requires additional sensitivity handling ## Risk & Decision Framework - All risk ratings must use: 🟢 LOW / 🟡 MEDIUM / 🔴 HIGH - All claim decisions must use: APPROVE / REFER / ESCALATE / DECLINE - Every decision must include a rationale citing specific data points - If data is missing or unavailable, state "DATA NOT AVAILABLE" — never estimate ## Claims Processing Rules - Claims authority limit for auto-approval: SGD $5,000 - Claims above SGD $50,000: mandatory human review - Pre-existing condition disputes: always escalate to senior adjuster - Fraud indicators: always flag, never auto-approve - MAS Notice on Claims Handling (MAS 120): response within 3 business days ## Guardrails - Only use data provided in the claim document — do not infer or assume - Cite the specific field or document section for every finding - When uncertain, escalate rather than decide - Never override policy exclusions without human authorization
✅ Checkpoint: After Kiro creates the file, verify it at .kiro/steering/anycompany-insurance-rules.md. Notice how it:
  • Sets the company context (currency, regulator, market)
  • Enforces data protection (PDPA, no PII)
  • Defines the decision vocabulary (APPROVE/REFER/ESCALATE/DECLINE)
  • Sets authority limits ($5K auto-approve, $50K mandatory review)
  • Establishes guardrails (cite data, escalate when uncertain)

These rules apply to every skill and conversation in this project — the claims triage skill you build next will inherit all of them automatically.

⚠️ Token cost awareness: This steering file is sent with every single message to Kiro. That's why it's concise (~200 words). A 2,000-word steering file would waste tokens on every interaction. Keep always files to essential rules only.

1b. Test the steering is active

Let's verify the steering file is working. Open a new chat session in Kiro (click the + icon in the chat panel) and paste this prompt — it's designed to trigger several steering rules at once:

PROMPT — Test steering rules (new chat session)
A customer named John Tan (NRIC S9812345A) submitted a health claim for $3,200. His policy number is ACI-HEALTH-2024-77210. The diagnosis is unclear — could be a pre-existing condition. What should we do with this claim?
✅ What to look for in Kiro's response:
  • PII redacted? — Kiro should NOT repeat "John Tan" or "S9812345A" in its output. It should use [REDACTED] or refer to "the claimant"
  • Currency correct? — Should reference SGD, not USD or generic "$"
  • Decision vocabulary used? — Should use APPROVE / REFER / ESCALATE / DECLINE (not "accept" or "reject")
  • Pre-existing condition rule applied? — Should recommend ESCALATE (steering says "always escalate to senior adjuster")
  • Guardrail respected? — Should say it needs more data rather than guessing the diagnosis

If Kiro follows these rules without you mentioning them, the steering is working. These rules are being injected into every conversation automatically.

💡 What if it doesn't work? Check that the frontmatter says inclusion: always (not manual). Also verify the file is in .kiro/steering/ — not .kiro/skills/. Steering files must be in the steering folder to be auto-included.

Step 2: Build the Claims Triage SKILL.md

Now let's build the core skill — a Claims Triage Agent that reads claim documents, extracts key data, classifies the claim, and recommends a processing track.

📝 Why SKILL.md?

A SKILL.md file is reusable expertise that Kiro activates on demand. Unlike a one-off prompt, a skill:
  • Auto-activates when someone mentions the relevant task (e.g., "triage this claim")
  • Is shared across your team via version control
  • Has guardrails built in — so every run follows the same rules
  • Produces consistent output — same structure every time

Ask Kiro to create the claims triage skill:

PROMPT — Copy & paste into Kiro
Create a Kiro skill at .kiro/skills/claims-triage/SKILL.md Use this structure: --- name: claims-triage description: Triage incoming insurance claims by reading claim documents, extracting key data, classifying claim type and complexity, and recommending a processing track. Use when reviewing new claims, processing First Notice of Loss (FNOL), or assessing claim intake documents for AnyCompany Insurance. --- # Claims Triage Agent ## Role You are a Senior Claims Analyst at AnyCompany Insurance with 12 years of experience in life, health, and general insurance claims across the Singapore market. You specialize in rapid claim classification, coverage validation, and routing decisions. You are thorough, evidence-based, and always cite the specific data point behind each finding. You err on the side of caution — when in doubt, you escalate rather than auto-approve. ## When to Use - New claim document arrives (PDF or structured data) - First Notice of Loss (FNOL) processing - Claim intake triage and classification - Batch claim review and prioritization ## How to Read PDFs When a claim arrives as a PDF file, convert it to markdown first using the PDF converter script: ```bash .venv/bin/python lab2-claims-triage/pdf_to_md.py lab2-claims-triage lab2-claims-triage/extracted ``` Then read the extracted markdown file from `lab2-claims-triage/extracted/`. This gives you structured text with all claim fields clearly readable. ## Workflow 1. **Convert** — If the claim is a PDF, run the converter script above to extract text 2. **Extract** — Read the claim document and extract: policy number, claim type, date of loss, claimed amount, supporting documents listed 3. **Validate** — Check coverage: Is the policy active? Does the claim type match policy coverage? Are there exclusions? 4. **Classify** — Determine: claim type (Health/Life/Motor/Travel/Property), complexity (Simple/Standard/Complex), and risk indicators 5. **Decide** — Recommend processing track: APPROVE (auto-process), REFER (standard queue), ESCALATE (senior adjuster), or FLAG (fraud/investigation) ## Output Format For each claim, produce this structured output: ### 📋 Claim Triage Summary | Field | Value | |-------|-------| | Policy Number | [extracted from document] | | Claim Type | [Health / Life / Motor / Travel / Property] | | Date of Loss | [extracted] | | Claimed Amount | SGD [amount] | | Complexity | [Simple / Standard / Complex] | | Risk Level | [🟢 LOW / 🟡 MEDIUM / 🔴 HIGH] | ### 🔍 Coverage Validation - Policy status: [Active/Lapsed/Under review] - Coverage match: [Yes/No — explain] - Exclusions check: [None found / Potential exclusion: describe] - Deductible: SGD [amount] ### ⚡ Decision **Recommended Track:** [APPROVE / REFER / ESCALATE / FLAG] **Rationale:** [2-3 sentences citing specific data points from the claim document] **Next Steps:** 1. [First action required] 2. [Second action if applicable] 3. [Third action if applicable] ### 🚨 Flags (if any) - [List any fraud indicators, missing documents, or anomalies] ## Decision Rules - Claimed amount ≤ SGD $5,000 + Simple complexity + No flags → APPROVE - Claimed amount $5,001–$50,000 + Standard complexity → REFER - Claimed amount > SGD $50,000 → ESCALATE (mandatory) - Any fraud indicator present → FLAG - Pre-existing condition dispute → ESCALATE - Missing critical documents → REFER with "pending documents" note ## Guardrails - ONLY use data present in the claim document - Cite the specific field or section for every finding - State "DATA NOT AVAILABLE" for any missing information — never guess - Do NOT override policy exclusions - Do NOT auto-approve if ANY fraud indicator is present - Always include the rationale — no decision without explanation
✅ Checkpoint: You should now have a file at .kiro/skills/claims-triage/SKILL.md. Verify in the Kiro Skills panel (click the Kiro icon → Agent Skills) that it appears. Key things to check:
  • The frontmatter has name and description with trigger keywords
  • The Role section defines a specific persona (Senior Claims Analyst)
  • "How to Read PDFs" section tells the skill how to use the converter script
  • The Output Format is structured and consistent
  • Decision Rules encode the business logic (authority limits, escalation triggers)
  • Guardrails prevent the agent from guessing or overriding policy
💡 Skills can include tooling, not just prompts:

Notice the "How to Read PDFs" section — it tells the skill how to use a script as part of its workflow. This is what makes skills more powerful than one-off prompts: they package expertise and operational tooling together. The skill knows both what to do (triage logic) and how to do it (run the converter, read the output).
💡 Notice the layered guardrails:

The steering file says "Claims above $50K: mandatory human review." The skill says "Claimed amount > SGD $50,000 → ESCALATE (mandatory)." This is defense in depth — the same rule enforced at two layers. If someone modifies the skill, the steering file still catches it. If someone removes the steering file, the skill still has the rule.

Step 3: Create a Hook — One-Click Claims Triage

Now let's create a hook — a one-click button that triggers the claims triage skill. No need to type a prompt every time — just click the button and the agent processes the claims automatically.

📖 Real-world parallel: In production, you'd use a fileCreated hook connected to your document management system — claims arrive via email/app and the agent processes them with zero human involvement. For the workshop, we'll use a userTriggered hook (a manual button) so you can reliably trigger and observe the automation flow.

3a. Create the hook

Ask Kiro to create a manual trigger hook:

PROMPT — Copy & paste into Kiro
Create a hook called "Triage Next Claim" that I can trigger manually with a button click. It should use the "userTriggered" event type and when triggered, ask the agent to: "Use the claims-triage skill to process all PDF claims in lab2-claims-triage/ that don't already have a corresponding _triage.md file. Convert each PDF to markdown first, then triage it. Save each triage output with the '_triage.md' suffix."
✅ Checkpoint: After Kiro creates the hook:
  • Open the Agent Hooks panel in the Kiro sidebar (look for the hooks icon)
  • You should see a "Triage Next Claim" button
  • This is your one-click trigger — clicking it sends the prompt to the agent automatically
💡 Notice how simple the hook prompt is:

The hook just says "use the claims-triage skill." It doesn't spell out how to convert PDFs or what decision rules to apply — that's all encoded in the skill. This is the power of skills: the hook is a simple trigger, the skill is the expertise. Separation of concerns.

3b. Click the hook — watch it work

Click the "Triage Next Claim" button in the Agent Hooks panel and watch the agent:

  1. Run the PDF converter (from the skill's "How to Read PDFs" section)
  2. Read the extracted markdown for each claim
  3. Apply the triage logic and decision rules
  4. Save structured triage outputs as _triage.md files
✅ What should happen:
  • Triage output files appear in lab2-claims-triage/ (e.g., claim-simple-001_triage.md)
  • Each file has the structured format from the skill: summary table, coverage validation, decision, flags
  • The steering rules are applied: SGD currency, no PII, decision vocabulary (APPROVE/REFER/FLAG)
📖 Hook types — when to use which

userTriggeredManual button — click to run. Good for on-demand tasks. (what we're using)
fileCreatedAuto-fires when a file appears. Good for intake pipelines (claims, invoices, reports).
fileEditedAuto-fires when a file is saved. Good for lint-on-save, format-on-save.
promptSubmitFires before every message you send. Good for injecting reminders or checks.

In production, you'd swap userTriggered for fileCreated with a pattern like claims-intake/*.pdf — same skill, fully automated trigger.

Step 4: Verify Results & Iterate on the Skill

The hook in Step 3 already triaged the claims. Now let's review the outputs and refine the skill — this is the real-world workflow: build → test → see gaps → improve → test again.

4a. Verify the decisions

Open the triage output files in lab2-claims-triage/. Each claim was designed to test a different routing path:

✅ Expected results:
ClaimExpected DecisionWhy
claim-simple-001APPROVEAmount ($380) well under $5K limit, simple outpatient, panel clinic, no flags
claim-standard-002REFERAmount ($18,500) in $5K–$50K range, hospitalization, non-panel hospital, standard complexity
claim-complex-003FLAG or ESCALATEMultiple fraud indicators: short policy duration, overseas hospital, previous decline, high amount ($250K), non-smoker with lung cancer
💡 Open the PDFs side-by-side: Open the original PDF (e.g., claim-complex-003.pdf) in one panel and the triage output (claim-complex-003_triage.md) in another. Notice how the agent extracted specific data points from the PDF and cited them in its rationale. This is the "cite the specific field" guardrail in action.

4b. Iterate on the skill

If the decisions don't match expectations — especially if the complex claim wasn't flagged — update the skill. This is the real workflow: the QA team tests, finds gaps, and refines the decision rules.

PROMPT — If the complex claim wasn't flagged correctly
Update my claims-triage skill at .kiro/skills/claims-triage/SKILL.md Add these fraud indicators to the Decision Rules section. If ANY of these are present, the decision must be FLAG: Fraud Indicators (any one triggers FLAG): - Policy duration less than 12 months + high-value claim (>$50K) - Medical treatment at overseas facility when claimant is Singapore-resident - Previous policy declined or cancelled by another insurer - Inconsistency between declared health status and diagnosis (e.g., non-smoker with smoking-related illness) - Supporting documents from non-verifiable sources - Multiple claims within first policy year Keep everything else unchanged.

4c. Re-run and confirm

After updating the skill, clear the previous outputs and re-run:

PROMPT — Clear previous outputs
Delete all .md files in lab2-claims-triage/ and the extracted/ folder contents, but keep the PDFs and Python scripts.

Then click the "Triage Next Claim" hook button again. Verify the complex claim now gets FLAG.

💡 The iteration loop: Create → Test → See gaps → Update SKILL.md → Test again. This is exactly how your tech team develops production skills. The SKILL.md is a living document — it gets better with every iteration. In a real deployment, the QA team (3 people in this room!) would be the ones testing and refining these decision rules.

Step 5: Add Routing — Classify & Route to Different Paths

📖 Pattern: Routing (Agentic Workflow Pattern)

Routing is one of the four core agentic patterns. Instead of one agent doing everything, a router agent classifies the input and sends it to the appropriate specialist. Each specialist has its own expertise, rules, and output format.

Real-world analogy: When you call your insurer, the IVR system routes you — press 1 for claims, 2 for policy changes, 3 for billing. The router doesn't solve your problem; it sends you to the right specialist. Same concept, but the AI reads the claim and routes intelligently.

Right now, your claims triage skill does everything — classification AND decision. Let's split it into a proper routing architecture:

🔀 Routing Architecture Agentic Workflow Pattern
Claim PDF → hook triggers ROUTER AGENT claims-triage skill Classifies → decides path APPROVE Auto-process ≤ $5K · Simple · No flags REFER Standard queue $5K–$50K · Standard FLAG Fraud investigation Fraud indicator · > $50K Approval letter Adjuster + timeline Investigation package

5a. Create the Fraud Investigation Skill

When the router flags a claim for fraud, it needs a specialist. Create a second skill that does deep-dive fraud analysis:

PROMPT — Copy & paste into Kiro
Create a second Kiro skill at .kiro/skills/claims-fraud-investigation/SKILL.md --- name: claims-fraud-investigation description: Conduct detailed fraud investigation analysis on flagged insurance claims. Use when a claim has been flagged with fraud indicators during triage, or when the Special Investigations Unit (SIU) needs an evidence package for a suspicious claim at AnyCompany Insurance. --- # Claims Fraud Investigation Agent ## Role You are a Senior Fraud Investigator at AnyCompany Insurance's Special Investigations Unit (SIU) with 15 years of experience in insurance fraud detection across life, health, and general insurance in Singapore and Southeast Asia. You are methodical, evidence-focused, and build cases that can withstand legal scrutiny. You never accuse — you document patterns and recommend further investigation steps. ## When to Use - Claim flagged during triage with fraud indicators - Special Investigations Unit (SIU) case preparation - Pattern analysis across related claims - Pre-litigation evidence packaging ## Output Format ### 🚨 Fraud Investigation Summary | Field | Value | |-------|-------| | Claim Reference | [from triage] | | Investigation Priority | [URGENT / HIGH / STANDARD] | | Fraud Type Suspected | [Opportunistic / Organized / Staged / Exaggerated / Identity] | | Confidence Level | [Low / Medium / High] — based on number and strength of indicators | ### 📊 Indicator Analysis For each fraud indicator found, document: | # | Indicator | Evidence | Severity | Notes | |---|-----------|----------|----------|-------| | 1 | [indicator name] | [specific data point from claim] | [HIGH/MEDIUM/LOW] | [context] | ### 🔗 Pattern Analysis - Related claims or policies: [any connections found] - Timeline anomalies: [suspicious timing patterns] - Document concerns: [authenticity, consistency issues] - Behavioral indicators: [unusual claimant behavior patterns] ### 📋 Investigation Recommendation **Recommended Action:** [Full SIU investigation / Enhanced verification / Monitor only / Close — insufficient evidence] **Immediate Steps:** 1. [First priority action] 2. [Second action] 3. [Third action] **Evidence to Obtain:** - [What additional evidence is needed] - [Who to contact for verification] - [What records to request] ### ⚖️ Legal & Compliance Notes - Regulatory reporting required: [Yes/No — cite MAS requirement if yes] - Data privacy considerations: [PDPA implications for investigation] - Limitation period: [time constraints for action] ## Guardrails - NEVER state that fraud has occurred — only that indicators are present - Use language: "indicators suggest" / "pattern consistent with" / "warrants further investigation" - ONLY use data from the claim document and triage output - Do NOT recommend claim denial based solely on this analysis — that requires human SIU decision - Cite specific evidence for every indicator — no speculation - Flag PDPA considerations when recommending data requests

5b. Test the fraud skill in isolation

Before wiring it into the full pipeline, let's test the fraud investigation skill on its own to verify it produces the right output:

PROMPT — Copy & paste into Kiro
Read the triage output for the complex claim at lab2-claims-triage/claim-complex-003_triage.md This claim was flagged during triage. Now use the claims-fraud-investigation skill to conduct a detailed fraud analysis. Read the original claim document at lab2-claims-triage/extracted/claim-complex-003.md and the triage output, then produce a full fraud investigation summary. Save the output as lab2-claims-triage/claim-complex-003_investigation.md
✅ What to observe:
  • The fraud investigation skill uses different language than the triage skill — "indicators suggest" not "this is fraud"
  • It builds an evidence package — each indicator is documented with specific data points
  • It recommends next steps for humans — the agent doesn't decide guilt, it prepares the case
  • It flags PDPA considerations — because requesting medical records from overseas has privacy implications
  • The steering rules still apply — no PII, SGD currency, cite specific data

5c. Create the full routing hook

Now let's upgrade the hook to orchestrate the complete routing pipeline — triage all claims, and automatically route flagged claims to the fraud investigation skill:

PROMPT — Copy & paste into Kiro
Create a new hook called "Full Claims Pipeline" that I can trigger manually with a button click. It should use the "userTriggered" event type and when triggered, ask the agent to: "Run the full claims routing pipeline on all PDFs in lab2-claims-triage/: 1. Use the claims-triage skill to convert and triage each PDF that doesn't have a _triage.md file yet 2. For any claim that gets a FLAG decision, automatically use the claims-fraud-investigation skill to produce a detailed investigation report (save as _investigation.md) 3. For claims that get APPROVE, generate a brief approval confirmation (save as _approved.md) 4. For claims that get REFER, generate a referral note with queue assignment (save as _referral.md) 5. Save a final routing summary as lab2-claims-triage/routing-summary.md showing all claims, their decisions, and which path each took"
✅ Checkpoint: You should now have two hooks in the Agent Hooks panel:
  • "Triage Next Claim" — simple triage only (from Step 3)
  • "Full Claims Pipeline" — triage + routing + specialist processing (new)

5d. Run the full pipeline

First, clear any existing output files so the pipeline processes everything fresh:

PROMPT — Clear previous outputs
Delete all .md files in lab2-claims-triage/ (the _triage.md, _approved.md, _referral.md, _investigation.md, and routing-summary.md files) but keep the PDFs and Python scripts. Also delete the extracted/ folder contents.

Now click the "Full Claims Pipeline" hook button and watch the complete routing flow:

⚡ What the Full Pipeline Hook Orchestrates
STEP 1 claims-triage skill Convert PDFs → classify → decide route APPROVE → _approved.md REFER → _referral.md FLAG → triggers Step 2 STEP 2 claims-fraud-investigation Deep analysis → evidence package → _investigation.md 📊 routing-summary.md
✅ Expected output files:
ClaimDecisionOutput files
claim-simple-001APPROVE_triage.md + _approved.md
claim-standard-002REFER_triage.md + _referral.md
claim-complex-003FLAG_triage.md + _investigation.md

Plus a routing-summary.md with the complete overview.

🎉 What just happened — the Routing pattern in action

You built a multi-agent routing system:
ComponentRoleAnalogy
Steering fileGlobal rules (authority limits, PDPA, decision vocabulary)Company policy manual
Claims Triage skillRouter — classifies and decides the pathTriage nurse in A&E
Fraud Investigation skillSpecialist — deep analysis on flagged casesSIU investigator
HookTrigger — starts the process when a PDF arrivesMailroom sorting incoming post

The router doesn't do everything — it classifies and delegates. Simple claims get auto-approved. Standard claims go to the queue. Suspicious claims get a specialist investigation. Each path has its own expertise, rules, and output format. This is how production claims systems work — but instead of hard-coded rules, the AI reads and understands the claim.

What You've Built

🎉 Complete Claims Triage Agent Stack

  • A steering file with AnyCompany Insurance global rules (authority limits, PDPA, decision framework)
  • A Claims Triage SKILL.md that classifies claims and routes to the right track
  • A Fraud Investigation SKILL.md that produces evidence packages for flagged claims
  • A hook that auto-triggers when claim PDFs arrive in the intake folder
  • A working Routing pattern — classify → route → specialist processing
  • Layered guardrails at every level (steering + skill + decision rules)
🤔 "Why not just code this as rules?"

The decision thresholds (amount < $5K → APPROVE, > $50K → ESCALATE) could be coded as if/else logic. That's not why you need an agent. The agent is needed for everything before the decision:

TaskWhy AI Agent?Why not code?
Reading the claim documentFree-text fields, inconsistent formatting, medical terminologyRule engines need perfectly structured input
Connecting fraud signalsReasons across 5+ weak signals together to detect a patternCoding every combination is brittle; new patterns emerge constantly
Handling ambiguity"Could be pre-existing" — agent reasons about uncertaintyCode needs binary yes/no; can't handle "maybe"
Generating rationaleWrites 2-3 sentences citing specific evidence from the documentCode can say "ESCALATE" but can't explain why

The pattern: The PDF converter is code (deterministic). The threshold checks are rules (guardrails). But reading unstructured documents, detecting fraud patterns across multiple signals, reasoning about ambiguity, and explaining decisions with evidence — that's reasoning, and that's where the agent earns its keep. The decision rules don't replace the agent's reasoning — they constrain it.

🏢 How this connects to your role
If you're in...This exercise shows you...
Audit / QAHow agent decisions are transparent (rationale for every decision), auditable (structured output), and governed (authority limits, escalation rules). You'd review and refine the Decision Rules.
Portfolio / ProductHow faster claims processing improves customer experience and reduces loss ratios. The auto-approve path for simple claims means faster payouts = higher NPS.
Technology / PlatformsThe architecture pattern — steering + skills + hooks + routing. This is what your team would build and maintain. The hook connects to your document management system.
SecurityHow fraud detection is built in as a routing path, not an afterthought. The guardrails prevent data leakage (PDPA). The investigation skill uses careful language ("indicators suggest").
Operations / DistributionHow the 80% of simple claims get processed automatically, freeing your team to focus on the complex 20% that need human judgment.

SKILL.md Best Practices

PracticeWhy
Keep SKILL.md under 500 linesLonger files slow down activation and reduce output quality
One skill, one jobClaims triage ≠ fraud investigation — separate skills for separate expertise
Include decision rules explicitlyDon't rely on the AI to "figure out" thresholds — encode them
Define the output format preciselyConsistent structure = auditable, comparable outputs every time
Add guardrails IN the skillDefense in depth — don't rely only on steering
Use specific personas"Senior Claims Analyst, 12 years, Singapore market" beats "helpful assistant"
Iterate based on test resultsSkills are living documents — test, improve, test again
Version via gitTrack changes, roll back if quality drops after edits
← Lab 1: MCP Lab 3: Agent Canvas →

Agentic AI Foundation Workshop · Claims Triage Agent · Powered by AWS