Agentic AI Use Case Deep Dive — Half-Day ILT (Follow-up)

About this session

A hands-on follow-up to the 0.5-day Agentic AI Foundations Workshop, for staff who identified a promising use case and want to take it further. Where the Foundations session builds awareness and a first idea, this Deep Dive is about refining, extending, and implementing that idea — deeper agentic patterns, a robust agent design, a full build with verification, the advanced capabilities that turn an assistant into an automation (Flows, connectors, and MCP), and a clear path to production for when a use case outgrows no-code.

Where Foundations had everyone build the same generic assistant (the Guideline Assistant) and sketch a canvas, this session moves to each participant’s specific use case. Participants have flexibility: continue from the Agent Design Canvas they started in Foundations, or bring a new problem statement from their work. Either way, they leave with a refined design, a working assistant on Amazon Quick, and a deploy-ready Build Kit — the instructions/prompt template, skills, connectors and automation — ready to hand to whoever deploys it. Worked examples by function are provided for anyone who needs a starting point — Vendor Proposal Analysis (Procurement/Finance), Policy & Circular Compliance (Governance), Claims / Leave Processing (HR), and Budget Variance Commentary (Finance).

Agnostic by design. The workflow patterns and design methods are platform-independent; the connector layer is the open Model Context Protocol (MCP); the build layer is the open-source Strands Agents SDK and the Kiro IDE; the runtime is Bedrock AgentCore. Amazon Quick is where staff build and verify — but the skills, standards, and tools travel to any agentic platform.

Learning Outcomes

By the end, participants can:

1. Select the right agentic workflow pattern for their use case from the four core patterns.
2. Write robust agent instructions — and package them as reusable Agent Skills — with guardrails and escalation rules for their use case.
3. Build and iterate a working assistant on Amazon Quick, including a verification step that catches errors.
4. Use advanced Quick capabilities — Automation (Flows), connectors, and the MCP client — to turn an assistant into an agent that reaches real systems and runs on a trigger.
5. Explain the path from prototype to production — when to move from no-code to a custom build with Kiro, Strands Agents, and Bedrock AgentCore, and how it deploys and is governed.
6. Design an agentic automation plan — triggers, steps, and human-in-the-loop checkpoints.
7. Turn the Agent Design Canvas into a deploy-ready Build Kit — a ready-to-use instructions/prompt template, skills, connectors and automation — prioritise on value / feasibility / risk, and define success metrics and an implementation path to hand to the DNA / IT team.

Agenda

Timings are adjustable. Runs equally well as a morning or afternoon session. D5 is calibrated to the room — awareness of the path for most, an on-ramp for the technically inclined.

Module Detail

D0 · Welcome + bring your use case (15 min)

• Quick recap of the Foundations essentials and the agent mindset.
• Each participant (or small team) frames their use case — continue from the Agent Design Canvas they started in Foundations, or bring a new problem statement from their work.
• Anyone who prefers a ready-made starting point adopts a worked example (Vendor Proposal, Policy & Circular Compliance, Claims/Leave, or Budget Variance).

D1 · Agentic workflow patterns in depth (35 min) — agentic AI workflow

• The four core patterns explored properly: Chaining · Parallelisation · Routing · Orchestration — with healthcare-admin scenarios.
• The agent loop (Observe → Plan → Act → Reflect) and levels of autonomy revisited at working depth.
• Applied: each participant picks the pattern that best fits their own use case and sketches the flow.

D2 · Build your agent’s Skills, instructions & data (40 min) ⭐ Hands-on — skills + instructions + grounding

• Building on the Foundations idea of Agent Skills — package the use case into a reusable, named capability: role, instructions, output specification, guardrails, escalation, and explicit “must NOT” rules.
• Applied (hands-on): each participant builds their agent on Amazon Quick — authors the Skill / instructions for their use case and connects the data it needs (documents, a Space), designing for verification and safe defaults (SGD, PII redaction, never-invent-data).

D3 · Build & verify — capstone (45 min) ⭐ Full hands-on

On Amazon Quick (a chat agent + connected data + instructions):

