Pick a real workflow from your team, choose a workflow pattern, and design the full agent using the Agent Design Canvas.
⏱ 45 minutes + bonus
Exercise Overview
This is the capstone exercise of the workshop. You've learned what GenAI can do, how to communicate with it effectively, and how to build reusable skills and automation. Now you'll put it all together — designing an AI agent for a real workflow from your own team.
You'll work in teams of 3-4 to select a workflow, choose an automation pattern, and fill out an Agent Design Canvas — a structured one-page document that captures everything needed to build the agent: its role, workflow steps, data requirements, guardrails, escalation rules, and expected business impact. This is the document you'd hand to your tech team to start implementation.
🎯 Deliverable
Each team produces an Agent Design Canvas — saved as a markdown file in your workspace. Submit it for LLM-as-Judge scoring — an automated evaluation technique applied to your agent design.
Step
What you do
Duration
Step 1
Pick your workflow
3 min
Step 2
Confirm the workflow pattern
2 min
Step 3
Design the agent (canvas auto-fills → paste into Kiro)
25 min
Step 4
Generate a presentable HTML canvas
5 min
Step 5
Submit for LLM-as-Judge scoring
5 min
⭐ Bonus
Build it yourself — turn the Invoice Processing canvas into Skills + Hooks
20 min
Step 1: Pick Your Workflow
Click a workflow below to select it (or pick your own). Your selection will auto-fill the canvas prompt in Step 3.
🏥 Claims triage & adjudication
Classify claim type → validate coverage → auto-decide or escalate
Recommended: Routing
📋 Underwriting risk assessment
Assess medical + financial + compliance in parallel → risk classification
Recommended: Parallelization
📜 Regulatory change impact
Scan MAS circular → assess gaps → generate action items
Identify renewals → assess coverage gaps → recommend to advisor
Recommended: Chaining
✅ Selected: —
⚠️ Best choice: Pick a workflow that your team does at least weekly and that takes at least 30 minutes each time. The bigger the time savings, the stronger your business case. You can also pick your own workflow — just type it into the canvas prompt in Step 3.
Step 2: Confirm the Pattern
The recommended pattern is pre-selected based on your workflow choice. You can change it if you prefer a different approach:
🔗 Chaining
A → B → C (sequential)
⚡ Parallelization
Run 3 analyses → combine
🔀 Routing
Classify → route to correct path
🎯 Orchestration
Decision points + human review
Step 3: Fill the Agent Design Canvas
The canvas below is pre-filled based on your selections. Review it, adjust anything that doesn't fit your team's specifics, then copy and paste into Kiro:
AGENT DESIGN CANVAS — Copy & paste into Kiro
Help me design an AI agent using this canvas template. I'll describe my workflow and you help me fill in each section.
# Agent Design Canvas
## Agent Identity
- **Name:** [descriptive name for the agent]
- **Role:** [Use the persona formula: Title + Experience + Specialty + Characteristic + Behavior]
- **Trigger:** [What event starts this agent? e.g., "New file uploaded", "Weekly schedule", "Manual request"]
## Workflow
- **Pattern:** [ ] Chaining [ ] Parallelization [ ] Routing [ ] Orchestration
- **Steps:**
1. [First action — what skill runs? what does it produce?]
2. [Second action — what does it do with the output of step 1?]
3. [Third action — decision point, human review, or final output?]
## Data
- **Inputs:** [What data does the agent need? Files, databases, APIs?]
- **Outputs:** [What does it produce? Report, notification, decision?]
- **Knowledge base:** [What documents should it reference? Policies, guidelines?]
## Guardrails
- **Must NOT:** [List negative constraints — what the agent must never do]
- **Escalate when:** [When does a human take over? Thresholds, confidence levels?]
- **Data rules:** [Grounding rules — only use provided data? Citation requirements?]
## Kiro Implementation
- **Steering file:** [What global rules apply?]
- **Skills needed:** [List each SKILL.md file needed for the workflow steps]
- **Hook trigger:** [What event triggers the workflow?]
- **MCP connections needed:** [What external systems? e.g., database, Slack, email, Google Drive — your tech team sets these up]
## Business Impact
- **Current process:** [How is this done today? How long does it take?]
- **With agent:** [Expected time savings per week/month]
- **Success metric:** [How will you measure if the agent is working?]
---
My workflow is: [Select a workflow in Step 1 above]
The pattern I chose is: [Select a pattern in Step 2 above]
My team currently spends [TIME] on this each [FREQUENCY].
Save the completed canvas as a markdown file at lab10-agent-canvas/agent-design-canvas.md
💡 Tips for a strong canvas:
Be specific about the trigger — "new CSV file in /data" is better than "when needed"
Name each skill — each step should map to a SKILL.md file
Include escalation rules — when does a human take over?
Quantify the business impact — "saves 10 hours/week" is more compelling than "saves time"
Use proven techniques — persona for the role, structured output for each skill, negative constraints for guardrails
Step 4: Generate a Presentable Canvas
Turn your Agent Design Canvas into a polished, visual HTML page that you can present on screen. In the same session, paste:
PROMPT — Generate HTML Canvas
Based on the Agent Design Canvas we just created, generate a single-page HTML file called "lab10-agent-canvas/agent-canvas.html" in the workspace.
The page should be a professional, presentation-ready visual layout of the canvas with:
1. A header bar with the agent name, workflow pattern badge, and team name
2. A visual workflow diagram showing the steps as connected boxes with arrows (use CSS — no images needed). Color-code by step type: blue for data input, green for AI processing, orange for decision points, red for human escalation
3. A two-column layout below the diagram:
- Left column: Agent Identity (name, role, trigger), Data (inputs, outputs, knowledge base)
- Right column: Guardrails (must-not rules, escalation triggers, data rules), Business Impact (current vs with agent, success metrics)
4. A "Kiro Implementation" section at the bottom showing: steering file, skill files needed, hook trigger, MCP connections — styled as a technical spec card with a dark background
5. A footer: "Agent Design Canvas — AnyCompany Insurance — [Team Name]"
Design: Clean white background, AnyCompany green (#00B14F) accent, professional typography, subtle shadows. Should look good projected on a screen.
Open the HTML file in the browser after generating.
✅ Checkpoint: You should now have:
A completed Agent Design Canvas (markdown — lab10-agent-canvas/agent-design-canvas.md)
A visual HTML version (lab10-agent-canvas/agent-canvas.html) ready to present on screen
💡 From canvas to production — see it realized in Lab 4
Want to see what happens when an Agent Design Canvas becomes real working code? Lab 4: Agentic Invoice Processing → takes the Invoice Processing canvas and implements it as a multi-agent system using the Strands Agents SDK:
Canvas Section
What it becomes in code
Agent Identity → Role
System prompt for each agent (system_prompt="You are a Senior AP Analyst...")
The canvas is the design document. Lab 4 is the working prototype. This is exactly the handoff your tech team would do — your canvas tells them what to build, the code shows how it works.
Step 5: Submit & Score Your Canvas
Submit your Agent Design Canvas for automated LLM-as-Judge scoring. Paste the markdown content from your canvas file, and the AI will evaluate it on 6 criteria.
📤 Submit Your Canvas
Submit as a team or individually. Resubmitting with the same name replaces your previous entry.
💡 How scoring works
Your canvas is sent to Amazon Bedrock (Claude Sonnet) which acts as an LLM-as-Judge — an automated evaluation technique. The AI evaluates your agent design.
The judge reviews your canvas holistically across several dimensions: how clearly you've defined the problem, whether the workflow design is logical and complete, how well you've thought through safety and escalation, and whether the design is grounded in AnyCompany's actual operations. Each dimension is scored 1-5, giving a total out of 30.
What makes a strong canvas? The same principles from the workshop apply — be specific (not vague), ground everything in data (not assumptions), include guardrails (not just the happy path), and quantify the business impact (not just "saves time"). The more concrete and actionable your canvas, the higher it scores.
Score
Verdict
What it means
25-30
🥇 Production-Ready
Your tech team could start building from this canvas this week
19-24
🥈 Strong Design
Solid foundation — address the feedback and it's ready
13-18
🥉 Good Start
Right direction but needs more specificity — check the improvements
Below 13
🔄 Needs Rework
Add more detail — the AI feedback tells you exactly where
🏆 Leaderboard
All team submissions ranked by score. Click "Refresh" to see new entries.
Loading leaderboard...
⭐ Bonus: Turn Your Canvas into a Working Agent
You've designed the canvas and submitted it for scoring. Now let's close the loop — ask Kiro to read your canvas and generate the actual Skills, Steering, and Hooks from it. Your design document becomes a working prototype.
🎯 The idea
Your Agent Design Canvas already has everything Kiro needs: the agent role, workflow steps, data requirements, guardrails, and implementation plan. Instead of writing each skill from scratch, we'll feed the canvas to Kiro and let it generate the full stack.
Step 1: Generate Skills from Your Canvas
📦 Need the invoice processing files?
This bonus step reuses the Python scripts from the invoice extraction exercise. If you don't have the lab1-invoice-processing/ folder, download the pre-built version:
Extract it into your Kiro workspace — you should see a lab1-invoice-processing/ folder
In a new Kiro session, paste this prompt. It reads your canvas and creates skills — reusing the Python scripts you already built for the deterministic tasks:
PROMPT — Copy & paste into Kiro
Read my Agent Design Canvas file at lab10-agent-canvas/agent-design-canvas.md
Also look at the existing Python scripts in my lab1-invoice-processing/ folder — these were built earlier for invoice extraction and validation (e.g., invoice_extractor.py, invoice_validator.py, generate_invoices.py).
Based on the canvas, create Kiro skill files for each workflow step. There are TWO types of skills — use the right one for each step:
**Type A: Skills with scripts** (for deterministic tasks — math, file parsing, data lookup)
For these, REUSE the existing Python scripts from lab1-invoice-processing/ instead of writing new ones. Copy the relevant scripts into the skill's scripts/ subfolder:
```
.kiro/skills/[step-name]/
├── SKILL.md ← Instructions: when to activate, what the script does, how to use it
└── scripts/
└── [script].py ← Copy from lab1-invoice-processing/ and adapt if needed
```
The SKILL.md should reference the script like:
```bash
python .kiro/skills/[step-name]/scripts/[script].py
```
Use this type for steps that involve: PDF/file parsing, math calculations, PO matching, CSV processing, variance calculations.
**Type B: Prompt-only skills** (for AI reasoning — analysis, compliance review, report writing)
Create these as SKILL.md only (no scripts folder). The AI handles the reasoning directly.
Use this type for steps that involve: compliance assessment, risk analysis, decision synthesis, report narrative, executive summaries.
For each skill (both types), include:
1. The persona from the canvas (or a specialized version for that step)
2. Structured output sections relevant to that step
3. The guardrails from the "Guardrails" section of the canvas
4. Input/output format based on the "Data" section
For script-based skills, use the pdf-to-markdown skill as a reference pattern — look at .kiro/skills/pdf-to-markdown/SKILL.md for how it references its scripts.
If the canvas has multiple workflow steps that could run in parallel, create separate skills for each parallel path plus a synthesis skill that combines their outputs.
Make sure each skill follows the SKILL.md format with name, description, and trigger keywords in the frontmatter.
After creating all skills, show me a summary table:
| Skill | Type | Has Script? | Script source | What it does |
💡 Why reuse existing scripts? In the earlier exercise, you asked Kiro to write Python code for invoice extraction and validation. That code already works — it parses PDFs, matches POs, calculates variances. Instead of rewriting it, we wrap it in a skill so it runs automatically. This is the "code calculates, AI narrates" pattern: scripts handle precision tasks (math, parsing), prompt-only skills handle reasoning tasks (compliance, decisions).
Step 2: Generate Steering and Hook from Your Canvas
PROMPT — Copy & paste into Kiro (same session)
Now, still using my Agent Design Canvas, create two more files:
1. A steering file at .kiro/steering/[workflow-name]-rules.md based on the "Guardrails" section of my canvas. Include:
- The "Must NOT" rules as always-on constraints
- The "Escalate when" thresholds
- The "Data rules" as grounding requirements
- Any domain-specific rules from the canvas (currency, thresholds, etc.)
2. A hook file that triggers the workflow based on the "Trigger" field in the "Agent Identity" section. The hook should:
- Use the trigger event from the canvas
- Ask the agent to run each skill in the order defined in the workflow steps
- Save the final output as a markdown report
Show me a summary of what was created: list each file with its purpose.
Step 3: Test the Workflow
Now let's test the full skill chain by triggering the hook. We need to create a "fresh" state so the hook sees new files being created.
Backup your invoice processing folder — in the terminal, copy it to a safe location:
Trigger the hook — run the generate script to create fresh PDF invoices. Since the hook watches for new PDF files, this should trigger the skill chain:
TERMINAL
cd lab1-invoice-processing
python3 generate_invoices.py
Observe the hook in action — watch the Kiro agent panel. The hook should fire and run the skill chain automatically: extraction → validation → decision → report generation.
💡 If the hook doesn't trigger: The fileCreated event may not fire if the PDFs already existed and were overwritten. In that case, delete the invoices folder first (rm -rf lab1-invoice-processing/invoices/), then re-run python3 generate_invoices.py — this ensures the files are truly new. Alternatively, use the Kiro hook panel to manually trigger the hook.
✅ What to verify:
Kiro created skill files matching your canvas workflow steps
The steering file contains your canvas guardrails
The hook triggers on the right event
The happy path case gets the expected result (e.g., APPROVE)
The escalation case triggers correctly (e.g., ESCALATE or FLAG)
The edge case is handled gracefully (e.g., "DATA NOT AVAILABLE")
🎉 What just happened
You went from a design document (the canvas) to a working prototype (skills + steering + hook) in three prompts. This is the workflow your tech team would follow:
Business user designs the canvas (Steps 1-5 of this lab)
Tech team reads the canvas and builds the implementation (what Kiro just did for you)
Test with sample data, iterate on the skills, deploy to production
The canvas is the handoff document. Today you played both roles — designer and builder.
🔗 Want to see the code version?
Lab 4: Agentic Invoice Processing → takes the Invoice Processing canvas and implements it as a multi-agent Python system using the Strands Agents SDK. Same design, different implementation path — Skills + Hooks for prototyping, Strands SDK for production.