We're officially 4 days away from kicking off the course I've been hinting about for weeks: Grokking Agents in Production, the 6-week course I've built together with Antonio Zarauz Moreno and Luis Serrano.
The Welcoming Session is this Monday, June 1st, and before we get started, I wanted to take a moment to reflect on why a course like this even needs to exist in 2026… and give you a proper sneak peek of what we'll be covering during the first three weeks (I don't want to spoil the rest 😉).
🎁 Hey, premium subscribers — there's a discount with your name on it ($499 instead of the regular price). Just DM me and I'll send the coupon.
Why this course (and why now)
If you've been on AI Twitter / LinkedIn for the last year, you’ve probably noticed something a bit unsettling:
There are a million tutorials showing you how to glue together a LangChain agent in 30 lines of code.
There are plenty of theory-heavy resources explaining transformers, attention, and the latest paper from DeepMind.
And then… there's a massive gap in the middle.
That gap is where real engineers live. The people who actually have to take an idea, turn it into a working agent, and then ship it to a real cloud environment with real users, real costs, and real failure modes.
That's exactly what Grokking Agents in Production is built for. We're combining three things that almost never come together in the same course:
Foundations — actually understanding what's happening under the hood (workflows vs agents, retrieval, embeddings, OCR, state).
Hands-on labs — building everything from scratch before touching any framework, so you know exactly what the framework is doing for you.
Real deployments to GCP — not localhost demos. Actual Cloud Run services, Cloud SQL for state, Qdrant Cloud for vectors, Pub/Sub for event-driven pipelines, etc.
The goal isn't to make you "an AI enthusiast who has played with agents." The goal is to make you an AI Systems Engineer.
Alright, enough manifesto. Let's talk about what's actually coming.
Week 0: Getting Started
Week 0 is the warm-up. No content yet — just the setup videos you need so that nothing is in your way once we hit Week 1. Three things to take care of:
🔑 Cohere API Keys
We're extremely lucky to share that Cohere has provided free credits for all of our students. In Week 0, we'll walk you through how to claim them and generate the API key we’ll be using throughout the entire course.
🟣 Qdrant Cloud
We'll explore Qdrant Cloud, spin up your own free cluster, and play around with some simple interactions so you’re comfortable with the interface before we start using it for real.
☁️ GCP
GCP is one of the main characters of this story. We'll walk you through installing the gcloud CLI (we’ll use it constantly), give you a tour of the services we’ll be touching, and — most importantly — show you how to claim your free GCP credits.
Week 1: Workflows vs Agents
This is where things actually start. The big question we tackle in Week 1:
What's the difference between an LLM Workflow and an Autonomous Agent?
Here's how we approach it:
Luis and I team up. Luis will explain the different LLM workflows — routing, parallelization, evaluator-optimizer, and friends — in his unique, ridiculously clear style. Then I'll take over and show you how to implement every single one of them from scratch, using nothing but raw Cohere API calls.
The final from-scratch lab is the cherry on top: we'll build a ReAct Agent from scratch, so by the end of the week you'll fully understand what’s happening under the hood before we ever touch a framework.
And then… it's framework time. We'll move to the agentic framework we'll be using for all of our cloud deployments: Google ADK.
In the last lab of Week 1, I'll teach you the basics of Google ADK and we'll rebuild the exact same ReAct agent using the framework. You'll see firsthand how much boilerplate disappears once you understand what's actually happening underneath.
And then we deploy 🚢
This is where Grokking Agents really starts to feel different. We'll take that simple ReAct agent built with Google ADK and deploy it to Google Cloud Run. I'll walk you through every line of code and every command, taking you from your local laptop all the way to a running agent on GCP.
By the end of Week 1, you'll have a real agent you can interact with, live on Google Cloud Run.
Oh … and the Sunday after Week 1 wraps, we'll host an Office Hour to cover the week's topics in depth and answer all your questions! (Remember: the Welcoming Session is this Monday, June 1st.)
Week 2: RAG, but actually properly
I don't want to spoil too much, but here's the shape of Week 2:
Luis and I team up again to cover everything you need to know about modern RAG:
Dense retrieval
Sparse retrieval (BM25)
Hybrid retrieval (RRF)
The role of the reranker in modern RAG pipelines
And — as you'd expect by now — we'll implement a RAG pipeline from scratch during the labs. Then we'll level up and implement Agentic RAG using Google ADK, where the tool is in charge of doing the hybrid retrieval and reranking. We'll also cover state persistence using external databases.
Deployments in Week 2 are significantly more interesting. We'll combine local deployment (using Docker Compose) with cloud deployment, orchestrating three services:
Cloud Run → the Google ADK application
Cloud SQL → external state persistence
Qdrant Cloud → dense + sparse embeddings storage (connected to our Cloud Run app via a tool)
This is the kind of architecture you'd actually see in production. And you'll build it yourself!
Week 3: Event-Driven Pipelines
This is the last teaser. I have to leave some room for surprise.
Week 3 focuses on multimodal embeddings, OCR systems, and building an event-driven multimodal embedding pipeline that automatically wires together:
Google Cloud Storage (drop a PDF in a bucket…)
Pub/Sub (…trigger an event…)
Cloud Run (…generate embeddings…)
Qdrant (…and store them, ready to be queried)
Antonio will be taking the lead for this week, showing you the kind of pipeline that turns a side-project agent into something that actually scales.
And that's all you're getting from me on Week 3 😄
Weeks 4, 5 and 6
If Weeks 1–3 take you from "I understand agents" to "I can ship one to GCP", Weeks 4–6 are where things get genuinely fun — and honestly, they're the weeks I'm most excited about teaching.
I'm talking about Agent Evals, Observability, Multi-Agent Systems, MCP, A2A, AgentOps, and more. All of these get covered in the last three weeks of the course — basically the stack of skills that separates a working agent from a system you can actually trust in production.
You've already got the full breakdown on the course page. I'll just say this: if Weeks 1–3 are the foundation, Weeks 4–6 are the part of the course where you stop building agents and start operating them.
🎁 For my Premium subscribers
If you're a premium subscriber of The Neural Maze, you have access to a massive discount: the full course for $499 (instead of the normal price).
To claim it, just DM me and I'll send you the coupon code. That's it.
See you Monday
Super excited for Monday, June 1st — that's when we kick off with the Welcoming Session. Week 0 setup videos will be waiting for you, so you can hit Week 1 running.
If you've been waiting for a course that takes you from "I kinda understand agents" to "I can architect, build, and deploy a production agentic system on GCP" — this is the one.
Let's become real AI Systems Engineers, folks. 💪
Which framework in the course is used ?
Langgraph or lang chain ?