Workshop Summary — Agentic AI Foundation

🔗 Important Links & Access

🌐 Workshop Site (All Materials)

https://sing.lab.mywcloud.net

All slides, interactive explainers, exercises, labs, and reference materials. Bookmark this — it stays live after the workshop.

☁️ Lab Environment (AWS Workshop Studio)

https://catalog.us-east-1.prod.workshops.aws/join?access-code=8fcc-078729-21

Access Code: 8fcc-078729-21 · Sign in with your corporate email. Lab environment is available for the duration of the workshop event.

📽️ Presentation Slides

https://sing.lab.mywcloud.net/presentation/day3-slides.html

Full slide deck — Agentic AI Foundation. Navigate with arrow keys. Press S for speaker notes, F for fullscreen.

🤖 Agent Design Canvas Exercise

https://sing.lab.mywcloud.net/lab3-agent-canvas.html

Main exercise — design your agent workflow, submit for AI scoring, view the leaderboard.

🏢 AnyCompany Insurance Product Guide

https://sing.lab.mywcloud.net/anycompany-policies.html

Sample data — life, health, general insurance products, claims process, underwriting guidelines. Used in Lab 1 (MCP Fetch demo).

☁️ Amazon Bedrock DocsModels, agents, knowledge bases, guardrails 🐍 Strands Agents SDKOpen-source agent framework from AWS 🔌 MCP SpecificationOpen standard for AI-to-tool connections 🏗️ Kiro IDEAI-powered development environment

📋 What We Covered

Module	Topic	Key Takeaway
M0	Introduction	Workshop goals, environment setup, what agentic AI means for insurance
M1	From LLMs to Agents	Fallacy of composition — chatbots aren't agents. Agents need perception, reasoning, and action.
M2	Exploring Agentic AI	4 agent types: Workflow, Autonomous, Hybrid, Multi-Agent. 4 autonomy levels (L1→L4).
M3	Agentic Workflows ⭐	Chaining, Parallelization, Routing, Orchestration — the 4 patterns that power every agent workflow
M4	AWS Developer Tools	Bedrock Agents, AgentCore, Kiro IDE, MCP integration — the AWS AI landscape
M5	Frameworks	Strands Agents SDK, LangGraph, CrewAI — when to use which framework
M6	Custom Solutions	Production patterns, guardrails, evaluation, human-in-the-loop design
M7	Wrap Up	Key takeaways, organizational readiness, next steps for your team

🔄 The 4 Workflow Patterns

1. Prompt Chaining

Sequential steps where each output feeds the next. Trades speed for accuracy — each step is testable and debuggable independently.

AnyCompany example: Claim received → Extract data → Validate against policy → Check authority limits → Approve/Escalate → Generate decision letter

2. Parallelization

Multiple tasks run simultaneously, then results are aggregated. Faster than sequential and provides multiple perspectives.

AnyCompany example: Underwriting — Medical Assessor + Financial Assessor + Compliance Officer assess simultaneously → Unified risk classification

3. Routing

A classifier directs input to the right processing pipeline based on content type. Each path is optimized for its category.

AnyCompany example: New claim → Classify (health/motor/life/travel) → Route to appropriate specialist workflow

4. Orchestration

The most complex pattern — dynamically manages workflows, spawns subtasks based on conditions, and includes human-in-the-loop at configurable thresholds.

AnyCompany example: Claims adjudication — <$5K auto-approve, $5K-$50K AI+adjuster review, >$50K mandatory senior review. Spawns fraud investigation if indicators detected.

Key insight: Most real workflows combine 2-3 patterns. A life insurance underwriting application uses routing (classify risk tier) + parallelization (simultaneous medical/financial/compliance checks) + chaining (sequential decision synthesis). The Agent Design Canvas helps you map which patterns fit your workflow.

⚡ Key Concepts Reference

Agentic Loop

Observe → Plan → Act → Reflect — continuous cycle, not linear

Perception → Reasoning → Action

The 3 components that make an AI system "agentic"

Fallacy of Composition

What works for parts won't work for the whole — why chatbots aren't agents

Autonomy Levels (L1-L4)

