Build AI Agents Without the Magic
Frameworks hide the hard parts until they break. Build memory, tool calling, and autonomous loops from scratch with pure Python in 10 hours.
What You Will Learn
- ✓Build agents from scratch — understand every line, no framework required
- ✓Give your agents memory, tools, and the ability to make decisions
- ✓Design loops with safety limits so agents don't run forever or go rogue
- ✓Debug agent failures because you understand exactly how they work
- ✓Ship a complete agent you can extend for your own projects
Who Is This For
- Backend developers — You want to ship AI features but frameworks feel like black boxes you can't debug.
- AI/ML engineers — You use LangChain daily but couldn't build an agent without it. That bothers you.
- Technical leads — Your team is evaluating agent frameworks and you need to make an informed decision.
Curriculum
Agent Fundamentals
4 lessons
ReAct Pattern
4 lessons
Tool Integration
4 lessons
Agent Loop
4 lessons
Memory Basics
4 lessons
AI Workflows
4 lessons
Error Handling
4 lessons
Human-in-the-Loop
3 lessons
Practical Agent — Capstone
4 lessons
Frequently Asked Questions
- Do I need LangChain experience?
- Nope. We build from scratch. Pure Python + LiteLLM.
- What LLM provider do I need?
- Anything that supports function calling. LiteLLM handles OpenAI, Anthropic, Google AI Studio (free), and more.
- How long does the workshop take?
- About 10 hours. Most people finish in 2-3 sessions over a weekend.
- Is the code production-ready?
- Yes. These are the same patterns running in production agent systems.
Build AI Agents Without the Magic
Build AI agents with pure Python. No LangChain. No CrewAI. No magic.
Chosen by engineers who want to understand the engine
The Framework Trap. Sound familiar?
LangChain Spaghetti
You've stitched together 8 different AgentExecutors and RouterChains, but you have absolutely no idea what prompt is actually being sent to the LLM.
Silent Failures
The agent just stopped working in production. Because the framework hides the core loop, debugging feels like guessing.
Unpredictable Loops
Your agent occasionally decides to hallucinate 40 tool calls in a row, draining your API budget and returning garbage.
Black Box Architecture
You're asked to explain the system design to the security team, but you can't, because the framework abstractions are a black box.
The fix isn't another framework update.
It's understanding the primitives.
Senior engineers aren't better because they know more syntax. They're better because they've:
Once you build the primitives yourself, the magic disappears. You gain complete control.
Pure Python.
Complete Control.
We tear away the abstractions. You will build the core loops, memory systems, and tool dispatchers using nothing but pure Python and LiteLLM. No magic allowed.
The Architecture Build Path
From a stateless API call to an autonomous Office Manager.
State & Memory
You build a stateful loop that persists conversation history and handles context window limits.
Tool Integration
You write raw JSON schemas and dynamic dispatchers so your LLM can execute Python functions.
The ReAct Loop
You implement the Thought-Action-Observation loop that gives your agent reasoning capabilities.
Safety & HITL
You add hard limits, self-correction, and Human-in-the-Loop approval gates for production safety.
Build an Agent from Scratch. No Frameworks. No Magic.
Agent Fundamentals
Understand the difference between stateless LLMs and stateful agents. Build your first agent with conversation memory using pure Python.
Welcome & Setup
Get introduced to the workshop, understand what you will build, and set up your development environment
From Stateless to Stateful
Discover why LLMs have no memory and understand the fundamental difference between stateless API calls and stateful agents
Building Your First Agent
Build a SimpleAgent class that maintains conversation memory and creates the illusion of a stateful AI
Agent Fundamentals Mastery
Test your understanding of stateless vs stateful, agent memory, and the SimpleAgent pattern
ReAct Pattern
Learn the Thought-Action-Observation reasoning loop that enables agents to use tools and solve multi-step problems.
The Reasoning Gap
Discover why LLMs cannot do math or access real-time data, and why agents need external tools
Think, Act, Observe
Learn the ReAct pattern: Thought-Action-Observation cycle that enables LLMs to use external tools
Building the ReAct Loop
Implement the complete ReAct agent loop with multi-step reasoning and tool execution
ReAct Mastery
Test your understanding of the ReAct pattern with ordering exercises and a checkpoint quiz
Tool Integration
Replace fragile regex parsing with native function calling using JSON schemas for reliable tool integration.
The Problem with Regex
Understand why regex-based tool parsing is unreliable and why we need structured function calling
JSON Tool Schemas
Define tool interfaces using JSON schemas so the LLM knows what functions are available and how to call them
Native Function Calling
Implement the complete function calling flow: pass schemas, receive tool_calls, execute functions, and return results
Tool Integration Mastery
Test your understanding of JSON schemas, function calling flow, and tool_call_id linking
Agent Loop
Build an autonomous agent that chains multiple tool calls in a while loop with safety limits.
Beyond Single Steps
Understand why agents need loops to handle multi-step tasks autonomously
The Autonomous Loop
Build an Agent class with a while loop that continues calling tools until the task is complete
State Propagation
Understand how tool results flow through the agent loop and inform each subsequent decision
Agent Loop Mastery
Verify your understanding of autonomous agent execution with ordering and checkpoint exercises
Memory Basics
Solve context window limits with sliding window and summarization memory strategies.
The Memory Problem
Understand why growing conversation history causes cost and context window issues
Sliding Window Memory
Implement the simplest memory strategy: keep only the last N messages
Summarization Memory
Use the LLM to compress old messages into a summary, preserving key facts while reducing tokens
Memory Mastery
Test your understanding of memory strategies with ordering and checkpoint exercises
AI Workflows
Build modular agent systems with the router pattern for task classification and the chaining pattern for multi-step workflows.
Why Monolithic Agents Fail
Understand why a single agent handling all tasks leads to poor performance and maintainability
The Router Pattern
Build a router that classifies requests and dispatches them to specialized handler agents
The Chaining Pattern
Build multi-step workflows where the output of one step becomes the input to the next
Workflows Mastery
Test your understanding of router and chaining patterns with exercises and a checkpoint
Error Handling
Make agents robust with validation, the reflection pattern for self-correction, and retry loops.
LLM Output is Untrusted
Learn why you should never trust LLM outputs blindly and always validate before executing
Validation Patterns
Build validation functions that check LLM output against your system constraints before execution
Self-Correction with Reflection
Feed validation errors back to the LLM so it can correct its own mistakes in a retry loop
Error Handling Mastery
Test your understanding of validation, reflection, and self-correction patterns
Human-in-the-Loop
Add safety gates and approval workflows so humans can review and approve sensitive agent actions.
Why Agents Need Guardrails
Understand why autonomous agents need human oversight for sensitive actions
Building Approval Gates
Implement approval gates that pause the agent for human review before executing sensitive tools
Human-in-the-Loop Mastery
Understand production HITL patterns and test your knowledge with a checkpoint
Practical Agent — Capstone
Integrate everything you learned into a complete Office Manager agent with memory, tools, loops, error handling, and human-in-the-loop safety.
Designing the Office Manager
Plan the architecture of a production-ready agent that combines all 8 modules of concepts
Building the Agent
Implement the complete OfficeManager class with all integrated patterns
Running the Capstone
Run the complete Office Manager scenario and verify all integrated components work together
Course Celebration
Review key concepts across all modules with flashcards and a timed quiz, then celebrate your achievement
Detailed Curriculum
See every system, every week, in detail before you decide.
Users call APIs. Engineers build systems.
Scripts are easy.
Anyone can copy-paste a LangChain tutorial to summarize an article.
Production agents are hard:
- Design context compaction algorithms
- Implement safe, isolated tool dispatchers
- Build dependable retry and recovery loops
- Architect multi-agent routing systems
Stop trusting abstractions you can't debug. Build the foundation yourself.
Learn From Someone Who Actually Does This
I am the Head of Engineering at Jobbatical (EU Tech), with 8+ years of leadership and 15+ years of total experience in the software industry.
"Most engineers are not blocked by ability, but by lack of real system ownership."
This accelerator exists to give you what most jobs never will.
Guest Sessions From Engineers at
Live sessions on System Design, Career Growth, and Interview Preparation.
Get Full Access
Invest in your career. It pays back 100x.
Frequently Asked Questions
Do I need LangChain experience?
What LLM provider do I need?
How long does the workshop take?
Is the code production-ready?
10 hours from now:
Stop trusting magic. Start building engineering systems.