AI Agents and Workflow Engineering

Understand what makes a system an agent and build the basic loop from scratch before using any framework.

• Workflows versus agents: when fixed steps beat open-ended autonomy
• The loop of model call, tool selection, execution, and observation
• Stop conditions, step limits, and loop detection
• Planning patterns such as plan-and-execute and ReAct-style reasoning
• Error handling when a tool fails or returns unexpected data
• Choosing models for planning versus simple steps

Hands-on lab: Write a minimal agent loop in plain Python with two tools, a step limit, and error recovery, and run it on five tasks including one designed to fail.

Design tools models can use reliably and expose them through the open MCP standard.

• Writing tool names, descriptions, and schemas that models interpret correctly
• Granularity: few capable tools versus many narrow ones
• Idempotency and safe side effects
• What MCP is: clients, servers, tools, resources, and prompts
• Building an MCP server in Python
• Security considerations for third-party MCP servers

Hands-on lab: Build an MCP server that wraps a small internal API, connect it to an MCP-capable client, and refine tool descriptions until a set of test prompts succeeds.

Model multi-step processes as graphs with explicit state so behavior is inspectable and repeatable.

• Nodes, edges, and shared state in LangGraph
• Conditional routing and branching
• Retries, fallbacks, and timeouts at the node level
• Parallel branches and combining results
• Supervisor and specialist multi-agent patterns, and their costs
• Comparing LangGraph with plain code and other orchestration approaches

Hands-on lab: Implement a research-and-draft workflow in LangGraph with a routing step, a retry on failure, and two specialist nodes, then compare it with a plain-code version.

Give agents the context they need across steps and sessions without overwhelming the model.

• Short-term memory: message history, trimming, and summarization
• Persisting graph state with checkpointers
• Long-term memory stored in a database or vector store
• What to remember, what to forget, and privacy implications
• Retrieval as a tool the agent can choose to use
• Resuming interrupted runs

Hands-on lab: Add persistent checkpoints and a long-term preference store to your workflow, interrupt a run midway, and resume it from saved state.

Constrain what agents can do and place people at the decisions that matter.

• Least-privilege tool permissions and scoped credentials
• Input and output validation with schemas
• Budget limits on tokens, tool calls, and wall-clock time
• Prompt injection through tool results and documents
• Approval gates and interrupts for high-impact actions
• Designing review interfaces that show the proposed action and its evidence

Hands-on lab: Add an approval interrupt before any write action, enforce a call budget, and run an injection test that tries to push the agent past its permissions.

Make agent behavior visible, measurable, and shippable.

• Tracing runs with LangSmith or an equivalent tool
• Logging tool calls, inputs, outputs, and token usage
• Evaluating agents on task success, step count, and cost
• Building test scenarios and replaying failed runs
• Packaging an agent service with Docker
• Operating agents: alerting, rollbacks, and handling model changes

Hands-on lab: Trace your workflow end to end, build ten evaluation scenarios with success criteria, find one failure from the traces, fix it, and rerun the scenarios.