AI Agents in LangGraph: under two hours to understand stateful agents, but not enough for production

When clients watch an agent demo, the question they ask most is rarely “how smart is it?”. They ask where it stops, who approves its output before it goes out, and what happens if the server crashes halfway through. “AI Agents in LangGraph”, a DeepLearning.AI short course, answers the first two questions thoroughly. On the third, it only makes a start.

The instructors are Harrison Chase, co-founder and CEO of LangChain, and Rotem Weiss, co-founder and CEO of Tavily. The course page lists it as Intermediate level, 1h42m long. It is aimed at people who write intermediate-level Python and want to build agents that are easier to control.

For an FDE, “control” is the job. Put an agent into a client’s workflow without being able to show which step it is on, and you will not get through the meeting with the risk team.

Why a graph rather than a chain?

LangChain introduced LangGraph in January 2024 as a module built on LangChain for constructing cyclical graphs. The reason was practical: chains until then ran straight through, with no clean way to add loops. Yet every agent needs a loop: call a tool, read the result, decide whether to call again or stop.

According to the launch blog post, developers often need tighter control over the flow, and LangGraph lets them describe that flow as a state machine expressed as a graph.

The course follows the same arc: first you write an agent from scratch in Python, then you port it to LangGraph. The LangChain team itself rebuilt its standard AgentExecutor in LangGraph, so the exercise is not a toy; it is the framework’s main direction.

Do not skip through the from-scratch lesson. Only after writing the tool-calling loop by hand once will you see what LangGraph takes off your plate, and be able to explain to a client why you are not continuing to hand-roll it.

Three ideas worth keeping

The first was covered above: an agent is a state machine. When a client asks “what is it doing?”, you point to a node on the graph, not to a long stretch of logs.

The second is persistence. The LangGraph documentation treats the checkpointer as the foundation for four things: continuous conversations, human-in-the-loop, time travel and fault tolerance. The course’s Persistence and Streaming lesson teaches this, and it is the lesson worth watching twice.

The third is human-in-the-loop, which the documentation defines as inspecting and modifying the agent’s state at any point. The Human in the Loop lesson teaches exactly that.

Applying it to a real case

Imagine building an agent that drafts refund emails for an insurer’s claims team. The graph has four nodes: read the file, check the policy, draft the email, send. You place a stop just before the “send” node, so a staff member can open the state, correct the amount if it is wrong, and then let it continue.

Now suppose the process dies while waiting for approval. The LangGraph documentation lists fault tolerance among the things a checkpointer provides. But the agent can only resume if its state lives somewhere that survives a restart, so before promising anything to the client, check where your checkpointer actually stores state.

If you want the agent to return to exactly the approval point without rereading the file, you need a durable checkpointer, and that is precisely what the course does not teach.

So in your first demo with a client, show them the approval stop, then be clear about what recovery after a failure will require in production. An honest answer to “what if it crashes?” earns more credit than a demo that overpromises.

The agentic search section uses Tavily’s search tool to give the agent extra knowledge. It is useful, but bear in mind that Tavily is the company of one of the two instructors. At a client site the data source is usually an internal system, so learn how to attach a tool to the graph rather than memorising Tavily specifically.

What to learn, what to drop, and in what order

A sensible order is to read the 2024 LangGraph launch post to understand why cycles are needed, then take the course, then read the Persistence page in the official documentation. If your Python is still weak, shore it up first, because the course assumes intermediate level.

What to drop is the idea that finishing the course means you can deploy. The LangGraph documentation now describes it as a runtime for long-running, stateful agents and names users such as Klarna, Uber and J.P. Morgan. But a course of under two hours does not teach the matching operations work: a durable checkpointer and long-term memory through a store.

On the career side, when reading FDE job descriptions, look for phrases such as “stateful agents” or “human-in-the-loop”. On your CV, do not write “completed the LangGraph course”. A line such as “agent with a human approval step that resumes from a durable checkpoint after failure”, with a link to the repo, carries far more weight.

The course is currently free for a limited time during the platform’s beta, so check again before signing up. Spending under two hours to learn how to make an agent stop in the right place is a very cheap investment; the real difficulty starts when the agent has to run continuously for a week at a client’s site.