GitHub
Practical AI Agent Workflows
4 hours, 25 minutes
CC
Course Description
Build AI workflows and agent systems that balance context, reliability, and cost. Explore the tools, memory, retrieval, planning, and reflection that make single agents effective. Compare single and multi-agent patterns and choose, test, and improve the right architecture for each task.
Prerequisite: Practical Prompt Engineering or experience with any programming language and basic knowledge of LLMs.
Preview
Course Details
Published: October 23, 2026
Learn Straight from the Experts Who Shape the Modern Web
Your Path to Senior Developer and Beyond
- 300+ In-depth courses
- 24 Learning Paths
- Industry Leading Experts
- Live Interactive Workshops
Table of Contents
Introduction
Section Duration: 8 minutes
Sabrina (Bri) Goldfarb from the GitHub Copilot team introduces the course and explains why efficient AI use matters more than using as many tokens as possible. She describes the simple scorecard for weighing context, reliability, and cost, which will be used throughout the course.
Agent Fundamentals
Section Duration: 1 hour, 19 minutes
Bri explains what an AI agent actually is and how it differs from a reasoning LLM. Agents are a system of connected parts, and you give up more control as systems become more flexible.
Bri shows how agents use tools to interact with the outside world. She covers how tools are described to the LLM, why clear metadata matters, and why too many tools can hurt an agent's performance.
Bri introduces the Model Context Protocol (MCP), a standard for connecting LLMs to tools and APIs. She also covers skills, which are bundles of instructions that load only when needed so they don't use up valuable context space.
Bri walks through Retrieval-Augmented Generation (RAG) and how it gives agents a form of external memory. She explains how documents are chunked, embedded, and searched so the model only sees the information that's relevant to a question.
Bri looks at the challenge of fitting everything an agent needs into a limited context window. She covers techniques like reranking, context compression, and Maximal Marginal Relevance, along with the costs and reliability concerns that come with them.
Bri explains how agents handle short-term and long-term memory, even though LLMs forget everything after each response. She covers working memory along with semantic, episodic, and procedural memory, and how agents retrieve and save information over time.
Bri covers how agents plan and reflect on their work. She explains the difference between plan-then-execute and ReAct approaches and shows how methods like self-refine and Reflexion help agents improve their results.
Non-Agent Workflows
Section Duration: 45 minutes
Bri explains what a workflow is and how it differs from an agent. She introduces prompt chaining, where each LLM call feeds the next, and discusses its benefits for accuracy and debugging as well as its cost in added latency.
Bri leads a hands-on lesson where you build a prompt chaining workflow in JavaScript. She demonstrates how to structure the code, validate outputs between steps, and stop early to avoid wasting LLM calls.
Bri shows how routing workflows classify user input and send it down a single specialized path. She explains how this approach saves cost and time compared to using one large prompt for everything.
Bri covers three more workflow patterns: parallelization, evaluator optimizer, and orchestrator workers. She explains when to run calls at the same time, when to use a feedback loop between LLMs, and when a central LLM should hand out tasks to others.
Bri wraps up the workflow section by showing that these patterns are built from basic programming tools like functions, switch statements, and if statements. She explains how to keep context focused, control cost, and handle errors so users get honest messages instead of bad answers.
Single-Agent Systems
Section Duration: 41 minutes
Bri introduces the key parts of a single-agent system, including the model, tools, instructions, and stopping conditions. She also gives practical advice on picking and maintaining models and designing tools that agents can use reliably.
Bri explains the ReAct agent, which cycles through thinking, acting, and observing until it finishes a task. She shows how it differs from a fixed workflow and how it decides its own steps and tools.
Bri discusses the plan and execute agent, which makes a full plan up front and then follows it step by step. She compares it to ReAct and explains when its lower cost and simplicity make it the better choice.
Bri covers reflection and self-refine in single agents. She explains how an agent can improve its answers using outside feedback or its own critique, and how these ideas can be combined with ReAct.
Bri introduces CodeAct, where an agent writes and runs code instead of making JSON tool calls. She covers how this speeds up complex tasks and why it requires a secure sandbox.
Bri looks at how a single-agent system holds up in the career advisor example. She highlights its strengths in adaptability, its weaknesses in context, reliability, and cost, and how to protect against prompt injection.
Multi-Agent Systems
Section Duration: 1 hour, 20 minutes
Bri introduces multi-agent systems and starts with the sequential pattern, where agents pass work down a chain. She explains how it improves context management and keeps costs low, but can compound errors and add latency.
Bri builds a sequential multi-agent workflow in JavaScript using a career picker agent and a path advisor agent. She shows how an orchestrator passes small handoff objects between agents and uses validation gates to catch errors.
Bri explains how parallel multi-agent systems split work across several agents at once. She describes the difference between sectioning and voting, how an aggregator combines results, and why this approach is faster but more expensive.
Bri covers the supervisor pattern, where one main agent breaks a task into pieces and assigns them to specialized sub-agents. She discusses where it works well, where it gets costly, and why it can be too much for simpler problems.
Bri discusses the dispatcher pattern, which uses a classifier to send each request to the right specialized agent. She explains how it saves money at scale and why a misrouted request is hard to recover from.
Bri covers the evaluator optimizer pattern, where one agent creates solutions and another critiques them in a loop. She emphasizes why stop conditions and concrete feedback, like test results, are important, and how to keep context from growing too large.
Bri explains peer-to-peer multi-agent systems, where agents talk to each other directly with no central coordinator. She describes why this approach is flexible but chaotic, hard to debug, and usually a last resort.
Bri steps back to look at the overall pros and cons of multi-agent systems. She weighs the benefits of specialization and swappable agents against the challenges of debugging, trust between agents, and use in high-stakes field
Bri shows how to build agents that improve themselves by adding reflection steps based on concrete feedback. She also offers guidance on choosing between workflows, single agents, and multi-agent systems, starting simple and testing for your own use case.
Wrapping Up
Section Duration: 10 minutes
Bri closes out the course by reviewing design patterns for self-improving agents and how to choose the right architecture. She revisits the trade-offs among reliability, cost, and context and offers advice on testing and experimenting with your own systems.
Earn a Completion Certificate
After completing this course, you'll receive a certificate of completion that serves as proof of your achievement, showcasing your expertise, and commitment to professional development. You can easily share this certificate on your LinkedIn profile to highlight your new skills and demonstrate continuous learning to potential employers and professional connections.
