Agentic AI Foundations — Half-Day Workshop (All Staff / Track 1)

About this session

A hands-on, half-day session that takes all staff from understanding how AI actually works to building an agent. We start with the platform-agnostic foundations — how a language model reads, represents meaning, and stays grounded in your documents — then everyone builds a shared, grounded assistant together (the Guideline Assistant) on Amazon Quick, and designs an agent for their own work on the Agent Design Canvas — the springboard into the optional Use Case Deep Dive.

The concepts come first and are tool-independent; Amazon Quick is simply where we apply them. Staff leave understanding why an agent behaves as it does — knowledge that transfers to any AI tool.

A second goal: help the team see the full range of agent capabilities — from grounding a document to automating a workflow — and understand what they can build today. Some capabilities depend on the subscription tier and on which connectors an administrator has enabled, so staff leave clear on what is available to them now and what to ask for next.

Learning Outcomes

By the end, participants can:

1. Explain in plain language how AI works — how a model reads text (tokenization), captures meaning (embeddings), and stays grounded in a source document — and why that matters for trusting its output.
2. Explain what makes an AI system an agent (versus a chatbot) — and why that shift matters for their work.
3. Write a clear system prompt / instructions using CRAFT — Context, Role, Action, Format, Trust.
4. Understand how a proven set of instructions becomes a saved Chat Agent — a reusable assistant the whole team can open, rather than a prompt one person retypes.
5. Build a simple working agent on Amazon Quick — a grounded chat agent that reads a document and produces a documentation report.
6. Design an agent for their own workflow on the Agent Design Canvas — and spot the advanced capabilities a design could use: Automation, Quick Flows, triggers / schedules, and knowledge Spaces.
7. Understand which agent capabilities are available to them today, and where Amazon Bedrock sits beneath Amazon Quick as the engine.

Agenda

Timings are adjustable; runs equally well as a morning or afternoon session. The How-AI-Works explainers are also sent as an optional pre-read for anyone who wants to go deeper. Full module descriptions follow below.

Module Detail

F0 · Welcome — from AI users to agent builders (10 min)

• Goals, Amazon Quick sign-in, quick poll (“what task eats your week?”).
• Meet the shared use case: the Guideline Assistant — an agent that reads an internal staff guideline (e.g., leave, claims, IT & data-handling, procurement rules) and helps you understand it, answer a question grounded in it, and draft a compliant note. Every employee deals with guidelines, whatever their function.

F1 · How AI actually works (30 min) — AI foundations (agnostic)

• The platform-agnostic grounding that makes everything after it make sense — kept deliberately plain-language and visual, using our interactive explainers.
• Tokenization: how a model reads text as tokens (why wording changes behaviour) — LLM Foundations & Tokenization explainers.
• Meaning / embeddings: how a model compares meaning, so it can find the right clause even when the words differ.
• Grounding: why an agent answering from your document (and citing it) beats a model answering from memory — the single idea behind the Guideline Assistant. Grounding explainer.
• The leadership read: these concepts don’t change when the tool changes — understand them once, use them everywhere.

F2 · From Chatbots to Agents (40 min) — agentic AI concept

• Why a chatbot hits a wall: it can draft and summarise, but it can’t fetch fresh data, reach a system, or take a multi-step action.
• The four ideas that turn an LLM into an agent: tool use, step-by-step reasoning, reading documents/images, and the framework that runs the loop.
• On Amazon Quick: an agent’s capabilities come from chat over your data, connected sources (Spaces), research, business intelligence, and automation — the building blocks you’ll draw on in the build.
• The four phases: LLM → Assistant → Agent → Agentic System — increasing autonomy, with healthcare-admin examples.
• The leadership read: chatbots make people faster; agents take work off the plate.

F3 · Prompting your agent (35 min) — prompt engineering

• CRAFT — Context · Role · Action · Format · Trust — five slots taught on one running example (a staff leave request judged against a real guideline), including the persona technique — framed as writing an agent’s instructions, not just one-off prompts.
• Structured output (summaries, tables, checklists) and simple guardrails (“only use the connected document,” “never invent data,” “cite the section”).
• From a prompt to a saved agent — the elevation: a good set of instructions, saved so it can be reused, becomes a Chat Agent — a named assistant with its own persona, instructions, knowledge source and suggested prompts. That is the reusable building block that sits above a one-off prompt: you write CRAFT once, and the whole team opens the careful version instead of retyping the lazy one. The idea is platform-agnostic — the same thinking applies on any agentic tool.
• Short guided practice that produces the agent instructions used in the next module.

F4 · Build the Guideline Assistant on Amazon Quick (55 min) ⭐ Guided demo + simple build

A light, guided build everyone completes together — the shared warm-up before designing their own agent. It also teaches the single most important idea: an agent grounded in your documents, not the open internet.

1. Create a chat agent and give it its instructions (role + rules: answer only from the provided document, cite the section, say “not covered” if it isn’t there) — starter template provided.
2. Connect a sample internal guideline (synthetic) as its grounding; ask it a question → a cited, grounded answer that points to the relevant section.
3. Have it produce a documentation report — a structured, brand-aligned document (overview, key points, and citations back to the guideline), generated from the source rather than hand-written.
4. Quick debrief: notice it answers from your document, cites what it used, flags what isn’t covered, and turns that into a polished report — why a grounded agent beats a generic chatbot, and where a human still checks.

Deliberately simple and universal so a class of ~50 (and, at scale, thousands of staff) can complete it comfortably. The deeper, robust build — with verification and guardrails — lives in the optional Deep Dive.

F5 · Agent Design Canvas — your use case (45 min) ⭐ Working session

• Using the Guideline Assistant as the template, each participant designs an agent for a task in their own function (Finance, HR, Operations, Procurement, admin).
• The canvas captures: purpose, the steps, the data / knowledge Space it needs, its instructions, guardrails, whether it could be automated or scheduled, and how they’d know it’s working.
• Explore the possibilities — what the platform can do: as they design, participants map their idea onto the advanced capabilities an agent could grow into, so they know what’s on the table:
  • Knowledge Space — grounding across a whole library of documents, not just one upload.
  • Automation & Quick Flows — turning a manual, repeated ask into a multi-step workflow the agent runs.
  • Triggers / schedules — the agent runs on an event or a timetable, not only when you ask. These are shown as awareness (the hands-on lives in the Deep Dive), so staff can picture where a simple assistant can go.
• What’s available today: for each possibility, note whether it is something they can build themselves now, or something that first needs an administrator to enable a connector or a higher subscription tier — so the team leaves knowing what is within reach.
• Output — a design one-pager: each participant captures their canvas as a simple Markdown file, converted into a branded HTML one-pager — a polished, shareable design they take away and present in the showcase.
• Share a few aloud. This canvas is the ticket into the optional Use Case Deep Dive, where it gets refined, built properly, and prepared for implementation.

F6 · Wrap-up & what’s next (10 min)

• Key takeaways; recognise the common workflow patterns and Amazon Bedrock as the engine beneath Amazon Quick — so staff know what they’ve learned sits on solid, enterprise-grade ground.
• Capability recap: an honest map of which agent capabilities they can use today and which need IT involvement — so everyone knows what they can build now.
• The optional 0.5-day Use Case Deep Dive for those who want to mature their canvas; the champion network; feedback.