L1: Copilot → L2: AI-enhanced → L3: Autonomous → L4: Fully autonomous

MCP (Model Context Protocol)

Standardized way to connect AI to databases, APIs, and tools

Human-in-the-Loop

Configurable thresholds where humans review AI decisions

Guardrails

Safety boundaries — what the agent must NOT do, when to escalate

Agent Design Canvas

Structured one-page document to hand to your tech team for implementation

🏗️ The Kiro Automation Stack

Layer	What It Does	Who Owns It
Steering	Global rules that apply to every AI interaction — compliance standards, formatting, authority limits	Team leads / policy owners
Skills	On-demand expertise that activates for specific tasks — reusable prompt templates with structured outputs	Domain experts
Hooks	Automated triggers — run actions when files change, on schedule, or on manual trigger (one-click pipelines)	Process owners
MCP	Data connections — connect AI to databases, APIs, and external tools via standardized protocol	Tech team

The key distinction: Skills = your domain knowledge (instructions you write). MCP = technical connections (your tech team sets up). You own the "what" and "how to assess." They own the "where the data lives."

🤖 Agent Design Canvas — Main Exercise

What You Designed

The Agent Design Canvas captures everything needed to build an AI agent for your workflow:

Canvas Section	What It Defines	Who Uses It
Agent Identity	Name, role (persona), trigger event	Everyone — sets the scope
Workflow	Pattern choice + step-by-step process	Tech team — architecture
Data	Inputs, outputs, knowledge base	Tech team — integrations
Guardrails	Must-NOT rules, escalation triggers, data rules	Risk/Compliance — governance
Kiro Implementation	Steering, skills, hooks, MCP connections	Tech team — build plan
Business Impact	Current process time, expected savings, success metrics	Leadership — ROI case

What to do with your canvas: Share it with your tech team. It's the specification document they need to start building. The more specific your guardrails and escalation rules, the faster they can implement safely.

🎯 Interactive Explainers (Self-Paced Reference)

These stay available after the workshop. Use them to refresh concepts or share with colleagues who weren't in the room.

🔄 Workflow PatternsAnimated walkthrough of all 4 patterns with insurance examples 🏗️ Kiro Automation StackSteering + Skills + Hooks + MCP interactive guide 🔌 MCP ExplainerHow AI connects to your systems — message flow demo 🤖 Agentic AI Use Cases9 validated insurance use cases with industry precedents ✂️ How AI Reads TextTokenizer playground — BPE in action 📊 Embeddings & Vector SpaceHow AI understands meaning — 3D explorer

🚀 Recommended Next Steps

What to Do This Week

Share your Agent Design Canvas with your tech team or manager. It's the starting point for any AI agent initiative — the "what to build" document.
Identify one workflow in your team that takes >30 minutes and happens weekly. That's your first agent candidate.
Review the use cases page (agentic-usecases.html) — find the use case closest to your team's work and use it as a reference when pitching internally.
Explore the interactive explainers — share the workflow patterns explainer with colleagues who weren't in the workshop.

What to Do This Month

Pilot one agent — start with a low-risk, high-frequency workflow (e.g., report generation, data extraction, document summarization)
Define guardrails first — before building, agree on what the agent must NOT do and when it must escalate to a human
Measure the baseline — document how long the current process takes so you can quantify the improvement
Connect with your Cloud COE — they can help set up Bedrock access, MCP connections, and the technical infrastructure

💬 Participant Q&A — Parking Lot

Questions raised during the workshop, answered with technical accuracy and practical guidance.

Q1 Should each SKILL.md focus on a single persona, or can we combine multiple personas into one skill?

Best practice: One skill per persona/task. Each SKILL.md should focus on a single, well-defined responsibility — same principle as microservices.

Approach	Pros	Cons
One skill per persona	Easier to test, clearer activation triggers, smaller token footprint, reusable across workflows	More files to manage
Combined mega-skill	Fewer files	Harder to debug, larger token usage on every activation, ambiguous triggers

Why: Kiro skills load full content on-demand when the agent determines relevance. A focused skill (500-1000 words) loads fast and keeps context clean. A mega-skill (5000+ words) wastes tokens when only one capability is needed.

