# Callous-0923/agent-study: A 37-Chapter Executable AI Agent Course, Reviewed

> A Chinese-language AI Agent curriculum whose chapters are runnable Python files, plus a browser-readable site. It is a study resource with a job-hunt angle, not a library you install.

**Callous-0923/agent-study** — 36章AI Agent全栈课程：从ReAct循环到Claude Code逆向、MCP/A2A协议、RAG、DSPy、生产可观测性——全部为可运行Python文件，面试导向。

- Repository: https://github.com/Callous-0923/agent-study
- Website: https://agent-study-ruddy.vercel.app
- Stars: 502 · Forks: 55
- Language: HTML
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/callous-0923-agent-study

## What agent-study actually is, and who it is written for

The README describes this as a full-stack AI Agent course aimed at job hunting and product engineering, spanning 37 topics across 7 layers. The framing matters more than the chapter count. This is not a framework, an SDK or a service. It is a course whose units happen to be Python files: according to the README, each chapter is an independently runnable .py file that serves both as lecture notes and as executable code.

The stated audience is specific: new graduates, engineers changing fields, and any developer who wants systematic coverage of AI Agents. The repository also carries a chapter_07_interview directory and the README advertises 20 frequently asked interview questions plus a project guide and interview process notes. So the intended reader is someone preparing for a hiring loop, not someone shopping for a dependency.

The curriculum is layered rather than flat. Layers run from theory (chapters 1 to 3) through engineering practice (4 to 7), deep technical analysis (8 to 12), production concerns (13 to 18), advanced architecture (19 to 24), foundational reinforcement (25 to 28) and expert material (29 to 36). The top-level directory listing matches that claim one-to-one: chapter_00_overview through chapter_36_defense are all present as separate directories.

One discrepancy is worth flagging before you invest time. The README header says 37 chapters, and the layer breakdown ends at chapter 36. Counting chapter_00 as a chapter gives 37. That is consistent, but the description in the repository metadata says 36 chapters. Treat the numbering as 0 through 36 and read the directory listing rather than the summary line.

## How the course is structured: chapters, HTML build, and a Vercel site

The data flow here is unusual for a course repository and is the main architectural decision. Source content lives in per-chapter directories, and a build script turns it into HTML. The top level contains build_html.py, index.html, package.json and vercel.json. The package.json exposes exactly one script: `python build_html.py --all`, run via `npm run build`. The vercel.json is what lets the generated output be deployed as the static site at agent-study-ruddy.vercel.app.

That explains the repository's primary language being HTML despite the course being Python. The Python chapters are the substance; the HTML is the presentation layer produced by the build script. If you clone the repository and read only the .py files, you skip the dark blueprint-style site the README advertises, and if you read only the site you skip the code. The README explicitly offers the site as the zero-install path: no setup, browser only, all 37 chapters, responsive on phone and desktop.

Each chapter directory also carries its own HTML file, and the README links directly to individual chapter pages on the Vercel domain, for example the RAG deep-dive at chapter_09_rag_deepdive and the MCP deep-dive at chapter_10_mcp. The GitHub Pages links in the chapter tables point at callous-0923.github.io, a second hosting path for the same generated pages. Two hosts for one artifact is a maintenance surface: a change to the build has to be correct for both.

The course content itself is organized around mechanisms rather than library tours. Chapter 8 covers the Claude Code architecture with a main loop, steering, context compression and sub-agents. Chapter 10 covers MCP over JSON-RPC with tools, resources, prompts and capability negotiation. Chapter 15 covers Google's A2A protocol with AgentCard, Task and Artifact. Chapter 24 covers observability with tracing span trees and a comparison of LangSmith against LangFuse. Chapter 28 covers a three-tier cache from exact to semantic to LLM. These are design descriptions with accompanying code, which is the useful part.

## Installing it and running your first chapter

