How this track works
Ten sessions, one growing artifact: DataDesk, a data-team assistant that starts tonight as 40 lines of Python and graduates in session b10 with memory, approval gates, retrieval over your docs, a colleague agent, and an eval suite. Every session upgrades the same code. Two LLM paths run through the whole track - the Claude API for capability, a local Ollama model for zero-cost privacy - and switching between them is one line, which is itself the first thing LangChain has to prove to you.
What an agent actually is 6 min live
Strip the hype and an agent is a while-loop: a model, a list of tools, and a loop that keeps calling the model until it stops asking to use tools. Everything else - state, memory, approval gates, multi-agent - is engineering around that loop. Tonight you write the loop yourself.
LiveWorkflow or agent - the definition that pays rent3 min▶
Anthropic's engineering team drew the line the whole industry now uses. A workflow is LLM steps orchestrated through predefined code paths - YOU wrote the flowchart, the model fills in text. An agent is a system where the model dynamically directs its own process and tool use - IT decides the steps.
- Workflow example: "summarize ticket → classify → route" - three fixed steps, model inside each.
- Agent example: "resolve this ticket" - the model decides whether to search docs, query the database, escalate, or answer.
- The rule that saves money: agents trade latency and cost for flexibility. Start with a single LLM call; move to a workflow when steps are predictable; reach for an agent only when you genuinely cannot predict the steps. Add complexity only when it demonstrably improves outcomes.
The invoice pipeline that did not need an agent. A finance team scoped an "invoice agent". On inspection: every invoice takes the same five steps. They shipped a workflow - five fixed nodes, model in two of them - in a week. Same team's contract-review problem, where every contract needs different digging, became their first real agent. Right tool, both times.
Self-studyThe autonomy ladder - where costs and risks climb2 min read▶
Rules/RPA → single LLM call → workflow → agent → multi-agent. Each rung up buys flexibility and costs predictability, auditability, latency, and tokens. McKinsey's teams, after 50+ agentic builds, put it bluntly: agents aren't always the answer, and low-variance standardized processes are better served by rules or plain automation. The leader track's session a1 teaches this ladder to your boss - useful to know what they are being told.
| Rung | Right when | Watch out |
|---|---|---|
| Single LLM call | One transformation: summarize, draft, classify | Usually enough - start here |
| Workflow | Predictable multi-step, same shape every time | Hidden variance breaks fixed paths |
| Agent | Steps genuinely unpredictable, tools needed | Cost, latency, compounding errors |
| Multi-agent | Distinct specialisms or parallel workstreams | Cascading errors - session b9 |
The LangChain stack, 2026 edition 6 min live
"LangChain" is four things wearing one trench coat. Getting the layers straight now means never being confused by a tutorial, a blog post, or a rename again.
LiveWhat 1.0 changed - and why this course exists now3 min▶
For three years LangChain was famous for two things: being everywhere, and breaking your code every few months. October 2025 changed the deal:
- One blessed entry point:
create_agentreplaced the zoo of AgentExecutor, create_react_agent and friends. One way to build an agent, documented everywhere. - The pipe chains are gone from the main package. LCEL chains, legacy retrievers and the hub moved to
langchain-classic. If a tutorial showsprompt | llm | parser, it is teaching history. - A stability promise: no breaking changes until 2.0. The churn era is officially over - though we pin versions anyway, because two 1.x releases have been yanked for regressions. Trust, with a lockfile.
- Middleware became the production story: summarization, PII scrubbing, human approval and retries as composable layers (session b4).
langchain>=1.3,<2 and langgraph>=1.2,<2 · docs live at docs.langchain.com (python.langchain.com is the 0.x museum). Naming: "LangGraph Platform" is now "LangSmith Deployment" - update your mental bookmarks.
LiveThe honest alternatives card3 min▶
A framework you chose without knowing the alternatives is a framework you cannot defend in a design review. The 2026 field, honestly:
| Pick | When it wins |
|---|---|
| Raw provider SDK | Single provider, simple call chains, zero magic wanted. Fastest to debug. |
| PydanticAI | FastAPI-native teams, type-safety-first, built-in usage limits. |
| CrewAI | Fastest role-based multi-agent prototyping. Convenience over control. |
| LlamaIndex | Retrieval quality over messy documents IS the product. Hybrid (LlamaIndex ingestion + LangGraph orchestration) is common. |
| LangChain/LangGraph | Cycles, persistent state, human approval, durable long-running work, provider swapping, team standardization. |
The criticisms you will hear are real: abstraction overhead, the 0.x churn history, stack traces through framework internals. The 1.0 surface-area cut answers some of it; LangSmith answers the debugging pain (and is the paid product - notice the business model). The best answer is the one you build tonight: know what the framework replaces, and you will know when it earns its keep.
The team that went back to raw SDK - and the one that could not. A two-person startup shipping one OpenAI-only summarizer ripped LangChain out and was happier: fewer layers, same output. A data platform team running approval-gated agents across Claude, a local model and three databases tried the same rip-out and rebuilt half of LangGraph badly within a month - checkpointing, interrupts, retries. The difference was never taste. It was state.
Self-studyIs this worth learning? The adoption evidence2 min read▶
- Money: LangChain Inc raised a $125M Series B at a $1.25B valuation (Oct 2025) - the company is not going anywhere soon.
- Usage: the ecosystem pulls roughly 300M downloads a month; LangGraph alone ~35M. 400+ named production deployments; LangChain claims 35% of the Fortune 500 use its products.
- Named users: Klarna (support AI, 85M users), Uber (code-migration agents, ~21,000 dev hours saved), LinkedIn (SQL Bot), Elastic, JPMorgan, BlackRock.
- The counterweight: a real 2026 discourse of teams migrating simple apps back to raw SDKs, Gartner predicting 40%+ of agentic projects canceled by 2027, and MIT finding most GenAI pilots show no P&L impact. Both currents are true. The skill you are building - knowing WHEN the framework earns its keep - is exactly what separates the successes from the cancellations.
Your two engines: Claude and a local model 3 min live
Every build-along in this track runs on either engine. Claude via API when you want maximum capability; a local Ollama model when you want free, private, offline. LangChain's job is to make the difference one line of code.
LiveSetup card - both engines in five minutes3 min▶
| Claude API path | Local Ollama path | |
|---|---|---|
| Install | pip install langchain-anthropic | pip install langchain-ollama + Ollama app |
| Key/model | ANTHROPIC_API_KEY env var | ollama pull llama3.1 (or your Hermes from the sibling course) |
| Cost | Per token - cents for this course | Free forever |
| Privacy | Anthropic ToS | Nothing leaves your machine |
| Tool calling | Excellent | Works on tool-tuned models only |
Build the agent with no framework ★ 14 min · everyone builds
DataDesk v0: a raw-SDK agent that can answer one real question - "how many rows and what date range does our CSV cover?" - by deciding for itself to call a Python tool. Forty lines, no LangChain, no magic left afterwards.
Create the project: mkdir datadesk && cd datadesk, a venv, and pip install anthropic (or use the Ollama path with plain requests to localhost:11434/v1).
Write one tool: a function csv_stats(path) that returns row count, columns and date range of a CSV as a dict. Use any real, non-confidential CSV you have.
Write the loop: send the question + tool schema to the model; if the response asks for the tool, run it, append the result, call the model again; when no tool is requested, print the answer. This is the agent loop from Part 1, verbatim.
Run it and watch the two round trips: model asks for csv_stats → tool runs → model answers with real numbers. Read your own loop code once more. That is an agent. All of it.
Now break it: ask a question needing TWO tool calls, add a second tool, imagine retries, streaming, memory, approval gates. Count the code you are about to write. Hold that feeling for Demo 2.
The same agent in three lines of LangChain ★ 8 min · build your own
Same tool, same question, framework edition. Watch what disappears - and check what you gained is worth the layer you added.
pip install "langchain>=1.3,<2" langchain-anthropic (and/or langchain-ollama).
Decorate your existing function: @tool above csv_stats - the schema you hand-wrote in Demo 1 is now generated from the signature and docstring.
Replace your whole loop with create_agent - three lines below. Run the same question. Same answer, two round trips, zero loop code.
The swap test: change the model line to the other engine (Claude ↔ Ollama) and re-run. One line. Your Demo 1 code would have needed a rewrite of every API call.
Decision minute: write ONE sentence in your notes - "for DataDesk, the framework is/is not worth it because ...". You will revisit that sentence in b10 with an eval suite in hand.
What you just did is the course. Sessions b2-b10 are this exact move repeated at higher altitude: meet a real production need (memory, approval, retrieval, evals), feel what it costs by hand, then let the framework carry it - or consciously decide it should not.
Try it yourself - this week ◐ 30-45 min total
- Finish both demos if you did not complete them live - the scratch loop especially. Nobody in this track gets to treat agents as magic.
- Add a second tool to the scratch version (e.g.
column_mean(path, column)) and feel the loop code start to creak. Then add it to the create_agent version in one decorator. - Run the autonomy-ladder prompt from Part 1 on four real tasks from your backlog. Bring the most interesting "actually just a workflow" verdict to session b2.
- Both engines working? Claude key set AND
ollama pull llama3.1done - b2 uses the swap constantly. - Optional reading: the LangChain 1.0 announcement (langchain.com/blog) - now you can read it as a review of decisions you understand.
Official sources covered
This track teaches from the official docs and the free LangChain Academy curricula (login required for lesson content; certificates stay with the Academy - all free). This page covers:
Three questions before you go 🎯 ◐ 90 seconds
1 · The difference between a workflow and an agent is...
Anthropic's definition, and the one that pays rent: predefined code paths vs model-directed process. It decides cost, risk, and whether you need an agent at all.
2 · A tutorial shows chains built with the pipe operator: prompt | llm | parser. What do you know?
LCEL chains left the main package in 1.0. Reading a tutorial's LangChain era at a glance is a real 2026 skill.
3 · When does the framework genuinely earn its keep over a raw SDK?
Both extremes fail design reviews. The honest answer is the list in A - and you now know it from writing the raw loop yourself.