AI Agent

A single AI that can use tools to complete a specific task.

• Follows a defined workflow
• Uses tools (search, calculate, API calls)
• Completes one task at a time
• Human defines the steps

Example: A chatbot that looks up policy details and answers policyholder questions

Agentic AI System

Multiple AI agents working together autonomously to achieve a goal.

• Plans its own approach
• Breaks complex goals into subtasks
• Coordinates multiple agents
• Reflects and adjusts strategy

Example: A system that receives a claim, extracts medical data, validates against policy benefits, checks for fraud signals, and routes for approval — all autonomously

1. Goals

What the system is trying to achieve. Clear goals = better outcomes.

2. Memory

Short-term (current task context) and long-term (learned patterns across sessions).

3. Tools

External capabilities: query databases, call APIs, read files, send alerts.

4. Reasoning

Chain-of-Thought prompting is the foundation — now automated.

5. Planning

Breaking a complex goal into ordered subtasks. "First extract, then validate, then route."

6. Reflection

Self-checking: "Did my output meet the goal? Should I try a different approach?"

Traditional Automation

• Rigid if/then rules
• Breaks when inputs vary
• Can't handle ambiguity
• Expensive to maintain

Agentic Automation

• Understands context and intent
• Adapts to variations in input
• Handles ambiguity with reasoning
• Improves with better prompts

Strengths

• Easy to understand and debug
• Each step can be tested independently
• Preserves context across steps
• Supports rollback and retry

Best for

• Claims processing pipelines
• Underwriting assessment workflows
• Policy issuance processes
• Data extraction → validation → output

Strengths

• 3x faster than sequential
• Multiple perspectives on same data
• Each branch is independent
• Aggregator resolves conflicts

Best for

• Underwriting assessment
• Due diligence (Medical + Financial + AML)
• Multi-perspective claims review
• Voting / consensus decisions

Strengths

• Handles diverse input types automatically
• Each path optimized for its type
• Can chain with secondary routers
• Scales to many categories

Best for

• Claims classification & processing
• Document type routing
• Policy servicing request triage
• Regulatory filing by jurisdiction

Strengths

• Handles complex conditional workflows
• Spawns subtasks dynamically
• Human-in-the-loop at decision gates
• Adapts to unexpected situations

Best for

• Credit facility approvals
• Insurance claims adjudication
• Complex compliance workflows
• Conditional branching + human oversight

Steering (Global Rules)

Always-on instructions for every interaction:

• Currency defaults (SGD unless specified)
• PII handling rules (never expose NRIC or policy numbers)
• Insurance terminology and brand voice
• Compliance requirements (MAS, PDPA)

File: .kiro/steering/rules.md

Skills (On-Demand Expertise)

Specialized instructions for specific tasks:

• Claims triage and adjudication
• Underwriting risk assessment
• Fraud investigation playbook
• Policy servicing automation

File: .kiro/skills/[name]/SKILL.md

Hooks (Auto-Triggers)

Events that automatically run your skills:

• File created: New claim submitted → run triage skill
• File edited: Policy updated → re-validate compliance
• Manual trigger: User clicks → generate report
• Scheduled: Daily compliance scan

MCP (Connections)

How AI connects to your real systems:

• Databases: Query policy data, claims history, underwriting records
• APIs: Call risk scoring engine, AML screening, medical bureau
• Files: Process claim documents, read policy wordings
• Messaging: Send Slack alerts, email notifications

Without MCP

• Export CSV → paste into chat → AI analyzes what you gave it
• Open 50 invoices one by one
• Check compliance in 3 systems manually
• Copy transaction data, format it, paste it

With MCP

• AI queries your merchant database directly
• AI scans the invoice folder automatically
• AI checks all 3 systems in one request
• AI runs SQL query, gets exactly what it needs

3 Core Primitives

• Tools — Actions AI can perform: run SQL, call API, send message
• Resources — Data AI can read: file contents, database schemas
• Prompts — Reusable templates for common interactions

Key Properties

• Open standard — works with Claude, Kiro, Cursor, VS Code
• Local or remote — runs on your machine or on a server
• Pre-built servers — community has built servers for most systems

// .kiro/settings/mcp.json
{
  "mcpServers": {
    "anycompany-db": {
      "command": "uvx",
      "args": ["mcp-server-sqlite",
               "--db-path", "./claims.db"],
      "autoApprove": ["read_query",
                       "list_tables"]
    }
  }
}

What happens: Kiro launches the server, discovers tools, and you can query the claims database in plain English.

Key Takeaway: MCP

• MCP = USB-C for AI (one standard, any connection)
• 3 primitives: Tools, Resources, Prompts
• Pre-built servers for databases, files, APIs, messaging
• You specify needs → tech team configures servers
• Try the interactive MCP explainer on the workshop site

Built-in: Automatic

• Kiro decides when to delegate — no config needed
• Works in Autopilot mode
• You can also ask explicitly: "do X and Y in parallel"

Custom: You Create & Invoke

• Saved as .kiro/agents/name.md — like skills
• Has its own tools (can restrict to read-only)
• Version in git, share with team
• Invoke: "use the [name] agent to review this file"

The Agent Design Canvas

• Agent Role: What does this agent do?
• Workflow Steps: What's the sequence?
• Pattern: Chain / Parallel / Route / Orchestrate?
• Data Inputs: What data does it need?
• Data Outputs: What does it produce?

• Tools/MCP: What systems does it connect to?
• Guardrails: What must it NOT do?
• Escalation Rules: When does a human step in?
• Autonomy Level: L1 / L2 / L3?
• Business Impact: Time saved, errors reduced?

Step 1: Identify (10 min)

• What manual process takes the most time?
• Where do errors happen most often?
• What's repetitive but requires judgment?

Step 2: Map (15 min)

• Draw the current process (boxes and arrows)
• Label each step with a workflow pattern
• Mark decision points and exception paths

Step 3: Assess (10 min)

• Feasibility: Can current AI do this?
• Impact: How much time/cost saved?
• Risk: What if the AI gets it wrong?

Step 4: Present (5 min each)

• Share your Agent Design Canvas
• Get feedback and suggestions
• Identify quick wins vs long-term projects