Awesome Agent Engineering

📚 Course 1: Hand-written RAG (9 lessons)

Follows the real RAG data flow, adding one stage per lesson:

All 9 lessons done 🎉. Each lesson has a principle walkthrough + runnable code + exercises.

🤖 Course 2: Hand-written Agents (9 lessons)

Builds up agent capability layer by layer—each lesson adds one ability (tools → loop → memory → planning → collaboration):

All 9 lessons done 🎉. Each lesson has a principle walkthrough + runnable code + exercises.

🔧 Course 3: Framework Engineering (9 lessons)

Re-implement what you hand-wrote in the first two courses with LangChain / LangGraph, comparing "hand-written vs framework" each lesson:

All 9 lessons done 🎉. Each lesson has a principle walkthrough + runnable code + exercises.

🔀 Course 4: Workflow & Multi-Agent Orchestration (9 lessons)

The first three courses cover "single agent + single flow." This course moves into multi-agent orchestration—a core skill for the AI architect track. LangGraph is the backbone for 6 classic topologies, then CrewAI / AutoGen are used for cross-paradigm comparison on the same problem:

All 9 lessons done 🎉. Each lesson keeps the "hand-written Agent L08 pipeline vs framework multi-agent" side-by-side. The L09 capstone integrates all of L01–L08 and is a résumé-grade piece.

🛡️ Course 5: LLMOps in Production (13 lessons)

The first four courses teach you to build an AI app; this one teaches you to operate it—answering the interviewer's "and after your project goes live? How do you know it's good, defend against attacks, get integrated by other systems, control cost?" All changes land directly on knowledge-base-qa, upgrading it from "running demo" to "ops-ready v2." Four modules, progressively:

All 13 lessons done 🎉. Teaching code.py files are all zero-dependency or have mock fallback paths so they run standalone; production changes go into kb-qa with a "## rollout checklist." Places that can't run real external services (Langfuse / Docker / load testing) are honestly marked as unverified with a fallback path.

📄 Course 6: Multimodal Document Intelligence (10 lessons)

The first five courses built a RAG pipeline that only eats "clean plain text"—but real enterprise knowledge bases are full of scans, tables, and charts, which a text-only pipeline is blind to. This course teaches converged engineering knowledge (document parsing / OCR / table handling have mature industry practices), upgrading kb-qa from "text-only" to a "multimodal document intelligence system v3 that eats scans / tables / charts with citations traceable to page + region." The tone aligns with the ops course (standard practices + trade-offs); every lesson has a "## approach comparison" section. Two through-lines: ① cost-accuracy (every multimodal decision trades cost for accuracy); ② provenance (citations upgrade from chunk text to doc name + page + region).

All 10 lessons done 🎉. Two through-lines: ① cost-accuracy (VLM direct read is expensive but strong, local OCR is cheap but brittle—classification routing is the engineering answer); ② provenance (citations upgrade from chunk text to doc name + page + region, the third step of the credibility trilogy). All new mechanisms default off (enable_multimodal_ingest etc.), existing tests stay green, every lesson has a "## approach comparison" + at least one "design experiment" exercise.

🧠 Course 7: Agent Frontiers (13 lessons)

The first six courses teach converged knowledge (how to chunk for RAG, how to write ReAct). This course teaches not-yet-converged frontiers—agent memory, reflection, Code Agents, trajectory evaluation, context engineering—where the industry has no standard answer. So the style changes: the README doesn't lecture "the standard way," it lays out "which schools of thought exist, what the trade-offs are, and why we picked X…"; the code is "hand-write the core mechanism + a design experiment to test whether it helps." All changes land on research-assistant, growing it from a one-shot "search → write report" system into a cross-session Deep Research Agent v2. Six modules:

