Agentic AI & Workflow Orchestration

This course teaches leaders and practitioners how to plan, design, and prototype task-seeking AI assistants that use tools, memory, and multi-step workflows. Students will learn to map business processes to agentic workflows, compare platform options including Microsoft Copilot Studio, Power Automate, and Amazon Bedrock Agents, and implement safety controls such as tool scopes, confirmation gates, and audit trails. The course emphasizes practical implementation patterns and organizational adoption strategies.

Participants will gain hands-on experience designing agent architectures (planners, routers, reviewers, tool-callers), configuring multi-step workflows with human-in-the-loop controls, implementing data permissions and security, building reliability patterns with fallbacks and retries, and creating adoption plans with change management strategies. Through progressive labs and a capstone project, students will develop a complete agent proof-of-concept ready for organizational review.

Audience

This course is designed for leaders designing AI-assisted processes across operations, customer experience, finance, HR, claims, and related business domains. Product and operations leads, solution owners and architects, business process analysts, and technical leads implementing agentic AI solutions will benefit from this practical, implementation-focused curriculum.

Objectives

Upon completion of this course, students will be able to:

• Map business processes to agentic workflows using plan → act → check → report patterns
• Design agent architectures including planners, routers, reviewers, and tool-calling agents
• Assign autonomy levels per tool based on the cost of an incorrect action
• Evaluate and select appropriate tooling options: Copilot Studio actions, Power Automate, Bedrock Agents, and low-code patterns
• Separate agent judgment from flow execution so that irreversible actions remain deterministic
• Implement safety controls including tool scopes, confirmation gates, least privilege access, and audit trails
• Classify data fields and apply masking so that agents process only what a decision requires
• Build reliability patterns with fallbacks, timeouts, retries, idempotency, and handoff procedures
• Evaluate a non-deterministic agent against a fixed task set using a scoring rubric
• Create organizational adoption plans with rollout strategies, enablement materials, and success metrics

Topics

• Agent design patterns: planner, router, reviewer, and tool-caller architectures
• The agent loop: plan, act, check, report – and the check most teams skip
• Goal definition, tool selection, guardrail implementation, and success metrics
• Autonomy levels and gating actions by what they can undo
• Microsoft Copilot Studio actions and custom agent development
• Power Automate flow orchestration and integration patterns
• Amazon Bedrock Agents configuration and deployment
• The agent/flow boundary: where judgment ends and execution begins
• Data permissions, least privilege access, and sensitive data masking
• Confirmation gates and human-in-the-loop workflow patterns
• Audit logging, compliance tracking, and governance controls
• Prompt injection and the architectural controls that limit its impact
• Reliability engineering: fallbacks, timeouts, retries, and graceful degradation
• Partial failure, idempotency, and designing a useful human handoff
• Evaluating non-deterministic systems with fixed task sets and scoring rubrics
• Impact measurement, change management, and organizational adoption strategies

Prerequisites

Students should have:

• Comfort with business process mapping and workflow design
• Understanding of organizational processes and approval workflows
• A business process they own, to use as a running example throughout the labs
• Familiarity with enterprise software systems and integrations (helpful but not required)
• Modern web browser with internet access; no coding is required at any point
• Access to Microsoft Copilot Studio and Power Automate, or Amazon Bedrock Agents (helpful but not required – every lab has a platform-neutral track, and instructor demos are available)

Outline

Day 1: Designing the Agent

I. Agent Architecture Patterns

1. Introduction to Agentic AI Systems
   1. Agent vs. traditional automation: autonomy, reasoning, and tool use
   2. The agent loop: plan, act, check, report
   3. Core agent patterns: planner, router, reviewer, and tool-caller
2. Designing Your First Agent
   1. Goal definition and testable success criteria
   2. Tool inventory, capability mapping, and reversibility
   3. Knowledge sources, memory scope, and guardrail design
   4. Autonomy levels and choosing one per tool
3. Hands-On Lab 1: Sketch Your Agent Design
   1. Write a goal statement with a number or an explicit boundary
   2. Inventory tools and mark what cannot be undone
   3. Assign an autonomy level per tool and write enforceable guardrails
   4. Name the success metric and its present-day baseline

II. Platform Tooling Options

