Building AI Agents From Scratch: An Honest

There's a particular genre of AI tutorial that promises to demystify everything, then spends two hours explaining that neural networks are "kind of like neurons in the brain." This three-hour course from KodeKloud, published on freeCodeCamp, is not that. It's attempting something more structurally interesting — and mostly pulling it off.

The course is taught by Bumshad Manhatt, and it builds toward a full dissection of OpenClaw, an open-source AI agent that runs on your own device and talks to you through WhatsApp, Telegram, Slack, and similar messaging channels. That destination matters. A lot of beginner AI content floats free of any real codebase, explaining concepts in the abstract. Using OpenClaw as the throughline gives the course something to be accountable to. The architectural choices have to actually exist somewhere you can look at.

The Conceptual Foundation Actually Earns Its Screentime

The early sections cover transformers, tokens, and context windows — the stuff you'd normally skim. But Manhatt structures it as a sequence of practical constraints rather than background reading, and that changes how it lands.

Tokens, for instance, get explained not as a technical curiosity but as the thing that determines your costs, your speed limits, and the boundaries of what the agent can remember at once. The course walks through how a single agent turn — system prompt, tool definitions, conversation history, tool results, intermediate reasoning — can burn through roughly 23,000 tokens before the model even generates a response. That's not theory. That's the engineering problem you're going to run into.

The context window gets similar treatment. The model's working memory — "more like a whiteboard than a notebook," as Manhatt puts it — has a hard ceiling, and everything outside it doesn't exist to the model. This is why ChatGPT sometimes seems to forget things you said earlier in a long conversation. Not a bug, not a failure mode. The messages fell outside the window. Knowing that changes how you build.

Temperature gets a clean practical framework too: zero for data extraction and classification, 0 to 0.2 for code generation, 0.5 to 0.7 for general conversation, lower generally for agents because "you want reliable decisions, not creative ones." The course demonstrates this live by calling the same prompt multiple times at different temperature settings — same input, wildly different outputs at 1.5, identical outputs at 0. Theory confirmed by running two lines of Python.

The Workflow vs. Agent Distinction Is Doing Real Work

Here's where the course earns its keep over the bloated competition. Most "AI agent" content glosses over the fact that most problems don't need an agent. Manhatt is unusually direct about this: "Find the simplest solution possible and only increase complexity when needed."

The distinction he draws is precise and worth sitting with. A workflow is a system where the developer defines the steps in advance — the LLM handles each step, but the sequence is in your code. An agent is a system where the LLM decides its own next steps based on what it discovers. That's not just a technical difference. It's a difference in who's responsible for what happens, and what you can realistically debug.

He offers a four-question test for deciding which to build: Can I define all possible paths in advance? Does the LLM need to make decisions about next steps? Is this a repeatable task? Does cost need to be controlled? Run through those honestly and you'll usually find the answer is "workflow," which is the correct answer more often than AI hype would have you believe.

The agent section then builds on this foundation rather than ignoring it. The core agent architecture — model, tools, memory, orchestration loop, system prompt — gets introduced through a fictional agent named Zippy, who evolves from a solo general assistant into an orchestrator managing a multi-agent system including a research specialist (Savvy), a memory agent, and a coding agent. The structure is pedagogically sound: introduce one piece, show its limits, introduce the next piece to address those limits.

The Production Layer Is Where It Gets Interesting

The OpenClaw case study in the final section is the course's actual payload. By the time Manhatt walks through the codebase, the abstract concepts have enough concrete context that the architectural decisions make sense rather than just being things to memorize.

OpenClaw handles multi-provider model support — Claude, GPT, Gemini — with automatic fallback if one goes down. Its memory system uses session history with compression when the context window fills up. The orchestration layer enforces guardrails: maximum iterations, context compression, model fallback. The system prompt is a 19-section programmatically assembled file. That last detail is worth pausing on — the thing most beginners treat as a simple text field is, in a production agent, an engineering artifact.

The course also covers terrain that most beginner content pretends doesn't exist: testing non-deterministic agents, observability and performance metrics, agent security. "What's everyone's concern regarding OpenClaw's security challenges?" Manhatt asks in the intro. "Is it real? What caused it?" That's not a rhetorical question — the final section actually engages with it.

Testing non-deterministic systems is a genuinely unsolved problem, and the course introduces the concept of LLM-as-a-judge evaluations — using another model to assess whether the agent's output meets quality criteria. It's not a complete solution to a hard problem, but naming the problem correctly is a start.

What the Course Doesn't Fully Reckon With

Neutrality requires noting the gaps. The course covers prompt engineering and includes the practical observation that positive instructions — "write in paragraphs" rather than "don't use bullet points" — reliably outperform their negative equivalents. That's useful. But the mechanistic why is left unexplored, which is probably the right call: the research on how transformers process negation is still genuinely contested, and confident-sounding causal explanations would be doing learners a disservice.

More substantively: the course uses KodeKloud's own lab infrastructure, complete with pre-loaded API keys and sandboxed environments. This is framed as a feature — "no unexpected charges" — and for a beginner course, it probably is. But it also means learners are insulated from the operational reality of managing API keys, handling billing limits, and dealing with rate errors in their own infrastructure. Those are skills you'll need the moment you graduate to building something real.

The multi-agent architecture section introduces patterns from Anthropic's and Google's production systems — orchestrator-worker models, generator-evaluator loops — but the treatment is necessarily surface-level in a three-hour beginner course. The course points at the territory; mapping it is your problem.

The Open Source Angle

OpenClaw's choice as a case study isn't incidental. There's a reasonable argument that open-source agents — running on your own hardware, using your own credentials, auditable end to end — represent a different threat model than cloud-hosted AI services. Manhatt gestures at this when discussing the security section, though the course doesn't fully develop the political or privacy dimensions of self-hosted agents versus managed ones.

The course also frames Anthropic's formulation of what agents are — "LLMs using tools based on environmental feedback in a loop" — as a kind of settled definition. It's clean and useful for learning purposes. But the boundaries of that definition are actively contested in the research community, where "agent" gets applied to systems ranging from a while loop calling an API to fully autonomous systems making consequential real-world decisions. The distinction matters for how you think about safety and oversight.

These aren't criticisms of the course so much as the open questions it leaves you holding. Which is, arguably, the appropriate output of a good beginner course: a working mental model and a clear view of what you don't yet know.

The course is available free on freeCodeCamp's YouTube channel, with paid lab access through KodeKloud.

By Dev Kapoor, Open Source & Developer Communities Correspondent, Buzzrag