deepagents-in-action: a Chinese course that builds Deep Agents from 0.5 to 0.7

What deepagents-in-action actually is, and who it is written for

This is a course repository. The top level holds an Astro site (astro.config.mjs, src/, public/, content/) plus scripts that prepare content before dev and build, so what you clone is the publishing pipeline and the chapter sources, not a Python package. The README describes the project as a complete guide to building production-grade AI agents on the LangChain and LangGraph ecosystem, produced by a LangChain certified ambassador who also wrote earlier LangChain and LangGraph courses.

The intended reader is a Chinese-speaking developer who already knows the Python side of LangChain or LangGraph and now wants the Deep Agents harness itself: virtual filesystem, task planning, subagents, async subagents, permissions, streaming, interpreters. The chapters map one-to-one onto those mechanisms, and each chapter links to a runnable AgentSeek template rather than leaving you to assemble a project. If you only want to read about Deep Agents in English, the README points at the official Deep Agents Overview documentation instead, and that is the better destination for you.

The version story: why 0.5, 0.6 and 0.7 all appear in one course

The README carries a warning that the course was written starting from Deep Agents 0.5 and deliberately keeps the learning path in which the framework's capabilities filled in over time. The recommended baseline is now 0.7, and new readers are told to use the latest 0.7.x patch release. Readers who followed 0.5 or 0.6 chapters are told to read the v0.7 update chapter first and finish the migration check before continuing experiments. Old chapters and screenshots record the defaults of their time; the nearby v0.7 reminders describe current usage.

That is an unusual editorial decision and it has a cost. A chapter written against 0.5 will show behaviour that no longer matches a fresh install, and the reader has to hold two mental models until the update chapter reconciles them. The compensating benefit is that the update chapter explains why defaults changed, which applications are affected, and how to verify a migration with evaluation and traces, instead of listing features. The README is also careful about one number: the 65% reduction in base input tokens is described as the reduction for simple turns, and the course states plainly that it does not mean every application's total cost falls by 65%. That kind of qualification is worth noticing, because such figures are usually repeated without it.

How the course is structured: chapters, templates and a lifecycle CLI

The material is organised in four blocks. Preparation covers environment setup and loading development skills into an AI coding assistant. A version-update block explains the 0.7 harness changes. Then cognition chapters (1 and 2) and core chapters (3 onward) each pair a chapter page with an AgentSeek template. Chapter 3 uses the content-builder template to show how content, intermediate results and skills land on disk through FilesystemBackend. Chapter 4 uses the research template with Todo explicitly enabled to watch write_todos generate and change a plan. Chapter 5 stays on the research template and compares the context on both sides of a delegation to a research-agent. Chapter 6 starts from the synchronous research app and splits the researcher into a separate graph wired up as an AsyncSubAgent.

The templates come from the agentseek-ai/agentseek-templates repository, and the README notes that some chapters do not ship a complete template: chapters 6, 8, 9 and 11 require you to add the chapter's capability on top of the template by following the chapter text. Chapter 14 uses a streaming-specific template, and chapters 15 and 16 share a Dynamic Subagents Pattern Lab template. So the template is a starting point, and for several chapters the interesting work is the part you type yourself.

Installing the course tooling and running your first chapter

The README's path is AgentSeek, a project scaffolding tool installed with uv. Upgrading it first matters because the templates change between batches:

uv tool install --upgrade agentseek
agentseek create --list-templates --checkout main

The second command lists the templates available on the main branch. Once you have chosen one, create the project non-interactively. Chapter 2's quickstart uses the default template:

agentseek create deepagents/default --checkout main --no-input

Inside the generated directory every template exposes the same lifecycle entries. The README says to complete dependency installation according to the output of task --list and to configure .env as described in the generated project's README, then run the checks and the dev server:

cd <generated project directory>
agentseek info
agentseek task --list
agentseek doctor
agentseek dev