1. Microsoft Copilot Studio and Actions
   1. Custom agent creation and configuration
   2. Topics, knowledge sources, actions, and instructions
   3. Publishing surfaces and their limits
2. Power Automate Flow Orchestration
   1. Multi-step workflow design and triggers
   2. Conditional logic, branching, and run history
   3. Native approval actions and audit trails
3. Amazon Bedrock Agents
   1. Agent configuration and foundation model selection
   2. Action group definition and API integration
   3. Knowledge base grounding and retrieval
4. Choosing and Combining Platforms
   1. Matching the platform to what the agent mainly does
   2. The agent/flow boundary: judgment versus execution
   3. Costs beyond the license: usage, connectors, approver time, maintenance
5. Hands-On Lab 2: Configure a Multi-Step Flow with Human-in-the-Loop
   1. Select a platform and validate it against a governance checklist
   2. Draw the agent/flow boundary for your process
   3. Configure an approval gate with all four outcomes
   4. Test the approved, rejected, and timed-out paths

III. Data Security and Permissions

1. Least Privilege Access Design
   1. Identity models: user, service account, scoped, and delegated
   2. Scoping tools and parameters rather than systems
   3. Gating actions by what they can undo
   4. API key management and credential vaulting
2. Sensitive Data Protection
   1. Classifying data before the model sees it
   2. PII masking that preserves matching and shape
   3. Deciding what the decision actually needs
   4. Compliance considerations (GDPR, HIPAA, PCI DSS)
3. Audit and Compliance Controls
   1. The six fields of a reconstructable audit entry
   2. Logging references rather than contents
   3. Correlating a request across systems
   4. Prompt injection and the architectural controls that limit it
4. Hands-On Lab 3: Permissions and Data Handling
   1. Choose and justify an identity model
   2. Scope every tool to the narrowest workable grant
   3. Classify each data field as pass, mask, or never fetch
   4. Specify the audit entry and its retention period

Day 2: Proving It and Running It

IV. Reliability and Error Handling

1. Failure Modes and Mitigation
   1. Six failure modes: model, tool, data, loop, permission, human
   2. Partial failure and why it is the characteristic agent problem
   3. Validating agent output against the system of record
   4. Retry with exponential backoff, and what is safe to repeat
2. Fallback Strategies
   1. Timeouts, step limits, and circuit breakers
   2. The fallback ladder and honest degradation
   3. Human handoff triggers and the handoff package
   4. Keeping the manual path warm
3. Monitoring and Alerting
   1. Signals worth watching, including silent failure
   2. Alerting somebody will act on
   3. Testing failure deliberately before go-live
4. Hands-On Lab 4: Add Reliability Controls to Your Agent
   1. Name your three most likely failure modes and their triggers
   2. Set retry, timeout, and step limits with stated reasons
   3. Design the fallback ladder and the handoff package
   4. Test failure scenarios and confirm the audit trail

V. Measuring Impact and Driving Adoption

1. Evaluating a Non-Deterministic System
   1. Why a spot check proves nothing
   2. Building a fixed task set from real cases
   3. Rubrics, scoring levels, and the blocking row
   4. Diagnosing failures by type and re-running on defined triggers
2. Success Metrics and KPIs
   1. Choosing a metric the organization already reports
   2. Measuring the baseline before the agent exists
   3. Metrics that mislead
   4. Cost per case, including the approver’s time
3. Change Management and Rollout
   1. Pilot group selection and why enthusiasts are the wrong choice
   2. A ninety-day rollout gated on evidence
   3. What to tell people before launch
   4. Feedback loops and scaling without breaking it
4. Hands-On Lab 5: Evaluate and Measure Your Agent
   1. Assemble a task set of real cases across four categories
   2. Write a three-level rubric with a blocking row
   3. Score a run and diagnose failures by type
   4. Define the metric and the baseline you will measure

VI. Capstone and Close

1. Assembling the POC Pack
   1. How the five deliverables govern the runtime
   2. The two-page brief: the case and the controls
   3. Demo script design, including a graceful failure
2. Hands-On Lab 6 – Capstone: Agent POC Plan and Demo
   1. Assemble the two-page agent POC proposal
   2. Build a three-case demo script with narration
   3. Design a ninety-day rollout plan with evidence gates
   4. Peer review against the final quality checklist
   5. Present the POC and adoption strategy