New: Roadmaps ordered paths through our cheat sheets and flashcards, so you always know what to study next.
Explore themSee what's new on GitHubFrom your first agent loop to a monitored fleet of production agents.
A 13-step learning path. Follow it in order, or jump to what you need.
This path is for developers who already call LLM APIs and use RAG, and want to go deep on building agents that plan, use tools, and work with each other instead of answering single prompts. Expect about 6 to 10 weeks at a few hours a week, moving from the agent loop and function calling through memory and reasoning, into orchestration frameworks, MCP, multi-agent coordination, and the operations discipline that keeps agents reliable in production. It does not reteach prompting, LLM internals, or RAG basics, and it does not cover model fine-tuning or serving optimization, all of which AI Engineer (LLM Applications) and Generative AI & LLM Engineering already own; this path stays inside the agent layer. By the end you can wire tool-calling agents with structured function calls, orchestrate multi-step workflows in LangGraph, coordinate a crew of collaborating agents, connect them to real systems through MCP, and run the whole fleet under AgentOps monitoring.
Expected: comfortable calling an LLM API and writing prompts, plus a working knowledge of retrieval-augmented generation (see AI Engineer or Generative AI & LLM Engineering for that grounding). Helpful but not required: prior use of an agent framework or MCP.
Start here: run through the think-act-observe loop that turns a chatbot into an agent, no framework or setup needed yet, the mental model every later step assumes you already have.
Give the loop from step 1 something to act on: define a tool's JSON schema so the model can call it, and Anthropic, OpenAI, and Gemini formats stop looking like three different problems.
This is where it clicks and where most builders get stuck: holding state across a dozen tool calls without blowing the context window, expect to revisit this table more than once as your agents get longer.
You can wire tool calls into an agent loop and give it working memory so it doesn't forget its own plan mid-task. Next up: picking a framework instead of building the loop by hand.
Finish this section to unlock.
+100 XP
Before picking a library, see the whole map: graph-based engines, role-based crews, and vendor SDKs solve the memory and tool problems from steps 2 and 3 in different ways, and the choice shapes everything downstream.
Take the graph-based option from step 4 and actually build one: nodes, conditional edges, and checkpointing turn your agent loop into a workflow you can pause, inspect, and resume, the choice teams reach for when they need an auditable decision trail.
Swap the explicit graph from step 5 for a role-based crew when speed matters more than control: give each agent a persistent identity and let CrewAI's process types get a prototype in front of stakeholders in days.
Take this if you're working in an Azure-heavy stack or maintaining an existing deployment: AutoGen frames collaboration as structured conversation between actors rather than the crew roles from step 6, though new Microsoft-stack builds now start on its successor, the Agent Framework.
You can stand up a stateful LangGraph workflow and a role-based CrewAI crew, and know which one fits which job; a few minutes of due flashcards keeps chapter 1's tool-calling habits fresh while you build on them. Next up: letting those agents reach outside their own process.
Finish this section to unlock.
+100 XP
Stop writing a custom integration for every API: MCP standardizes how the tools from step 2 and the frameworks from steps 5 and 6 reach external systems through one protocol.
Reach for this if you'd rather wire in an existing server than build your own: browser control, databases, and dev tools already have MCP servers covering the protocol from step 8.
Aim here if your agent needs to click through a GUI, not just call APIs: screenshot grounding and sandboxed execution keep a computer-use agent from the prompt-injection risks step 8's tool contracts don't fully cover.
You can expose real tools and data to an agent through MCP instead of hand-rolling every integration, and you know what it takes to run a GUI-driving agent safely. Next up: proving the whole thing holds up under real evaluation and guardrails.
Finish this section to unlock.
+100 XP
Before you trust any workflow from steps 5 through 10, score it against something other than your own read of the transcript: agent-specific metrics catch the silent failures a single demo run hides.
An agent that calls tools and reaches external systems through step 8's protocol is also one that can be tricked into misusing both: layer input, execution, and output guardrails before anything ships.
Pull the framework choice from step 4, the tool and MCP wiring from steps 2 and 8, and the evaluation and guardrails from steps 11 and 12 into one operating discipline: deployment, cost, drift, and incident response for a fleet of agents, not a single script.
You can take an agent from a single tool call to a monitored, multi-agent system running in production, evaluated, guarded, and observed the whole way. This badge marks that you can ship agents a team can actually trust, not just a demo that works once.
Finish this section to unlock.
+100 XP
Finish every required step, at least 70% of them genuinely done (not skipped), to earn this badge and 500 XP.