LangGraph Agents with Memory & Human-in-the-Loop

Name: LangGraph Agents with Memory & Human-in-the-Loop
Rating: 5.0 (15 reviews)

Build graph-based AI agent workflows in LangGraph with state, memory and human approval checkpoints for real actions

Created byAnton Voroniuk• 1.250.000+ Students, Anton Voroniuk Support, George Paterakis

Last updated 9/2026

English

English [Auto],

What you'll learn

Build a complete LangGraph workflow from scratch, defining nodes, edges, and conditional routing between steps
Manage state and memory across multi-step runs so your agent remembers earlier steps and past interactions
Add human-in-the-loop checkpoints that pause the agent and wait for approval before high-stakes actions
Apply nine reusable LangGraph workflow patterns to structure real agentic tasks quickly and consistently
Understand why graph-based workflows outperform single agents for multi-step tasks and when to make the switch
Design approval workflows that keep humans in control without slowing the agent down unnecessarily
Explain what an AI agent is, how its reason–act–observe loop works, and when an agent is the wrong tool for the job
Recognize the most common ways agent projects fail and apply design habits that prevent them

Course content

5 sections • 17 lectures • 3h 25m total length

Welcome to the Course: Agentic Workflows with LangGraph0:16
A short introduction to the course goals, the final project, and the prerequisites you'll want in place before writing your first graph.

AI Agents Demystified: A Practical Definition9:39
Cut through the buzzwords to a working definition of an AI agent and see why this pattern has become central to building with LLMs.
The Reason–Act–Observe Cycle Every Agent Runs On10:48
Trace the loop an agent repeats on every step so you can anticipate its behavior before you design a workflow around it.
Do You Really Need an Agent? A Decision Framework5:46
Apply a quick checklist for deciding whether a task justifies an agent or is better served by a single, cheaper LLM call.
Common Agent Failure Modes and How to Design Around Them12:41
Examine the patterns behind most broken agents in production and the design choices that keep yours out of that list.
Key Agent Concepts at a Glance19:50
A compact reference of the terms and ideas from this section for quick review as you move into LangGraph.

Why a Single Agent Isn't Enough — The Case for Graphs9:55
A conceptual explanation of where single-agent designs hit their limits and what a graph of nodes and edges solves.
What LangGraph Is and How It Differs from a Plain Agent24:54
Learn the core ideas behind LangGraph — nodes, edges, state — and how it changes the way you control an agent's flow.
Hands-On: Nine Reusable Workflow Patterns in One Session14:58
Code nine LangGraph workflow patterns back to back and learn which one to reach for in each type of agentic task.
Hands-On: Your First End-to-End LangGraph Workflow11:51
Build a working LangGraph workflow from an empty file to a finished run, wiring nodes, edges, and conditional routing yourself.
The LangGraph Patterns You'll Use Most7:51
A reference list of the workflow patterns that come up again and again, with notes on when each one fits.

How State, Memory and Human Checkpoints Fit Together in LangGraph25:25
See how LangGraph state carries memory between steps and how interrupt points let a human step in before the agent continues.
Hands-On: An Agent That Remembers and Pauses for Approval11:45
Build a LangGraph agent that retains context from earlier steps and stops to wait for your approval before acting.
Hands-On: Approval Workflows for High-Stakes Agent Actions9:33
Go deeper with a second build focused on designing approval flows for actions with real consequences, such as sending or spending.
Managing State and Memory Across Multi-Step Runs17:18
A practical guide to structuring state so your agent remembers what it should and forgets what it shouldn't.
Designing Human Checkpoints That Don't Slow Agents Down12:05
Guidelines for placing approval gates where they add safety without turning every run into a waiting game.

Requirements

Working knowledge of Python (functions, classes, basic async is a plus)
Basic familiarity with LangChain and LLM APIs — you should have called a chat model at least once
An API key for an LLM provider such as OpenAI or Anthropic (free tiers are enough for the exercises)
A computer with Python 3.10+ and a code editor installed
No prior LangGraph experience is required — we start from the fundamentals

Description

A single agent works well on short tasks and gets unpredictable on long ones. It forgets earlier steps, repeats itself, or takes an action nobody approved. LangGraph solves this by turning the agent into a graph of steps with persistent state and checkpoints where a human decides whether to continue. In this course you will build such a graph yourself, node by node.

By the end of the course you will be able to

Build a complete LangGraph workflow from scratch, with nodes, edges, and conditional routing
Apply nine reusable workflow patterns to structure real multi-step tasks
Manage state and memory so your agent remembers what it did in earlier steps
Add human-in-the-loop checkpoints that pause the agent before high-stakes actions
Design approval workflows that keep humans in control without slowing the agent down

Course structure

The course opens with a refresher on agent fundamentals so you know exactly what a graph is improving on. The next section introduces graph-based thinking: why single agents break down, what LangGraph adds, nine patterns coded in one session, and your first end-to-end workflow. The final practical section covers state, memory, and two full builds of approval workflows, from a simple pause-and-confirm to gates for actions like sending, spending, or deleting. Written references follow each section.

Who should take this course

Python developers who have built a basic LLM app or agent and want a cleaner way to orchestrate multi-step work. Engineers whose prototype has become hard to control and who need memory and approval gates before trusting it with real actions. Basic familiarity with LangChain is recommended; no LangGraph experience is needed.

Why this course

Two hands-on builds for memory and human-in-the-loop alone, nine patterns you will reuse in every future project, and no filler. You leave with a way of thinking about workflows that transfers to any agent you build.

Enroll now and build agents that remember, pause, and ask before they act.

Who this course is for:

Python developers who have built a simple LLM app or agent and want to move to structured, multi-step workflows
AI engineers who need agents that remember context across steps and can be trusted with real actions
Backend and automation developers looking to add human approval gates to AI-driven processes
Anyone whose single-agent prototype has become hard to control and who wants a cleaner way to orchestrate it
Anyone evaluating LangGraph for a production project who wants a fast, practical introduction before committing

LangGraph Agents with Memory & Human-in-the-Loop

What you'll learn

Explore related topics

Course content

Welcome & Course Roadmap1 lecture • 1min

AI Agents 101: How They Think and Where They Break5 lectures • 59min

Thinking in Graphs: Your First LangGraph Workflow5 lectures • 1hr 9min

Stateful Agents: Memory and Human Approval Checkpoints5 lectures • 1hr 16min

Wrap-Up and What to Learn Next1 lecture • 1min

Requirements

Description

Who this course is for: