The Practical AI Agents Roadmap

From Python to AI Engineer in 9 hands-on lessons

It’s been over a decade since I completed my degree in Physics (you’re getting old Miguel)

Honestly, a lot has happened since then… if you’d told the Miguel who was studying Hilbert spaces that one day he’d be sending a newsletter about AI, he would’ve laughed.

But even though my work today has nothing to do with Physics, I still carry closely a quote from my favorite physicist, Richard Feynman:

“What I cannot create, I do not understand” ~ Richard P. Feynman

Honestly, I’ve been following this approach since I was very young—and it’s funny, because my very first project for The Neural Maze was a clear example of this philosophy in action.

That project was about implementing, from scratch, the four agentic patterns, back when agents were still just a shiny new concept.

I have to admit that most of what I know about agents, and much of my understanding of agentic architectures, really solidified through that project.

Today, I want to share a series that follows the same hands-on approach, created by my friend Paul Iusztin, whom I had the pleasure of collaborating with during our PhiloAgents course.

Paul has done an amazing job creating nine hands-on lessons that cover the end-to-end fundamentals of building AI agents.

And as with all of Paul’s content, don’t expect hype or shallow explanations—this is a course focused on the concepts and design principles needed to build truly robust agentic architectures.

Without further ado, let’s break down each lesson!

---

---

Lesson 1 - Workflows vs Agents

The course starts by clarifying the key differences between workflows, agents, and hybrid systems.

From there, it explores some of the most common workflow, agent, and hybrid use cases to build the intuition needed to start designing your own AI systems, such as:

• Document summarization workflow

• Coding agents

• Vertical AI agents

• Deep research agents

---

Lesson 2 - Context Engineering

The course continues by making one thing clear:

Prompt engineering alone is no longer enough when building real workflows or agents.

That’s why the second lesson introduces context engineering. Instead of optimizing individual prompts, the focus shifts to designing the AI’s entire information environment.

By dynamically selecting, filtering, and structuring context from memory, databases, and tools, systems stay accurate, efficient, and scalable—even as they grow more powerful.

---

Lesson 3 - Structured Outputs

The course then tackles a fundamental challenge: how to reliably extract structured, trustworthy information from an LLM.

This lesson starts by building everything from scratch to clearly understand what’s happening under the hood, before moving on to more practical, production-ready approaches using popular LLM APIs like Gemini’s GenAI SDK.

Along the way, it covers:

• Implementing structured outputs from scratch using JSON

• Implementing structured outputs from scratch using Pydantic

• Using the Gemini SDK together with Pydantic for robust, real-world setups

---

Lesson 4 - The 5 Workflow Patterns

The course emphasizes a smarter approach: starting with simpler, more controllable patterns before jumping straight into agents.

Before considering agentic systems, it encourages solving problems using five core workflow patterns, all covered in Lesson 4:

• Prompt Chaining

• Parallelization

• Routing

• Orchestrator–Worker

• Evaluator–Optimizer

---

Lesson 5 - Tool Calling From Scratch

The course then takes a step back from frameworks and abstractions to answer a crucial question: how do tools actually work under the hood?

While libraries like LangGraph or AgentSDK make it easy to wire tools into LLMs, optimizing how agents use those tools requires a deeper understanding.

In Lesson 5, the focus is on building tool calling from scratch—learning how to define tools correctly, how many tools an agent should have to avoid confusion, and which types of tools are actually worth using in the first place.

---

Lesson 6 - ReAct & Plan-and-Execute

The course then addresses a common misconception: looping over tools does not automatically make a system an agent.

That approach quickly breaks down in more complex scenarios because it’s missing a critical ingredient … planning.

Planning is what enables the jump from simple workflows to true agents. In this lesson, the focus is on understanding how planning fits into the bigger picture, how it connects to tools and execution loops, and why separating planning from execution matters.

By the end, the lesson introduces the two core planning paradigms that power most agentic systems today: ReAct and Plan-and-Execute.

---

Lesson 7 - ReAct Agents from Scratch

In this lesson, the course walks through their core implementations, helping you learn how to build your own custom ReAct and Plan-and-Execute agents.

---

Lesson 8 - AI Agent’s Memory

In this article, the course explores:

• The four fundamental types of memory for AI agents

• A deep dive into long-term memory: semantic, episodic, and procedural

• The trade-offs between storing memories as plain text, entities, or knowledge graphs

• The complete memory lifecycle, from ingestion to inference

---

Lesson 9 - Multimodal Agents

This final lesson covers how to directly manipulate multimodal data when building AI Agents.

---

So, if you have no plans before New Year, this is the perfect time to dive in and become an Agent master with this course!

And speaking of New Year … on the 31st, I’ll be outlining the next phase (or saga, now that I’m becoming a One Piece nerd) of The Neural Maze: what you can expect heading into 2026.

I’ll also be sending a poll to the premium subscribers, since you’ll be the ones helping decide how this ecosystem should evolve.

Merry Christmas, builders 🎄