AI Agents & Workflows
Maya Chen
Maya teaches agent design as workflow engineering: well-scoped tools, explicit state, clear stopping rules and a plan for every way a step can fail.
Sample profileLoading page
AI Agents
AI Agents & Workflow Engineering
Design tool-using, multi-step systems you can test and control.
- Level
- Advanced
- Format
- Online · Mentor-guided
- Duration
- 10 weeks (sample schedule)
- Effort
- 6–8 hrs/week (suggested)
- Modules
- 5 modules
- Price
- Price on request (demo)
- Availability
- Open enrollment (demo)
Register interestEditable sample values
01
Overview
Agents are useful when a task needs several steps and the right sequence is not known in advance. They are also harder to test, debug, and secure than a single model call. This program treats agent design as a systems engineering problem.
You will start with tool calling and deterministic workflows, then add planning loops, persistent state, and memory only where they earn their complexity. Along the way you will implement guardrails, permission boundaries for tools, and human-in-the-loop approval for actions with side effects.
By the end you will have built a tool-using agent with an evaluation harness that replays scenarios and checks both the final result and the path the agent took to reach it.
fig. — bounded agent loop
- 1
plan
next action from goal + state
- 2
select tool
allow-listed registry only
- 3
validate args
schema check before running
- 4
execute
timeout + idempotency key
- 5
observe
append result to state
- loop while goal not met
Exits
✓ respond
goal met, cite tool results
⏸ ask a human
approval required for write actions
✕ fail safely
step limit (8) or invalid tool call
state = { step: 3/8, tools: ["search_orders"], pending_approval: false }
02
Prerequisites
- Strong Python, including async code and type hints
- Experience calling model APIs and producing structured outputs
- Familiarity with retrieval concepts such as embeddings and vector search
- Comfort writing unit tests with pytest
03
Curriculum
Module 01: Tool Calling Fundamentals
Give models access to functions through well-defined schemas and handle the results safely.
- 01.1Defining tool schemas with JSON Schema and Pydantic
- 01.2Parsing tool calls and validating arguments
- 01.3Error handling, retries, and tool timeouts
- 01.4Designing tools that are easy for a model to use correctly
Module 02: Workflows and Orchestration
Choose the simplest structure that solves the task, from fixed pipelines to open-ended loops.
- 02.1Prompt chaining, routing, and parallel calls
- 02.2When to use a workflow and when to use an agent loop
- 02.3Orchestrator–worker patterns
- 02.4Step limits, budgets, and stopping conditions
Module 03: State, Memory, and Context
Track what the system knows across steps and sessions without overflowing the context window.
- 03.1Representing agent state explicitly
- 03.2Short-term conversation memory and summarization
- 03.3Long-term memory with retrieval
- 03.4Checkpointing and resuming long-running tasks
Module 04: Guardrails and Human Oversight
Constrain what an agent can do and bring people into the loop for consequential actions.
- 04.1Input and output validation
- 04.2Least-privilege tool permissions and sandboxing
- 04.3Prompt injection through tool results and retrieved content
- 04.4Human-in-the-loop approval for actions with side effects
- 04.5Escalation paths and graceful failure
Module 05: Testing and Debugging Agents
Evaluate both what the agent produced and how it got there.
- 05.1Scenario-based test suites with mocked tools
- 05.2Trajectory evaluation: checking tool choices and step order
- 05.3Tracing agent runs for debugging
- 05.4Regression testing as prompts and tools change
04
Skills and project outcomes
Skills you’ll practice
- Tool schema design and argument validation
- Workflow and agent orchestration patterns
- Agent state and memory management
- Guardrails and permission boundaries
- Human-in-the-loop approval flows
- Defending against prompt injection in tool results
- Scenario and trajectory evaluation
- Tracing multi-step runs
What you’ll build
- A tool-using agent with validated tool calls and step limits
- An approval flow that pauses for human review before side-effecting actions
- A scenario test suite with mocked tools and trajectory checks
- A design write-up explaining the agent's boundaries and failure handling
Related project briefs
Outcomes describe skills and artifacts you will practice. No certification, employment or career outcome is guaranteed.
05
Mentors
LLM Application Engineering
Alex Morgan
Alex focuses on the unglamorous parts of LLM products: input validation, structured outputs and graceful failure. Their sessions are about turning a promising prototype into code a team can maintain.
Sample profile06
Program FAQs
Core patterns are built in plain Python first so you understand what frameworks do for you. Later modules show how the same patterns map onto popular open-source orchestration libraries.
07
Where this fits
Interested in AI Agents?
Register your interest and tell us about your experience. We’ll suggest where to start.