1. Deploy the instructions drafted in D2 for your use case.
2. Connect a document pack; run the agent → structured output.
3. Iterate on a deliberate-error document — the trust-but-verify teaching moment; refine the instructions until the agent catches it.
4. Generate the final output — a clean, template-aligned deliverable (e.g., a vendor comparison table, a formatted variance memo, or a policy briefing) — and review quality.

D4 · Advanced Quick — Automation, Connectors & MCP (35 min) ⭐ Demo + design — advanced capabilities

The shift from an assistant you invoke to an agent that acts, connects, and runs on its own — the L1 → L2 → L3 autonomy ladder. This is the “end-to-end automation, not just information retrieval” that staff have asked for.

• Automation (Flows): manual / scheduled / event-driven triggers, conditional logic, parallel paths, and human-in-the-loop approval steps — orchestrating steps across connected apps and data. Shown as a live demo so participants see a real automation, not a slide.
• Connectors: how Quick reaches the tools staff already use — files, SharePoint, Outlook, Teams, databases and more.
• MCP — the open connector standard: Amazon Quick Suite includes a managed Model Context Protocol (MCP) client, so an agent can securely connect to remote or custom-hosted MCP servers to reach any system that speaks the standard. Because MCP is open and vendor-neutral, this is the agnostic way to extend an agent — the same tools plug into other MCP-aware platforms too.
• Applied — the deliverable: each participant designs the “automation view” of their agent and captures it as an automation plan (Markdown) — the trigger, the steps, the systems it connects (connector / MCP), the approval/human checkpoints, and the fallback.

D5 · From prototype to production — Kiro, AgentCore & deployment (25 min) — the path beyond no-code

Where a use case outgrows no-code — bespoke logic, deep integrations, or enterprise scale — this is the path from a Quick prototype to a governed production agent. Positioned as options, and the bridge to the Technical Community (Track 3).

• The ladder: no-code (a Quick chat agent) → advanced (Quick Automation + connectors + MCP) → pro-code (a custom-built agent) — you climb only as far as the problem requires.
• Build it — Kiro + Strands: the Kiro IDE turns an Agent Design Canvas into specs and builds the agent and its tools with AI assistance (specs, hooks, steering); Strands Agents is the open-source SDK for the agent logic — portable and framework-agnostic.
• Run it — Bedrock AgentCore: the managed runtime that hosts and scales the agent securely (AWS IAM / VPC), with memory and observability, and can expose custom tools as an MCP server that plugs straight back into Quick. (Quick itself is built on AgentCore.)
• Deploy & govern it: how a validated prototype becomes production — the DNA / IT handoff, CI/CD (Azure repositories), infrastructure-as-code, guardrails, and monitoring. What the business builder hands over (canvas + automation plan + verified prototype) and what the technical team does with it.
• The agnostic read: open standard (MCP), portable SDK (Strands), a build tool (Kiro) and a managed runtime (AgentCore) — the skills and assets are not locked to any single platform.

D6 · Agent Design Canvas → Build Kit (25 min) ⭐ Working session

The canvas isn’t just a design to admire — participants turn it into a Build Kit: a deploy-ready package for their agent, captured as Markdown (like the Foundations one-pager) so it can be handed straight to whoever deploys it — themselves on Quick, or the DNA / IT team.

The Build Kit pulls together everything built across the session:

• Instructions / prompt template — the tested Skill + instructions from D2/D3, guardrailed and ready to paste into a Quick Suite chat agent (or hand to the technical team).
• Skills — the capabilities to enable, and how they’re configured.
• Data & connectors — the Spaces / documents and any connector or MCP server the agent needs.
• Automation — the trigger, steps, and human-in-the-loop checkpoints from D4.
• Guardrails, escalation & success metrics, plus the deployment path — what’s no-code on Quick today versus what needs the technical team (custom build / AgentCore).

Then prioritise on value × feasibility × risk (responsible-AI / PDPA) and confirm the first milestone. The output is something a participant — or the DNA / IT team — can deploy from directly, not just a design to admire.

D7 · Showcase & next steps (5 min)

• Rapid share-out of designs; peer and facilitator feedback.
• Each participant leaves with a working assistant and a deploy-ready Build Kit (canvas + prompt template + skills + connectors + automation), plus a first implementation milestone.
• How to engage the DNA / IT team, the champion network, and the Technical Community track for anything that needs a custom build.