What you should see is a working Deep Agent application you can edit: the quickstart chapter's experiment is changing the system prompt and adding a custom tool. One detail worth keeping: --checkout main fetches the newest template batch, which is what you want while following the course, but the README suggests replacing main with a recorded full commit SHA when you need to freeze an assignment environment. That is the only pinning mechanism the README offers, and it is a good one.

Model choice is part of the setup, not an afterthought

The examples connect to models through SiliconFlow by default, and the README recommends managing the model name with the MODEL_NAME environment variable rather than hardcoding it, because platform models, prices and free tiers change. For introductory or simple tasks it names Qwen/Qwen2.5-7B-Instruct as usable for getting the examples to run, and deepseek-ai/DeepSeek-V4-Flash as a cheap option for quick trial runs.

For complex scenarios (task planning, context summarisation, orchestration across multiple subagents) the README states that small models often cannot complete the run reliably and recommends a stronger tool-calling model, naming zai-org/GLM-5.2 for long-horizon agent tasks with a 1M context window. This is the most practically useful warning in the README. A course that teaches subagents and delegation will look broken if the model behind it cannot call tools consistently, and the failure will look like a framework bug rather than a model limitation.

Version floors and beta features you have to track per chapter

The README lists minimum versions that are not uniform across the course. Basic filesystem permissions require deepagents>=0.5.2. The interrupt permission mode requires deepagents>=0.6.8. RubricMiddleware is still Beta, and chapter 13 verifies versioned behaviour with deepagents==0.7.1. Chapter 14 builds on Event Streaming v3, introduced in deepagents>=0.6. Chapter 15 covers Interpreters, also Beta, and requires Python 3.11+ plus langchain-quickjs>=0.2.0.

This is the sharpest limitation of the material. You cannot follow the whole course on a single pinned dependency version, because the chapters were written against different floors, and two of the features covered are Beta. Anyone treating this as a stable reference for production code should read those version notes before copying anything into a real service. The course is honest about it, but the burden of resolving it sits with the reader.

The site's own build, and how it differs from a docs generator

The repository is an Astro site with Tailwind, and its package.json requires Node >=22.12.0. The dev and build scripts both run a content preparation step first, so content is transformed before Astro sees it:

npm install
npm run dev

The predev hook runs node scripts/prep-content.mjs, then astro dev starts the local site. Several validation scripts exist alongside it: assets:check validates assets, assets:test runs image-related tests, ci:test covers cross-platform CI and version updates, and docs:test covers Windows documentation. That last one is a hint about the audience: the course is used on Windows as well as macOS and Linux, and the project tests for it.

If you wanted to fork the course and translate it, this layout is what you would be working with: Markdown content, a preparation script, and image optimisation through sharp. Nothing here is a plugin for Deep Agents itself, and no part of the repository installs into your agent application.

When this course is the wrong tool

If you need an API reference, this is not it. The README defers to the official Deep Agents documentation for that, and the chapters are explanatory rather than exhaustive. If you are not comfortable reading Chinese, the value drops sharply: the chapters, the update notes and the version reminders are all in Chinese, and the repository description is in Chinese too. The README's English content is limited to links and package names.

If your team has already standardised on a different agent stack, the course still explains harness concepts such as context isolation through a virtual filesystem and delegation to subagents, but the code you write will not transfer. And if you need a stable, versioned dependency to build against today, a course whose chapters span 0.5 through 0.7 is a moving reference. The alternative for that need is the official documentation plus the Deep Agents release notes, which describe one version at a time.

Editorial conclusion

Adopt this course if you already write Python against LangChain or LangGraph and want the Deep Agents harness explained in sequence, including the 0.5 to 0.7 default changes that break older examples. Skip it if you need an English-language reference, an API reference, or a library you install as a dependency; this repository is an Astro site plus Markdown chapters. Before committing, check the version note in the README, confirm that the chapter you need has an AgentSeek template (chapters 6, 8, 9 and 11 require you to add the capability yourself), and read the v0.7 update chapter before re-running any 0.5 or 0.6 experiment.

Frequently asked questions

Official sources

1. datawhalechina/deepagents-in-action on GitHub
2. Issues
3. Project website
4. README