Example structure: claims-triage/SKILL.md (router) + medical-claims-review/SKILL.md (specialist) + fraud-investigation/SKILL.md (specialist) — each independently testable, each with a clear activation trigger.

Q2 Can I create MCP connections to Jira, Confluence, and Figma?

Yes — all three have production-ready MCP servers available today.

Tool	MCP Server	Auth Method
Jira + Confluence	Official Atlassian MCP Server (GA)	OAuth 2.0
Jira + Confluence	mcp-atlassian (community)	API token or OAuth
Figma	Official Figma MCP Server	OAuth 2.0
Figma	Figma-Context-MCP (community)	Personal access token

What you can do: Jira — create/update issues, search with JQL, transition tickets. Confluence — read/create/update pages, search content. Figma — read design files, extract component properties, get layout info.

Security note: Use OAuth 2.0 (not personal API tokens) for production. OAuth provides scoped permissions, token expiry, and audit trails — important for MAS compliance.

Q3 Can a Kiro hook trigger another hook?

Not directly — hooks do not chain to each other by design. This prevents infinite loops and makes debugging straightforward.

Indirect chaining is possible:

Method	How It Works
Agent-mediated	Hook A uses `askAgent` → agent creates a file → file creation triggers Hook B (`fileCreated`)
Single orchestrator	One hook with a comprehensive prompt that runs multiple skills in sequence
Command chaining	Hook uses `runCommand` with a script that performs multiple steps

Recommended: Use a single userTriggered hook with an askAgent prompt that orchestrates the full pipeline. This is what the underwriting bonus exercise does — one hook triggers the agent to run 4 skills in sequence.

Q4 How should AI agents be positioned in CI/CD pipelines from a security perspective? Should AI deploy to production?

Best practice: AI automates dev/staging; humans approve production deployments. This follows the principle of progressive trust.

Environment	AI Agent Role	Human Role
Dev/Sandbox	Full autonomy — write code, run tests, auto-deploy, fix lint errors	Review when needed
Staging	Assisted — run tests, security scans, performance tests, auto-deploy to staging	Review flagged issues
Production	Read-only — generate change request, provide risk assessment, recommend rollback	Approve and deploy

Where AI adds value without deploying to prod: Code review & security scanning, test generation, IaC validation, dependency auditing, change impact analysis, post-deploy anomaly detection.

For AnyCompany (MAS-regulated): MAS Technology Risk Management (TRM) guidelines require human accountability for production changes. AI can prepare, validate, and recommend — but a named human must approve production deployments. This is a regulatory requirement for financial institutions in Singapore.

Q5 What is the difference between invoking an agent via Amazon Bedrock versus calling a model provider (Anthropic/DeepSeek) directly?

Bedrock = managed agent platform. Direct = raw model API access.

Aspect	Amazon Bedrock	Direct Provider
What you get	Agent orchestration, tool use, knowledge bases, guardrails, memory	Raw inference (text in → text out)
Security	Data stays in your AWS account, VPC endpoints, IAM, CloudTrail	Data sent to provider's endpoint
Guardrails	Native — content filtering, PII redaction, topic denial, grounding	You build your own
Model choice	30+ models via single Converse API (swap via config)	Only that provider's models
Compliance	SOC 2, ISO 27001, HIPAA, PCI DSS, MAS TRM compatible	Varies by provider
Vendor lock-in	Low — same API for all models	Locked to provider's API format

For AnyCompany: Bedrock is recommended. MAS TRM requires data residency controls, audit trails, and access management — all native to Bedrock. Direct provider access requires building these controls independently.

Q6 Does Kiro use compression or optimization techniques to reduce token consumption?

Yes — Kiro employs several context management strategies:

Technique	How It Works
Conversation compaction	When context window approaches its limit, earlier exchanges are summarized while preserving key decisions and recent context
On-demand skill loading	Only YAML frontmatter (name + description) loads at startup (~50-100 tokens). Full content loads only when relevant.
Conditional steering	Steering files with `inclusion: fileMatch` or `inclusion: manual` only load when relevant, not always
Intelligent file reading	Large files use AST parsing to extract only relevant signatures rather than loading entire files
Search-based context	Targeted search (grep, file search) finds only relevant sections rather than loading entire codebases

