Bootcamp · Part 1 · Student notes
Before writing a single line of code — what LangChain actually is, how it relates to LangGraph / LangSmith / Deep Agents, and why the framework looks the way it does today.
Skipping this step is the single biggest reason people get confused later — they start writing code without a mental map of where that code fits.
This page has no code to run. Treat it as the map you’ll keep referring back to for the rest of the course.
If you’ve searched anything about LangChain online, you’ve probably already run into posts titled something like “LangChain vs LangGraph vs LangSmith — Which One Should I Use?” That confusion exists for a simple reason: the LangChain team builds four different products that share the same first word, but solve four completely different problems.
None of these four tools are competitors. You don’t “pick one.” You use as many of them as your project actually needs.
Foundation
A low-level orchestration framework — the engine underneath everything else. Fine-grained control over flow: branching, loops, persistence (state between steps), and durable execution (pause / resume long-running work).
Most people building agents will never touch LangGraph directly at first — LangChain is built to hide that complexity until you need it.
This course
Provides create_agent: a highly configurable harness for building
agents quickly. Built on top of LangGraph, so you get durable execution, persistence,
and human-in-the-loop without learning LangGraph’s internals first.
This is the product the entire course is built around, starting from Part 2.
Batteries included
A layer on top of LangChain’s create_agent. Where create_agent gives
you a customizable but empty harness, Deep Agents ships planning tools, a virtual filesystem,
and sub-agent spawning — pre-wired.
Reach for it when you want to skip assembling those capabilities yourself. Covered properly in a later module.
Observability
Not something you “build an agent with.” It’s an observability and evaluation platform — it watches agents (and, via OpenTelemetry, almost anything else) and shows exactly what happened during a run.
With a normal Python script, if something goes wrong you read the stack trace and the code. An agent is different — it decides what to do at runtime, based on a conversation with itself (calling tools, reasoning about results, calling more tools). You cannot “read the code” to know what an agent actually did on a specific run, because the code only describes what it could do, not what it did on that call.
LangSmith records a trace — a complete, timestamped record of every model call, every tool call, and every decision, in order. When something goes wrong, you don’t guess. You open the trace and read exactly what happened.
LANGSMITH_TRACING=true
LANGSMITH_API_KEY=your-key-here“LangChain’s agents are built on top of LangGraph. This allows us to take advantage of LangGraph’s durable execution, human-in-the-loop support, persistence, and more.” — official docs
The official LangChain documentation opens with this framing — worth memorizing:
An agent is a model calling tools in a loop until a given task is complete.
A harness is everything around that loop.
The model is the raw language model — GPT, Claude, Gemini, whatever you plug in. It is extraordinarily capable at reasoning, but on its own it has no ability to actually do anything. It doesn’t know what tools exist. It has no instructions on how to behave in your application. It can’t check anything outside of what it already knows.
The harness is everything that turns that raw capability into something useful:
create_agent is that harness. When you call
create_agent(model=..., tools=..., system_prompt=...), you are configuring the
harness around a model — not building a new model.
create_agent gives you a pre-configured, highly customizable harness.
This is what the rest of this course uses.
create_deep_agent gives you a harness that already includes planning,
a filesystem, and sub-agent spawning, pre-wired.
All three stand on the same LangGraph engine. You are not “avoiding” LangGraph by using LangChain — you’re standing on it; you just don’t need to look at it directly for most of this course.
Online tutorials span several years, and a huge amount is outdated — not because it was wrong when written, but because the framework went through a genuine architectural overhaul. Knowing the timeline lets you judge whether something you’re reading is current.
LangChain launches. Two core ideas: LLM abstractions, and “Chains” — predetermined sequences of computation (e.g. a RAG chain: retrieve documents, then generate an answer).
First general-purpose agents, based on the ReAct paper (Reasoning + Acting). The model generates JSON representing a tool call, and LangChain parses that JSON by hand.
LangGraph is released — the low-level orchestration layer that had been missing. Adds streaming, durable execution, short-term memory, and human-in-the-loop support.
LangGraph becomes the preferred way to build anything beyond a single model call. Most of the old LangChain chains and agents are marked deprecated.
One unified agent abstraction, built on LangGraph, replaces essentially everything that
came before. Old code still runs only if you deliberately install the separate
langchain-classic package.
Deep Agents is released — the batteries-included harness described above.
AgentExecutor and functions
like initialize_agent do. That approach didn’t scale well, which is why LangGraph
was built. In October 2025, everything unified into the single create_agent
abstraction this course teaches.
AgentExecutor, it is almost certainly
outdated — not wrong at the time, just written before the ground moved. Importing
AgentExecutor from langchain raises an ImportError because
that functionality now lives in langchain-classic, kept apart so the main v1.0
package stays clean.
Before moving to Part 2, you should be able to answer these without looking back. Click a question to reveal the answer.
create_agent — or Deep Agents if you want batteries-included.AgentExecutor was the pre-v1.0 approach; anything using it was written before
October 2025’s unification into create_agent.
Tip: try answering aloud before opening each answer.
Part 2 — Environment Setup
That’s where we actually start writing code.