agent-study: a 37-chapter, runnable Python curriculum for AI Agent engineering
36章AI Agent全栈课程：从ReAct循环到Claude Code逆向、MCP/A2A协议、RAG、DSPy、生产可观测性——全部为可运行Python文件，面试导向。
At a glance
- What is it?
- The repository ships 37 chapters and roughly 22,000 lines of Python as standalone .py files, each doubling as lecture notes and executable code. It is built for interview preparation and product engineering, and its value depends on whether you want a guided syllabus rather than a library.
- Who is it for?
- Adopt agent-study if you are preparing for agent engineering interviews or want a single repository that walks from a hand-written ReAct loop to MCP, A2A and observability without assembling a reading list yourself. Do not adopt it if you need a supported library with semantic versioning, a changelog and an issue triage process; this is a course, and the repository shows no releases.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 10 days ago.
- What is it written in?
- Mainly HTML, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on September 15, 2026, and from our analysis. They are not legal advice.
DEEP OPEN-SOURCE ANALYSIS
The gap agent-study tries to close: scattered agent knowledge versus one ordered syllabus
Agent engineering material tends to arrive in three disconnected forms: framework documentation that explains one library's abstractions, blog posts that describe a single technique, and papers that assume you already know the surrounding system. A developer preparing for an interview or building a first agent product has to stitch these together and guess the ordering. agent-study takes the opposite position. It presents 37 chapters across seven layers, from theory (Ch1 to Ch3) through frameworks and multi-agent systems (Ch4 to Ch7), deep dives (Ch8 to Ch12), engineering and frontier topics (Ch13 to Ch18), advanced architecture (Ch19 to Ch24), foundational reinforcement (Ch25 to Ch28) and expert-level material (Ch29 to Ch36). The README states the intended audience plainly: new graduates, engineers changing fields, and any developer who wants systematic coverage. The interview orientation is explicit, with Ch7 listed as 20 high-frequency interview questions plus project guidance and interview process notes. The framing matters because it sets expectations. This is a syllabus with runnable code attached, not a toolkit you import. If your problem is 'I do not know what I do not know about agents', the ordered layers are the product. If your problem is 'I need a maintained abstraction over three model providers', this repository is not aimed at you.
How the chapters are actually delivered: standalone .py files plus a static site
The README describes each chapter as an independently runnable .py file that serves as both a complete lecture and executable code. That is the central architectural decision, and it has consequences. There is no package to install, no import path shared across chapters, and no build step implied by the description. You read a chapter, run it, and modify it. The repository's primary language is listed as HTML, which is consistent with the published site at agent-study-ruddy.vercel.app and with the chapter links in the README pointing at generated .html pages. So there are two consumption paths: the browser path, described as no installation required, with a dark blueprint style and responsive layout for phone and desktop; and the source path, where you open the corresponding .py file. The chapter list is concrete about mechanisms rather than slogans. Ch1 covers writing a ReAct loop by hand and the mechanics of Function Calling. Ch8 covers the Claude Code architecture, naming the main loop, steering, context compression and SubAgents. Ch9 covers chunking strategy, embedding selection, RRF, cross-encoder reranking and production patterns. Ch10 covers MCP over JSON-RPC, its primitives (Tools, Resources, Prompts) and capability negotiation. Ch21 describes an EventBus, dynamic interruption, backpressure control and a StateManager reducer. Whether the code matches the depth of those headings is the thing you must verify yourself; the README asserts roughly 22,000 lines and more than 60 runnable examples, and that claim is not independently checkable from the description alone.
Getting a chapter running: Python 3.10+, an API key, and no install step
The entry point is Ch0, the course overview and environment setup, which the README lists as covering the learning roadmap, dependency installation and API key configuration. The badge in the README states Python 3.10+ as the requirement. Beyond that, the supplied material does not enumerate the exact pip command or the environment variable names; Ch0 is where those live, so read it before running anything else. The practical sequence the repository implies is: open the Vercel site or the chapter HTML, read the chapter, then open the matching .py file from the same chapter directory and run it with your own key configured. The directory naming is visible in the README's URLs, for example chapter_09_rag_deepdive, chapter_10_mcp, chapter_15_a2a, chapter_24_observability. If you want to jump straight to a topic rather than follow the layering, those directory names are the navigation. One caveat worth stating: because each chapter is standalone, expect duplicated helper code and repeated client setup across files. That is a deliberate trade for readability, and it means you should not treat any single chapter's helpers as a shared utility layer for your own project.
Where the curriculum is opinionated, and where it thins out
The chapter titles reveal a point of view. Ch20 is titled Context Engineering and lists Context Rot, budget management, XML-structured prompts and Skill.md; that is a stronger claim than 'prompt engineering', and it treats context as a resource with a budget rather than a string you append to. Ch26 splits model routing into four named strategies: threshold, cascade, semantic and cost-aware. Ch28 describes a three-level cache (exact, semantic, LLM) alongside token budget management. These are specific enough to argue with, which is a good sign in teaching material. The thinner areas are the ones where the README gives a topic name and little else. Ch12 mentions OpenClaw architecture, Harness and MultiAgentEval without further explanation in the supplied text. Ch23 covers code agent architecture comparison, CodeAct, ACI, Plan-Execute, SWE-bench and the Agentless finding, which is a lot of surface area for one chapter. Ch29 to Ch36 are cut off in the README excerpt I have, so I cannot describe their content and will not guess. The honest summary is that the first seven layers are documented in enough detail to judge, and the expert layer is not visible in the material provided.
What you give up: no releases, no packaging, and a moving target
The repository has no releases retrieved. That is the single most important operational fact for anyone considering it. There is no version to pin, no changelog to read, and no compatibility promise between the chapter you read last month and the one on main today. The last push recorded is 2026-09-05, and a README badge states an update of 2026.08, so the material is being revised rather than frozen. For a course that is fine, arguably desirable, since the protocols it teaches (MCP, A2A) are themselves moving. For reuse inside a product it is a problem: copying a chapter's retry logic or tracing setup into your codebase means adopting code with no upgrade path and no owner. The MIT licence removes the legal friction for copying, but it does not create maintenance. A second limitation is the interview orientation itself. Ch7 is built around 20 interview questions and a project guide. That shapes what the earlier chapters emphasize: named patterns, comparisons and vocabulary. If your goal is a working agent that handles your specific domain's edge cases, the curriculum gives you the concepts and a runnable starting point, not a hardened implementation. Expect to rewrite the parts that touch your data, your auth and your failure handling.
Alternatives: a framework versus a syllabus, and why the difference matters
The obvious alternative is a framework such as LangChain or LangGraph, both of which appear in Ch4 as material to be studied. The difference in approach is structural rather than qualitative. A framework gives you a maintained abstraction: you install a versioned package, inherit its release cycle and its bug fixes, and accept its opinions about how state and tools are represented. agent-study gives you the reasoning behind those abstractions, written out in a file you can read in one sitting, with no dependency on the project's continued existence. If LangGraph's state machine model changes in a major version, your code migrates or breaks; if agent-study's Ch4 prose drifts from the current LangGraph API, a chapter stops running correctly and nobody is obligated to fix it. The inverse trade also holds: a framework will not teach you why a ReAct loop terminates, and Ch1 will. A second alternative is the official documentation for each protocol and product the course covers (MCP, A2A, the model providers' tool-calling APIs). Those are authoritative and current, and they are the right source when you need an exact schema. They are also unordered and assume context the course supplies. The sensible combination is to use agent-study for the ordering and the mental model, and the official docs for anything you are about to ship.
Maintenance, licensing and what to check before you invest a weekend
The licence is MIT, stated in the repository metadata and shown as a badge in the README. That permits reuse and modification with the licence and copyright notice retained; it does not come with warranty, and it is not legal advice, so read the LICENSE file in the repository root if you plan to ship derived code. On maintenance cost, the material supports one concrete observation: the course tracks fast-moving targets. Ch10 names MCP 2026-07-28, Ch15 names A2A v1.0, and Ch24 compares LangSmith with LangFuse. Each of those is a dependency on someone else's release schedule, and each will age at a different rate. The Python version floor of 3.10+ is the other thing to confirm early, since it constrains which environments can run the chapters unmodified. Before spending a weekend, do three checks in this order. Open the Vercel site and read Ch9 or Ch10, the two chapters the README promotes with its own badges, to see whether the depth suits you. Then find the matching .py file and confirm it runs under Python 3.10+ with your key configured per Ch0. Then look at the last-push date against the protocol versions the chapter cites, and decide whether you are reading current material or history.
Editorial conclusion
Adopt agent-study if you are preparing for agent engineering interviews or want a single repository that walks from a hand-written ReAct loop to MCP, A2A and observability without assembling a reading list yourself. Do not adopt it if you need a supported library with semantic versioning, a changelog and an issue triage process; this is a course, and the repository shows no releases. Before committing time, open the Vercel site and read one chapter end to end, then run its .py file against your own API key to confirm the code matches the prose. Check the Python 3.10+ requirement and the MIT licence in the repository root before you plan to reuse any chapter inside your own product.
Community notes