This roadmap is for engineers who can already call an LLM API and now need to design the whole system: which pieces to use, how to connect them, and when a simple workflow beats an agent. It does not cover training models.
It is built around free resources. Where a paid option exists, it sits underneath as an alternative, and you never need both. Some free courses charge only for the certificate, so each step says which is which.
Realistic timeline: 4 months at 5–6 hours a week. End every phase with a GitHub project.
Phase 1 — Mental Model (Month 1)
Before you pick a framework, learn the difference between a workflow and an agent. A workflow follows a path your code decides. An agent decides its own next step. Agents cost more and are harder to debug, so most tasks only need a good workflow.
Workflows vs agents
The four patterns almost every AI system is built from: prompt chaining, routing, parallelization, and agents.
Phase 1 project
Pick a task you know, such as summarising a support ticket and drafting a reply. Design it twice on paper, once as a workflow and once as an agent. Write half a page on which one you would ship and why.
Phase 2 — Agentic Design Patterns (Month 1-2)
Now learn what makes an agent useful: reflection (checking its own answer), tool use, planning, and multi-agent collaboration.
Agent patterns in practice
The free course covers agent fundamentals, tools, and three frameworks. The paid one teaches the four patterns in plain Python, with no framework in the way.
- Main (free): AI Agents Course, Units 1–2 (Hugging Face). A certificate is included if you finish the assignments.
- Alternative (paid): Agentic AI by Andrew Ng (DeepLearning.AI). Needs a Pro plan for the labs and the certificate.
Phase 2 project
Build a "research helper" that searches a topic, writes a short summary, then reviews and fixes its own summary. Log every step it takes.
Phase 3 — Orchestration (Month 2)
Once you have several steps and several agents, a pile of if statements gets messy. An orchestration framework controls the flow for you: who runs next, what gets remembered, and when a human steps in. Start with LangGraph, then look at one other framework to see a different way of thinking about the same problem.
LangGraph (start here)
LangGraph lets you draw the system as a graph: each step is a node and each decision is an arrow. You also get memory, and the ability to pause and resume.
- Main (free): Introduction to LangGraph (LangChain Academy)
- Alternative (paid, with certificate): Multi-Agent Systems with LangGraph (DataCamp, about 2h45). It covers swarm and supervisor designs.
Other orchestration frameworks (pick one to compare)
Each framework answers the same question in its own way. You do not need all of them. Pick one, rebuild your Phase 2 project in it, and notice what feels easier and what feels harder.
- CrewAI: a team of agents with roles. You give each agent a role, a goal, and tools, and the crew works together. Multi AI Agent Systems with crewAI (DeepLearning.AI, about 3 hours). Free to watch; the accomplishment needs a Pro plan.
- Microsoft Agent Framework: graphs plus enterprise features. It is the successor to AutoGen and Semantic Kernel, built by the same teams, and it adds workflows that give you explicit control over the order agents run in. AutoGen is now in maintenance mode, and Microsoft recommends the new framework for new projects. Microsoft Agent Framework overview (Microsoft Learn)
- Google ADK: a hierarchy of agents. A parent agent delegates to sub-agents, with built-in tracing and evaluation. Build an agent team (ADK tutorials)
- OpenAI Agents SDK: handoffs or a manager. Two simple patterns: a manager that calls specialist agents as tools, or a triage agent that hands the conversation to a specialist. OpenAI Agents SDK quickstart
- LlamaIndex: workflows built around your data. It offers a built-in multi-agent workflow with handoffs, an orchestrator pattern, and a do-it-yourself planner. Multi-agent patterns in LlamaIndex
Phase 3 project
Rebuild the research helper as a supervisor graph in LangGraph. One agent searches, one writes, one reviews. Then rebuild the same flow in one other framework from the list, and write half a page comparing them: how you control the order, how you debug, and which one you would pick for a real project.
Phase 4 — RAG Architecture (Month 3)
RAG gives the model your own documents so it answers from facts instead of guessing. The model call is the easy part. The hard parts come before it: how you split documents, which vector database you use, how you retrieve, and how you check the answers.
Retrieval you can trust
- Main (free): Building and Evaluating Advanced RAG (DeepLearning.AI). The certificate needs a Pro plan.
- Alternative (paid): Retrieval Augmented Generation (DeepLearning.AI, the full course). Only the first module is a free preview; the certificate needs Pro.
Phase 4 project
Build a RAG system over documents in Arabic, English, or both. Write 20 test questions with known answers and measure how many your system gets right.
Phase 5 — Protocols (Month 3)
Two open standards connect AI systems, and they are easy to mix up. MCP connects one agent to its tools and data. A2A connects one agent to another agent. They do different jobs and work well together.
MCP: agent to tools
You build an MCP server in Python and learn its three building blocks: tools, resources, and prompts.
A2A: agent to agent
The official docs are the main source here. The short course is a hands-on version if you prefer video.
- Main (free): Agent2Agent (A2A) Protocol documentation
- Alternative (video, free to watch): A2A: The Agent2Agent Protocol (DeepLearning.AI, 1h27). Quizzes and projects need a Pro plan.
Phase 5 project
Wrap one of your own tools (a database lookup or a file search) as an MCP server and connect your Phase 3 agent to it. Then write a one-page design note: if two teams each owned one agent, where would A2A fit?
Phase 6 — Production-Ready (Month 4)
A normal bug crashes your program. An AI bug gives a confident wrong answer, and nobody notices for a week. Build three habits: trace every step, evaluate on a fixed test set, and monitor after launch.
Evaluation, tracing, and monitoring
- Main (free): Building Reliable Agents (LangChain Academy)
- Alternative: Evaluating AI Agents (DeepLearning.AI with Arize). It covers tracing, evaluating, and monitoring.
Phase 6 project
Capstone. Take your best system from Phases 3–5. Add tracing, a fixed evaluation set of at least 30 questions, a Dockerfile, and a README with an architecture diagram. Push it to GitHub.
YouTube Channels You Should Follow
Free Newsletters & Blogs
Honest Advice
- Build projects, don't just watch videos. A repo with a trace and a test set says more than a certificate.
- Start with a workflow. If you can write the steps in advance, write them. Use an agent only when you cannot.
- Pick one framework and finish a project. Frameworks change fast, and the patterns underneath them do not.
- Write your test questions early. "It looks right" is not a test. Keep your Phase 4 questions and reuse them.
- Test with real Arabic from day one. Retrieval, chunking, and evaluation behave differently in Arabic.
- Keep designs simple. Teams here are often small, and a design a teammate can read in an afternoon beats a clever one.
- Do not mix up MCP and A2A. MCP is agent-to-tool. A2A is agent-to-agent.