The repository is a course, so installation means getting a Python environment that can execute the chapter files. The README's chapter_00_overview is described as covering the environment setup, the learning roadmap, dependency installation and API key configuration. The dependency list is pinned in requirements.txt with a comment stating the major-version ranges were verified on 2026-08-01, and the file itself gives the install command.

```bash
python -m pip install -r requirements.txt
```

That pulls openai, python-dotenv, langchain, langchain-openai, langgraph, numpy, fastapi, pydantic and uvicorn, with numpy selected by Python version. Python 3.10 or newer is required according to pyproject.toml. Note that dspy and openai-agents are optional extras, not part of the base install, so chapters that depend on them will fail until you add the extras.

The README states that API keys are configured in chapter 0, and python-dotenv is a base dependency, which points at a .env file. The repository does not document the variable names in the chapter listing, so read chapter_00_overview before running anything that calls a model.

For the browser-only route, the README is explicit that no installation is needed.

```bash
npm run build
```

That invokes `python build_html.py --all` and regenerates the HTML from the chapter sources. If you only want to read, open agent-study-ruddy.vercel.app instead and skip both commands.

## The Python version and dependency ranges are the first real constraint

The pinned ranges are tighter than they look. pyproject.toml requires Python 3.10 or newer and caps openai below version 3, langchain below 2, langgraph below 2, fastapi below 1 and pydantic below 3, while requiring pydantic 2.13 or newer. numpy is split by interpreter version: below 2.3 for Python under 3.11, and 2.3 or newer above it. If you are on an older 3.10 environment with a numpy already resolved to 2.3, the resolver will fight you.

This matters because the course teaches against specific API surfaces. Chapter 11 covers the difference between OpenAI and Anthropic tool calling, including streaming assembly and strict mode. Chapter 13 builds a FastAPI service with SSE streaming and WebSockets. Chapter 22 covers DSPy signatures, modules and optimizers. Those chapters describe behavior that shifts between major versions. A course pinned to `openai>=2.52,<3` will read as stale the moment the next major lands, and nothing in the repository layout suggests a version-tracking mechanism beyond the comment in requirements.txt.

The second constraint is language. The README is Chinese, the chapter titles are Chinese, and an English README exists at README_EN.md. The course prose itself is not documented as translated. If you cannot read Chinese, you are relying on the English README plus the code, which is workable for the code-heavy chapters and much weaker for the design-discussion chapters.

## Where this is the wrong tool

This is a study resource, not a dependency. There is no importable package that gives you an agent runtime, no published version to pin in your own project, and no changelog. The pyproject.toml declares a project named agent-study at version 2026.8.0, but nothing in the repository suggests it is meant to be consumed as a library. If you need an agent framework to build on, this repository is the wrong place to look.

The tests directory exists and pytest is configured with `testpaths = ["tests"]` and `-q`, which implies the chapters are exercised in CI. But the repository does not describe test coverage, and a passing test suite for a course repository verifies that examples run, not that the teaching is correct. Do not read green tests as validation of the architectural claims in chapters 8, 12 or 23.

There is also no exercise or grading layer. The README describes chapters, interview questions and a project guide, but not assignments with reference solutions. If you learn by doing graded problems rather than by reading and running examples, the format will not carry you.

Finally, the maintenance signal is worth stating plainly. The last push was on 2026-09-05, which is recent, and the repository is not archived. But the README's own update badge reads 2026.08, and the requirements comment is dated 2026-08-01. The project is moving, yet the version-sensitive chapters age faster than the push cadence suggests.

## How it compares to LangChain's own tutorials and the DeepLearning.AI short courses

The obvious alternative for a developer learning agents is LangChain's own documentation and tutorial track. The difference in approach is structural. LangChain's material teaches you LangChain: the tutorials exist to make you productive with that library, and the abstractions you learn are the library's abstractions. Chapters 4 and 5 here do cover LangChain Agent and LangGraph state machines, but they sit inside a curriculum that also covers MCP, A2A, MemGPT-style memory, computer use, DSPy and code-agent architectures. The teaching target is the problem space, not one vendor's API.