All 13 lessons done 🎉. Two through-lines: ① an evaluation main line (L00 sets the baseline → L08 builds the evaluator → L09 harness quantifies every mechanism's gain); ② a context-engineering main line (memory / skills / RAG / MCP unified under the one question "what goes in the window"). Each lesson's README has a "schools of thought" section + at least one "design experiment to validate" exercise. 104 unit tests green; all new mechanisms default-off, with intact fallback paths.

🖥️ Course 8: GUI Agent / Computer Use (13 lessons)

The first seven courses grew research-assistant into a deep agent that thinks—but it only has a brain, no hands: its sole channel to the world is search snippets. This course teaches a frontier that is still unconverged in 2025–2026: letting the agent operate a browser directly (open pages, click, paginate, extract, download), growing research-assistant a pair of hands that are steady, safe, and measurable. The style continues Course 7: READMEs lay out "the three schools of thought (text / vision / dedicated models), their trade-offs, and why we pick X…"; the code is "hand-write the core mechanism + a design experiment to test whether it helps." All changes land on research-assistant; enable_browser defaults to off, and all 123 tests stay green.

All 13 lessons done 🎉. Two through-lines: ① an evaluation main line (L00 bare baseline → L08 mini-benchmark → L11 gains table quantifying every mechanism); ② an observation–action interface main line (L02 observation space → L03 action DSL → L04 loop closure—the context-engineering theme extended to GUI). Each lesson's README has a "schools of thought" section + at least one "design experiment to validate" exercise. Landing adds 19 browser tests to research-assistant (123 total, all green); enable_browser defaults to off with intact fallback paths.

🛡️ Course 9: Agent Production Reliability / AgentOps (10 lessons)

ops-lessons protects a single request (auth, rate limiting, guardrails); this course protects a trajectory—an Agent that loops many times and decides its own next step, so the failure modes are fundamentally different: infinite loops, cost blowouts, fault propagation, dangerous side effects, mid-run crashes. kb-qa is a linear chain that doesn't need these mechanisms; research-assistant is a loop body that can't ship without them—this asymmetry is itself evidence of the boundary. The style follows ops-lessons (teaching "the standard practice + the trade-offs"); each lesson has a "comparison of approaches" section. All changes land on research-assistant, upgrading it from the capable "Deep Research Agent v2" into a production-reliable v3: survives faults, gates dangerous actions, recovers from crashes, and has SLO numbers. Ten modules:

All 10 lessons done 🎉. Two through-lines: ① a blast-radius main line (L00 measures five unbounded failure modes → each lesson bounds one: loops→step-bounded, cost→budget-bounded, faults→degradation-bounded, side-effects→idempotent+approval-bounded, crashes→redo-bounded); ② an autonomy-vs-control main line (every protection trades autonomy/latency/human-effort for safety—too tight and the Agent is useless, too loose and it's reckless; each lesson gives the "when tight, when loose" criterion). Each lesson's README has a "comparison of approaches" section + at least one "design experiment" exercise. Landing adds 96 tests to research-assistant (219 total, all green); all new mechanisms default off with zero tax on clean runs.

🌙 Course 10: Ambient / Always-on Proactive Agents (10 lessons)

The first nine courses build conversational (pull) Agents: a human initiates, the Agent answers, the run ends. This course inverts the paradigm (push): the Agent lives in the background, wakes on schedule, decides what changed in the world, and only interrupts when it is worth your attention. An active 2025–2026 frontier (OpenAI scheduled tasks / Pulse, LangChain ambient agents, Claude Code background tasks all point here). All landings go to research-assistant, upgrading it from "production-reliable v3" to an ambient-proactive v4 that wakes itself, researches only what changed, knows when to speak, and cannot die silently.

All 10 lessons done 🎉. Two through-lines: ① a paradigm-inversion main line (five steps—who initiates / what to research / who diffs / when to speak / who keeps watch—move from human to machine lesson by lesson; "the cron tier ties the baseline on all six metrics" proves inversion ≠ mere timing automation); ② an attention-economy main line (an ambient Agent spends two currencies that belong to others: the user's attention and overnight tokens—grading + quotas + the period wallet make both auditable). Each lesson's README has a "comparison of approaches" section + at least one "design experiment" exercise. Landing adds 112 tests to research-assistant (331 total, all green); all eight switches default off with zero tax on clean runs, and every test runs with zero real waiting (injectable clock).

🧠 Course 11: Agent Harness & Context Engineering (10 lessons)

The first ten courses all rest on a hidden assumption: the context window of a single run is always big enough. Once a task gets long (30 sources, hundreds of tool calls, work spanning sessions), the window becomes the new ceiling: overflow, silent-truncation amnesia, lost-in-the-middle drift, context poisoning. What lifts the ceiling is not a bigger model but a better harness—the real 2025–2026 battleground of the application layer (Claude Code's compaction/memory/subagents/skills, LangChain deepagents, Manus's context engineering, MemGPT). All landings go to research-assistant, upgrading it from "ambient-proactive v4" to a long-haul research v5 that finishes 30 sources inside an 8k window without forgetting, accepts mid-run steering, and remembers you across sessions.

All 10 lessons done 🎉. Two through-lines: ① a window-economy main line (the fourth budget layer—space: every token pays rent to stay in attention; the ledger measures rent, shaping cuts it, compaction reclaims, externalization ends the lease—the same coin as Course 10's attention economy, spent on the model instead of the human); ② an externalization main line (virtual memory: window=RAM, files=disk, compaction=swap, subagents=process isolation, indexes=lazy loading). Killer row: "truncation buys survival, not memory." Landing adds 118 tests to research-assistant (449 total, all green); all nine switches default off with zero tax on clean runs, every test deterministic and reproducible (injectable tokenizer, byte-identical double runs).

Course 12: DeepSeek Harness Hands-On (6 labs + 12 deep-reading chapters)

Third redefinition (2026-08): the simulator version taught our toys; the pure reading-guide version lost to upstream's own docs. This version stands on the only defensible ground — you run, extend, and tear down a real checkout yourself. Pinned at 99f6f02 (rc.7, shared with Course 13); every lab's commands and outputs were executed by the course author on the same SHA, keyless throughout: in Lab 2 you write a 50-line scripted LLM adapter whose scripted model drives the real loop, tool pipeline, and session log (same shape as upstream's own keyless test lane — the system is real; only the model boundary is pluggable, which is exactly dsh's architectural promise).

Course 13: DeepSeek Harness Design-Decision Case Studies (8 cases)

Shares the Course 12 checkout (99f6f02). Every case follows one procedure: dilemma → wounded options → upstream's choice with evidence (source comments, test names, Known Limitations) → hands-on verification → costs → transfer. The signature move is break-it: temporarily remove the decision, run upstream's own test, watch it go red, restore — A05's fail-closed normalization has the author's fully executed transcript (38 green → delete one line → normalizes a rogue non-vocabulary answer to unavailable red with expected 'yolo' to be 'unavailable' → restore → 38 green). Shared method across all eight: among wounded options, pick the one whose harm is reversible.