What Kiro does NOT do: It does not compress text in a lossy way or use a separate summarizer model to pre-process prompts. The actual tokens sent to the model are standard text.

Practical tip: Write focused skills (fewer tokens per activation), use inclusion: manual for large reference docs, and break large steering files into conditionally-included pieces.

Q7 How do you prevent model hallucination during long conversation sessions?

Hallucination risk increases with conversation length due to context dilution — earlier facts get de-prioritized as the context window fills. Proven mitigation strategies:

Strategy	How It Helps
RAG (Retrieval-Augmented Generation)	Ground every response in retrieved source documents. Re-retrieve for each new question rather than relying on earlier context.
Structured output enforcement	Require citations: "Based on [document, section X]: ..." Forces grounding over generation.
Data grounding rules	In steering: "Only use provided documents. State INFORMATION NOT PROVIDED for missing data."
Low temperature (0.0-0.2)	Reduces creative generation for factual tasks. Higher temperature only for brainstorming.
Chunked verification (Chaining)	Break tasks into steps, verify each output before proceeding. Each step produces verifiable results.
Multi-agent consensus	Multiple agents assess same data independently. Disagreements flag potential hallucinations.
Context window management	Start new sessions for new topics. Re-inject critical reference docs periodically.
Conversation compaction	Kiro auto-compacts, preserving key facts while summarizing verbose exchanges.

For AnyCompany: Combine RAG (grounding in policy documents) + structured output (cite section numbers) + escalation rules (flag low-confidence answers). This provides the strongest protection in regulated workflows.

Q8 What is the agentic AI strategy for QA use cases from a testing perspective?

Agentic QA uses autonomous AI agents that plan, execute, and adapt testing workflows based on goals rather than fixed scripts.

4 maturity levels:

Level	Approach	What AI Does	Human Role
L1	AI-Assisted	Generate test cases, suggest assertions, auto-complete scripts	Reviews everything
L2	AI-Augmented	Auto-generate regression suites, self-heal broken selectors, generate test data	Focuses on exploratory testing
L3	Agentic QA	Decides what to test based on code changes, risk, and coverage gaps	Sets goals, reviews results
L4	Self-Healing	Detects failures, diagnoses root cause, fixes tests, re-runs, reports	Handles only novel failures

Agentic QA workflow patterns:

Pattern	QA Application	Value
Chaining	Requirements → Generate test cases → Prioritize by risk → Generate test data → Output suite	6 hours manual → 30 min review
Routing	Code change → Classify (UI/API/DB) → Route to targeted test suite → Run → Report	4-hour full regression → 20-min targeted
Orchestration	Agent explores app → Detects anomalies → Generates bug reports → Prioritizes → Escalates	Finds edge cases humans miss; runs 24/7
Parallelization	Failed tests → Check UI change? + Check API change? + Real bug? → Auto-fix or file bug	40% reduction in test maintenance

For AnyCompany QA team: Start at L2 (AI-Augmented) — use AI to generate test cases from requirements and auto-generate regression suites. High-value starting points: regulatory test coverage from MAS circulars, claims processing regression, policy document validation after system updates.

🎓 Workshop Complete

Agentic AI Foundation — Key Takeaways

Agents ≠ Chatbots: Agents observe, plan, act, and reflect in a loop. They use tools, access data, and make decisions within guardrails.
4 Workflow Patterns: Chaining (sequential), Parallelization (simultaneous), Routing (classify & direct), Orchestration (dynamic + human-in-the-loop)
Design before build: The Agent Design Canvas captures what to build, how it should behave, and when humans take over — before any code is written.
Guardrails are non-negotiable: Every agent needs clear boundaries — what it must NOT do, when it must escalate, and what data it can access.
Start small, prove value: Pick one workflow, build one agent, measure the impact. Then expand.

🎯 Your deliverable: The Agent Design Canvas you created today is the document you hand to your tech team. It tells them exactly what to build, what guardrails to enforce, and how to measure success. Start the conversation this week.

← Workshop Home Agent Design Canvas →

📨 Workshop Summary