That cuts both ways. If your goal is to ship something on LangGraph next month, the vendor tutorials are faster and stay current with the library by construction. If your goal is to answer why a ReAct loop differs from Plan-Execute or Reflexion, or how capability negotiation works in MCP, a library tutorial will not cover it. Chapter 3 covers exactly that ReAct, Plan-Execute and Reflexion comparison, and chapter 19 catalogs seven workflow patterns. Those are the chapters with no direct equivalent in a framework's own docs.

The second alternative is the short-course format, which trades depth for completion. A multi-hour video course gets you to a working demo quickly and stops there. Here, chapter 12 covers production infrastructure with a harness and a production checklist, chapter 18 covers prompt injection attacks and defenses with permission tiers and audit, and chapter 24 covers tracing and alerting. That is the material a short course typically omits, and it is also the material most likely to be wrong in a year.

## Licence, upgrade cost and what a fork implies

The repository is MIT licensed, and pyproject.toml declares `license = "MIT"`. That is permissive: you can reuse the code in your own work, including commercially, provided you keep the copyright notice and licence text. The LICENSE file is at the top level alongside README.md and README_EN.md. This is a factual description of the licence identifier, not legal advice; read the LICENSE file itself before relying on it.

The upgrade cost is the interesting part. Because the chapters are prose plus code in the same file, updating a chapter means editing text and code together, and the code is pinned to major-version ranges that will eventually break. The build step adds a second obligation: `python build_html.py --all` regenerates the HTML, and the result is served from both the Vercel deployment and GitHub Pages. A contributor changing a chapter has to keep the Python runnable, the prose accurate and the generated HTML consistent across two hosts.

Forking is cheap and probably the intended use. If you want an English-language version, or a version pinned to a newer OpenAI SDK, MIT lets you do that without asking. The cost is that you now own the version drift for every chapter that touches a moving API, and there are many of them.

## Conclusion

Adopt it if you are a graduate, a career switcher or a working engineer who wants one repository that walks from a bare ReAct loop through RAG, MCP, A2A and observability, and you are comfortable reading Chinese or the English README. Skip it if you need a maintained library to depend on, English-first prose, or a course with a graded exercise set: the repository ships chapters and tests, not assignments with solutions. Before committing time, open the Vercel site and read chapter_00_overview, then confirm the Python version and dependency ranges in pyproject.toml match your environment, and read chapter_08_claude_code to judge whether the reverse-engineering chapters are the depth you want.

## FAQ

### What is an agent versus GPT, and does agent-study cover that?

The course begins with a chapter on writing a bare ReAct loop and the principles of function calling, then a chapter on core components covering the planner, memory systems and tool design. A GPT model is the thing being called; the agent is the loop, memory and tools around it. Chapters 1 through 3 are where that distinction is taught.

### Can I learn agentic AI from scratch with agent-study?

The README states the course is aimed at new graduates, engineers changing fields, and any developer who wants to learn AI Agents systematically, and it says chapter 0 covers the environment setup and API key configuration. Python 3.10 or newer is required and dependencies install from requirements.txt. The repository does not state a prerequisite beyond that.

### How does agent-study approach testing agents?

Chapter 6 covers evaluation and testing, listing an evaluation framework, LLM-as-Judge and a production checklist. The repository also has a tests directory, and pyproject.toml configures pytest with `testpaths = ["tests"]`. The repository does not describe what those tests cover.

## Sources

- [Callous-0923/agent-study on GitHub](https://github.com/Callous-0923/agent-study)
- [Issues](https://github.com/Callous-0923/agent-study/issues)
- [License: MIT](https://github.com/Callous-0923/agent-study/blob/main/LICENSE)
- [Project website](https://agent-study-ruddy.vercel.app)
- [README](https://github.com/Callous-0923/agent-study/blob/main/README.md)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/callous-0923-agent-study