
This course includes our updated coding exercises so you can practice your skills as you learn.
See a demo
Man reist ja nicht um anzukommen, sondern um zu reisen
AI Engineer Bootcamp 1337 — Learn to Build Real AI Agents
3 free modules. A story-driven journey. And the price only goes up from here.
What you get right now — for free:
Module 1 — Python Foundations — everything you need to start building
Module 2 — LangChain — chains, RAG, memory, MCP, and a full AI assistant
Module 3 — LangGraph — stateful agents, HITL, time travel, multi-agent systems
This isn't just another coding course.
Every lesson is part of a narrative. You're not watching tutorials — you're living a story, solving real problems, building toward something bigger.
Coming soon (and the price rises with each new module):
Microsoft AutoGen / AG2 — multi-agent teams, GroupChat, CaptainAgent
Google ADK + Agent2Agent Protocol (A2A) — production-grade agents that talk to each other across frameworks
DSPy — and much more
Early access = lowest price. The longer you wait, the more you pay.
"I'm genuinely happy you chose this course — and truly grateful for any support you give it."
[Enroll now while it's free →]
Overview: A narrative introduction set in the year 2049—the dawn of Artificial General Intelligence (AGI).
Key highlights:
Follow the story of Triangle, a young developer from New Seoul-7 facing the overnight collapse of the junior tech market.
Discover the origins of his coding journey, starting from a foundational Python course he took at age 13.
Set the stage for "CTF Matrix Hack"—the exact course that laid the groundwork for everything to come.
A narrative introduction to the course. Triangle—a developer who wants to be on the side that patches vulnerabilities, not exploits them—discovers that every path in cybersecurity starts with one fundamental step: learning to code.
Key Highlights:
Direct Access: One author. No team, no marketing—your feedback goes straight to the source.
Community-Driven: Your comments, questions, and insights directly shape future lessons.
Leave Your Mark: Rate the course, drop a comment, ask questions, and share the link.
The first real lesson of "CTF Matrix Hack." Triangle opens the terminal and starts from absolute zero.
Key Highlights:
Variables: Name tags pointing to objects in memory, not physical boxes.
Four Basic Types: int, float, str, and bool.
Operators: Arithmetic, comparison, and logical operations.
Interaction & Formatting: Using f-strings for clean output and input() for user interaction.
Anti-Pattern: == vs is—a classic trap every beginner falls into.
Extra Deep Dive: Integer caching, the floating-point trap, None, inf, nan, and the mysterious ... (ellipsis).
Triangle learns how to make code think and automate repetitive tasks—the absolute foundation of every hacking script.
Key Highlights:
if / elif / else: Branching logic, ternary operators, and evaluation order.
Truthy and Falsy: What Python actually treats as False (spoiler: it's not just False).
The for loop: Iterating ranges, strings, and lists; using enumerate for index and value.
The while loop: Running until a condition breaks; avoiding infinite loop traps.
break and continue: Taking full control of your loop flow.
Anti-Pattern: Never write if is_active == True—it's a massive red flag.
Extra: The little-known for...else and while...else constructs for cleaner search patterns without flag variables.
Triangle digs into the Matrix's data core and learns the two most essential sequence types in Python.
Key Highlights:
Lists: Ordered, mutable collections; append, pop, remove, sort.
Indexing & Slices: [start:stop:step], negative indices, reversing.
Tuples: Immutable sequences; when to use [] vs (); unpacking and value swapping.
List Comprehension: Filter and transform in a single readable line.
Anti-Pattern: Never mutate a list while iterating over it.
Extra: sort() vs sorted(), tuple unpacking in loops, print(*list, sep='\n').
Triangle infiltrates the Matrix's data vault and learns how to map the network using fast lookups and unique collections.
Key Highlights:
Dictionaries: Instant O(1) lookups by key; safe access using .get().
Dict Comprehension: Filtering and transforming data into dictionaries in a single readable line.
Sets: Ensuring uniqueness and performing set theory operations (intersection, union, difference).
Anti-Pattern: The fatal trap of modifying a dictionary while iterating over it.
Extra Deep Dive: Hashability rules, frozenset, and the incredibly useful collections.defaultdict.
Manual hacking is too slow. Triangle learns to write reusable commands—the core building blocks of any real script.
Key Highlights:
Functions: def, return, and naming conventions (always start with a verb).
Parameters & Arguments: Positional, keyword, defaults, *args, and **kwargs.
Scope (LEGB): Local → Enclosing → Global → Built-in; why global is a strict anti-pattern.
Lambda Functions: For clean one-liners in sorted(), filter(), and map().
Anti-Pattern: Mutable default arguments—one of Python's sneakiest traps.
Decorators: Wrap any function with logging, timing, or access checks using @.
Extra: Keyword-only arguments with * and positional-only arguments with /.
Deep in the Matrix, system agents start pushing back—and they show up as errors. Triangle learns to write resilient code that doesn't crash under pressure.
Key Highlights:
EAFP vs LBYL: Why Python favors "try it and catch the error" over "check before every step."
try / except / else / finally: The full block structure and when to strictly use each part.
Common Exceptions: ValueError, TypeError, ZeroDivisionError, KeyError, FileNotFoundError, and more.
raise: How to manually trigger exceptions for input validation.
Custom Exceptions: Building an exception hierarchy (HackError → AccessDeniedError) for meaningful error messages.
Anti-Pattern: The bare except: pass—Python's silent bug killer.
Extra Deep Dive: The exception hierarchy from BaseException, and exception chaining using raise ... from.
Hacked data lives only in RAM—close the program and it's gone. Triangle learns how to save and load data that actually persists.
Key Highlights:
with open(): The only correct way to open files; auto-closes even on error.
File Modes: "r", "w", "a", "x", "r+", and exactly what they do.
Reading: read(), readlines(), and for line in f (the best approach for large files).
Writing: write(), writelines(), and why you must always append \n manually.
CSV: csv.DictWriter and DictReader for handling flat tabular data.
JSON: json.dump and json.load for complex, nested structures.
Anti-Pattern: Skipping encoding="utf-8"—the silent UnicodeDecodeError trap on Windows.
Extra Deep Dive: pathlib—modern, object-oriented path handling.
Deep in the Matrix's core, simple scripts no longer cut it. Triangle learns to build sophisticated digital weapons using the full OOP toolkit.
Key Highlights:
The Four Pillars Encapsulation, Abstraction, Inheritance, and Polymorphism, plus the power of duck typing.
Classes Mastering class, __init__, and self; understanding attributes vs. methods.
Magic (Dunder) Methods Tapping into __str__, __repr__, __add__, __eq__, and the broader ecosystem.
Inheritance Implementing super().__init__(), method overriding, and isinstance() checks.
Composition vs. Inheritance "Has-a" vs. "is-a" relationships; why composition is often the superior architectural choice.
Class vs. Instance Attributes Navigating a frequent source of logic bugs.
Anti-Pattern The "God Class"—avoiding the trap of a single class that does everything.
Extra Tech Leveraging @property, __slots__, and @dataclass.
Everything from nine lessons converges into one project. Build a complete, coherent system—not a collection of scripts.
Goal: A console app that manages network nodes, deploys viruses, analyzes the network, and logs everything.
Architecture: Node, Virus, StealthVirus, and MatrixCoreHacker controller—all connected.
New Tools: random, datetime, and PermissionError.
5 Build Steps: Data classes → controller → automation + analytics → file I/O → demo.
Quality Checklist: __str__/__repr__, with statement + encoding, specific except blocks, no code duplication, lambda usage, and sets.
This is the closing narrative of the Matrix Coders Python course.
Triangle enters a new world of cutting-edge research and meets Joy, an architecture specialist who reveals the true future of the industry: the AI Engineer.
Triangle transitions from simple coding to mastering neural architectures, embracing a philosophy that defines the journey of an AI Engineer.
Triangle spends an all-nighter at the library diving into the world of autonomous agents, realizing that building them requires more than just code—it requires a perfectly tuned environment.
Triangle discovers that in 2026, an IDE is no longer just a text editor—it's a mission control center for a team of autonomous AI agents.
Joi introduces Triangle to uv, a blazingly fast Rust-based package manager. They explore how it replaces pip, venv, pyenv, and poetry with a single unified binary.
Key Highlights:
Why You Need uv Escaping the fragmented Python ecosystem and dramatically speeding up dependency installs.
Installation Setting up uv seamlessly across macOS, Linux, and Windows environments.
Key Commands Mastering uv init, uv add, uv run, and more.
Lockfiles and Reproducibility Understanding how uv.lock and pyproject.toml guarantee cross-platform reproducibility.
Anti-Pattern Naked pip installs without lockfiles—why unpinned dependencies break production.
Joi explores OpenRouter—the unified gateway to hundreds of LLMs. She learns what an API is, how to structure a project securely using uv and .env, and writes her very first script to send a HumanMessage to the AI.
Key Highlights:
APIs Explained Understanding the restaurant analogy for APIs and how REST communication works.
The Power of OpenRouter Why a single endpoint and API key beats installing separate SDKs for OpenAI, Anthropic, and Google.
Secure Environment Setup Initializing a project with uv and keeping API keys out of code using .env.
The First Request Writing a script with ChatOpenAI and HumanMessage to invoke a response directly from the terminal.
Anti-Pattern Hardcoding API keys—why committing keys directly into a script is a critical security flaw.
Joi explains the core architecture driving modern AI, exploring how Transformers overcome the limitations of recurrent networks and how Prompt Engineering acts as the steering wheel for these massive models.
Key Highlights:
The Transformer Architecture Understanding self-attention to see how models process context all at once.
The Birth of GPT The evolution from pre-training and fine-tuning to the crucial role of RLHF.
Prompt Engineering Strategies Mastering Zero-shot, Few-shot, Chain-of-Thought (CoT), and Role prompting to control model outputs.
The Golden Rule "Garbage in, Garbage out"—why precise context is non-negotiable.
Anti-Pattern Naked prompts without context—why contextless queries yield unpredictable results.
Triangle and Joi put theory into practice, comparing different prompting levels on the same problem. They discover how structural variations radically change model behavior and output quality.
Key Highlights:
Four Levels of Prompting Comparing Zero-shot, Role prompting, Few-shot, and Chain-of-Thought on a single prompt.
Prompt Templates Utilizing PromptTemplate and ChatPromptTemplate to build reusable, scalable inputs instead of string concatenation.
Advanced Templates + LCEL A first look at the | operator by chaining prompt, LLM, and parser.
Intent Classifier Using FewShotChatMessagePromptTemplate to route agent tasks based on user intent.
Anti-Pattern Hardcoded prompts versus templates—why string concatenation fails at scale.
Deep into the night, Triangle and Joi explore LangChain's core. They dive into LCEL (LangChain Expression Language), learning how to pipe models, prompts, and parsers together to build robust, asynchronous AI pipelines.
Key Highlights:
What is LangChain? Moving beyond single model calls to a framework of standard Runnable blocks.
LCEL Fundamentals The power of the | operator to create declarative, clean processing chains.
Four Levels of LCEL Progressing from manual API calls to dynamic prompts and integrated token streaming.
Behind the Pipe Why LCEL gives you asynchronicity, streaming, and batching out of the box.
Anti-Pattern Manual concatenation of prompts and responses instead of relying on the streamlined LCEL pipeline.
Triangle learns to tame unstructured text. Using Pydantic v2 and with_structured_output, he forces the LLM to output predictable, validated JSON objects, transforming the model from a text generator into a reliable data source.
Key Highlights:
Structure Out of Chaos Why raw text is bad for applications and how JSON schemas solve the problem.
Pydantic Basics Defining robust data models and nested structures using Python type hinting.
Modern Structured Output Using with_structured_output() versus the legacy PydanticOutputParser.
Function Calling API How modern models use native function calling to guarantee schema compliance.
Anti-Pattern Relying on fragile regular expressions to parse unstructured LLM text instead of native structured outputs.
At 3:00 AM, Triangle tackles the hallucination problem. He builds a RAG (Retrieval-Augmented Generation) pipeline, letting the model "read" external documents by converting texts into numerical embeddings and querying a vector database.
Key Highlights:
Embeddings & Vector Search Converting meaning into mathematics to enable semantic similarity search rather than keyword search.
The RAG Architecture Breaking down the process: Indexing (chunking, embedding, storing) and Retrieval + Generation.
Chunking Matters Exploring RecursiveCharacterTextSplitter and understanding how chunk size prevents the "Lost in the Middle" problem.
Document Loaders & Chroma DB Using LangChain tools to parse PDFs, CSVs, and web pages into a local vector database.
Anti-Pattern Relying on fragile keyword search instead of robust semantic search for unstructured data.
As dawn approaches, Triangle realizes his RAG bot has severe amnesia. He learns to manage context windows, exploring Buffer, Window, and File memory strategies to give the LLM the ability to recall past conversations.
Key Highlights:
The Stateless Model Understanding why LLMs don't remember and how MessagesPlaceholder bridges the gap.
Three Memory Strategies Comparing Buffer Memory, Window Memory (trim_messages), and persistent File Memory.
Managing Token Budgets Why memory isn't infinite and how to prevent context window overflow.
RunnableWithMessageHistory Mastering the LangChain standard for automatically injecting session history into LCEL chains.
Anti-Pattern Unbounded buffer memory—why letting context grow infinitely leads to high costs and degraded performance.
Triangle moves from static reasoning to dynamic action, giving his model "hands." He learns to use the @tool decorator and the ReAct architecture to build autonomous agents capable of performing math, checking time, and writing to files.
Key Highlights:
Why Tools are Needed Giving LLMs the ability to reach outside their isolated text generation environment.
Defining Tools Using the @tool decorator to turn ordinary Python functions into AI-accessible utilities.
The ReAct Cycle Understanding the Reason+Act loop where models continuously evaluate, tool-call, and observe.
Building an Agent Writing a manual ReAct loop to chain multiple tool calls together to solve complex queries.
Anti-Pattern Infinite agent loops—why failing to set max_iterations leads to runaway token consumption.
At 4:15 AM, Triangle discovers MCP, Anthropic's universal tool standard. Instead of rewriting tools for every new framework, he builds a single FastMCP server to expose his functions to LangChain, Cursor, and any other MCP-compatible client.
Key Highlights:
Write Once, Run Anywhere Understanding the Host-Client-Server Model Context Protocol architecture.
Building an MCP Server Using fastmcp to expose standalone tools (e.g., calculator, weather, currency converter) outside the LLM loop.
Connecting an MCP Client How LangChain dynamically converts MCP schema definitions into native StructuredTool objects.
Cross-Platform Agent Building a ReAct loop that uses tools securely running in a separate MCP server process.
Anti-Pattern Framework lock-in—developing duplicate tool implementations for LangChain, OpenAI, and Cursor instead of using one universal MCP server.
Morning breaks. Triangle combines everything he's learned into a capstone project: a fully autonomous research assistant. By integrating web search, HTML cleaning, Pydantic validation, Chroma DB, and a multi-stage LLM fallback mechanism, he builds a miniature version of Perplexity AI.
Key Highlights:
The Architecture Building a multi-stage pipeline: Search → Validate → Save → Query → Fallback.
HTML Cleaning & Token Budgeting Using regex to format raw web pages to fit efficiently into the context window.
Validation with Few-Shot Using with_structured_output and examples to programmatically reject junk content.
Intelligent Note Retrieval Searching the local vector database first, then automatically falling back to live web searches when answers are missing.
Tying it All Together Creating a production-ready CLI loop that acts as an end-to-end research workflow.
After an intense fourteen-hour night, Triangle reflects on his journey. From raw API calls to fully functional autonomous agents, he reviews the foundational patterns of LangChain and sets his sights on the next frontier: multi-agent orchestration.
Key Highlights:
The Journey A recap of the thirteen foundational lessons and the progression of Triangle's AI engineering skills.
Core Toolkit A summary cheat sheet of the essential building blocks: LCEL, RAG, Memory, and Agents.
Key Patterns Map Quick-reference code snippets for the most important LangChain implementations.
The Architecture Wall Recognizing the limitations of a single, all-in-one generic ReAct agent.
What’s Next? A glimpse into LangGraph—transitioning from linear cycles to complex, stateful multi-agent workflows.
Joi reflects on the limitations of linear prompt chains, realizing that robust AI agents require a cyclical, dialogic mindset. Setting the stage for LangGraph, she prepares to evolve from building simple pipelines to crafting intelligent, self-correcting neural systems.
Key Highlights:
Breaking the Linear Paradigm Recognizing that "lines" and "rails" frequently collapse under complex user interactions.
The Shift to Graphs Adopting nodes and edges to build systems capable of recursive logic and self-evaluation.
From Pipelines to Nervous Systems Transitioning from structural skeletons into self-aware, active agents capable of reasoning.
Joi moves away from linear LCEL chains and introduces LangGraph. She learns how to build state machines with nodes, edges, and persistent state, creating her very first Hello Node graph.
Key Highlights:
When Linearity Fails Why static chains like prompt | llm | parser are insufficient for cyclic agent behaviors.
The Anatomy of a Graph Understanding State (the agent's backpack), Nodes (crossroads/actions), and Edges (conditional routing).
The Hello Node Building the foundational graph structure using StateGraph, START, and END.
Visualizing with Studio Setting up LangSmith to visually trace and debug the graph's execution.
Anti-Pattern Writing single linear scripts with nested if-else statements instead of modular, graph-based routing.
Joi addresses state overload by learning encapsulation in LangGraph. She implements strictly enforced InputState and OutputState schemas, alongside PrivateState to securely route sensitive intermediate data through the nodes, avoiding data leaks.
Key Highlights:
The Problem of Global State Why a monolithic, shared state turns into a messy "courtyard" and risks internal data leakage.
Encapsulation Layers Breaking down state into Input, Output, Overall, and Private schemas to enforce strict data contracts.
Building a Secure Graph Creating a graph that classifies queries and performs internal searches without leaking raw logs to the user.
TypedDict vs Pydantic When to use lightweight type definitions inside the graph versus robust run-time validation on the edges.
Anti-Pattern Dumping everything into a single shared state dictionary instead of separating input/output boundaries.
Joi realizes that a graph without tools is just a philosopher. She integrates external functionality using @tool and ToolNode, builds a ReAct loop, and connects to an MCP (Model Context Protocol) server to dynamically provide an agent with a calculator and weather data.
Key Highlights:
Brain in a Vacuum The three limitations of vanilla LLMs: halluciations in math, lack of reality access, and static cutoff dates.
The ReAct Loop Understanding Reasoning + Acting and how LangGraph handles it with ToolNode and tools_condition.
MessagesState Leveraging the built-in LangGraph state schema for conversational agents.
Model Context Protocol (MCP) Connecting to separate, scalable tool servers via FastMCP and langchain_mcp_adapters.
Anti-Pattern Writing manual rule-based loops to check for tool calls instead of using the robust, standard tools_condition.
Joi upgrades her graph by executing independent nodes concurrently. She moves beyond static parallelism (Fan-out/Fan-in) and discovers the Send API, unlocking dynamic Map-Reduce scaling where the graph spawns parallel workers based on real-time data needs.
Key Highlights:
The Bottleneck of Sequential Logic Why forcing an agent to wait for independent tasks wastes time and resources.
Supersteps and Reducers How LangGraph intelligently executes parallel nodes and safely aggregates results using Annotated reducers.
Static Fan-out/Fan-in Running pre-defined branches simultaneously, like querying a web search and a database at the same time.
Dynamic Send API (Map-Reduce) Using Send objects to dynamically generate an unknown number of identical worker nodes on the fly.
Anti-Pattern Passing the entire global state into every spawned worker instead of using minimal, encapsulated private states.
Joi explains why linear agents are unsafe for production. She designs a guarded pipeline featuring custom conditional routing, a prompt injection firewall, and a peer-review loop where one LLM critiques the draft generated by another, incorporating a strict retry counter to prevent infinite loops.
Key Highlights:
The Open Gate Problem Why a naive linear pipeline blindly accepts malicious prompts and outputs unchecked responses.
Custom Conditional Edges Moving beyond tools_condition to route graph execution based on arbitrary state variables (like safety checks or quality approvals).
Guarding the Entry Implementing a guard_node combining heuristic keyword filtering and LLM classification to defeat prompt injection.
Reviewer Cycle Cultivating a "writer-reviewer" dynamic where poor drafts are iteratively corrected.
Anti-Pattern Coding an infinite loop without a retry counter, which inevitably crashes the system or exhausts the rate limit.
Joi addresses the amnesia inherent in default LLM architectures by integrating persistent memory layers. She implements both short-term per-thread memory via Checkpointers and long-term cross-thread user profiles using Stores to craft an agent that genuinely remembers its users.
Key Highlights:
Amnesia by Default Why stateless LLM sessions destroy continuity and hinder complex tasks.
The Memory Dual-Layer Understanding the distinct roles of the short-term Checkpointer (per-thread) and the long-term Store (cross-thread).
Implementing Persistence Transitioning from volatile InMemory backends to robust persistent databases like SQLite, PostgreSQL, and Redis.
Smart Extraction Employing an LLM to actively curate and update structured user profiles dynamically rather than indiscriminately dumping all chat logs.
Anti-Pattern Bloating the Store with raw conversation logs instead of isolating and saving actionable semantic facts.
Key Concepts:
Human-in-the-Loop (HITL) Pausing the graph before critical operations using interrupt() to request explicit user approval.
Time Travel Using get_state_history() to retrieve past checkpoints and update_state() to roll back to any previous state for replay or correction.
Conditional Routing Using Command(goto=...) to dynamically redirect the graph flow based on human feedback.
Anti-Pattern Running agents with full tool access without approval gates, creating a "ticking time bomb" scenario.
Key Concepts:
Subgraphs as Nodes Treating compiled StateGraph instances as single, reusable nodes within a larger parent graph.
State Encapsulation Each subgraph maintains its own private State (TypedDict), isolated from the parent's global state.
Wrapper Functions Using adapter functions to map data between the parent's State schema and the subgraph's private State schema.
Shared vs Private Keys Understanding how overlapping keys are automatically mapped, while private keys remain isolated within the subgraph.
Independent Checkpointers Option to compile subgraphs with their own checkpointers for independent history and time travel.
Key Concepts:
Supervisor Pattern A central coordinator agent that receives tasks and delegates them to specialized sub-agents, maintaining overall control.
Swarm Pattern A decentralized network of agents that communicate and transfer tasks directly to each other using handoff tools, without a central coordinator.
Handoff Tool A special tool that enables an agent to transfer control of a task to another agent, passing along the necessary context.
Scalability Trade-off Supervisors scale linearly with task complexity (more agents = more coordination overhead), while Swarms scale near-linearly (more agents = more parallelism).
Complexity Trade-off Supervisors are easier to debug and control due to centralized logic, while Swarms are more flexible and fault-tolerant but harder to manage.
Joi and Triangle meet to discuss the final project: an AI Dev Team. They learn how to put all the LangGraph concepts together into a real working pipeline with strict separation of agent roles, RAG collections, and human validation.
Key Highlights:
Agent Pipeline Why one monolithic agent fails and how separating responsibilities across PM, Researcher, Architect, and Dev improves results.
Shared File System Memory Using the local file system instead of large state contexts for passing artifacts between agents.
Specialized RAG Collections Isolating code, research, and plans into separate ChromaDB collections for targeted querying.
Human-in-the-Loop Review Implementing interrupt() along with Command(goto=...) at every stage for human validation and rollback.
Parallel Research Orchestrating fan-out and fan-in data flows with the Send API for concurrent worker agents.
Joi and Triangle review their journey through the LangGraph module. They summarize the key concepts learned, from basic state graphs to multi-agent pipelines with Human-in-the-Loop, before preparing for the next module.
Key Highlights:
Course Recap Reviewing all major LangGraph concepts including conditional routing, parallelism, memory, and specialized agent networks.
The Final Project Reflecting on the assembly of a complete working pipeline utilizing RAG, Tavily, and the Send API.
Looking Forward Setting the stage for the transition from the LangGraph philosophy to AutoGen.
This lecture unpacks Harness Engineering: the emerging discipline that transforms a raw language model into a production-grade coding agent. From the nine core components every Harness must have, to a map of 30+ tools dominating 2026, Joi learns that architecture matters as much as the model itself.
Key Highlights:
The Harness Defined What separates a chatbot from an agent — and why LLM is the brain, but Harness is the body, hands, operating room, and assistant combined.
Harness ≠ Framework Why confusing building materials with a finished house is an expensive mistake — and where LangChain, LangGraph, and Claude Code each sit on the spectrum.
The 9 Components A deep dive into While-Loop Engine, Context Engineering, Tools + Registry, Skills, Subagent Management, Memory, Dynamic Prompt Assembly, Lifecycle Hooks, and Permissions.
Context Rot The silent killer of agentic systems — how a poor Harness lets the task drown in noise, and three techniques (compaction, retrieval, prefix caching) that fight it.
Guides vs Sensors Martin Fowler's two classes of lifecycle hooks: feedforward controls that act before (specs, AGENTS.md) and feedback controls that react after (linters, tests, compilers).
The Core Paradox The same Claude Opus scores 77% in OpenCode and 93% in Cursor. The only difference is the Harness — proving architecture outweighs model choice.
The 2026 Tool Map 30+ tools across CLI, AI-native IDEs, cloud autonomous agents, OSS BYOK, and the often-ignored Chinese players — each representing a distinct Harness philosophy.
Lecture Title: Pi Coding Agent: Installation, Setup, and First Run
Description:
This lecture walks you through everything you need to get the Pi coding agent up and running from scratch. You'll install Pi globally via npm, configure a provider (Anthropic, OpenRouter, Nvidia, or a free-tier option), set up auth.json and settings.json, create your first AGENTS.md, and run a real agentic session — all step by step.
Key Highlights:
Installation One command installs Pi globally: npm install -g @mariozechner/pi-coding-agent. Node.js 18+ is the only prerequisite.
Three Auth Options OAuth login for Claude/ChatGPT/Copilot subscribers, API key via environment variable, or the recommended ~/.pi/agent/auth.json for ongoing work.
Provider Choice Anthropic direct, OpenRouter (300+ models, one key), or Nvidia — each with a ready-to-use JSON config snippet. Free-tier models included.
settings.json Global vs. project-level config, thinking levels (minimal → xhigh), and compaction parameters explained.
Pi File Structure How ~/.pi/agent/ and .pi/ in the project root interact — and the hierarchical loading order for AGENTS.md.
First Session The official recommended first prompt (Summarize this repository), what the Footer numbers mean, and when to call /compact.
Five Launch Modes Interactive, print (-p), JSON, no-session, and resume (-c, -r) — Pi is a platform, not just a TUI.
Common Problems Windows bash issues, 401 auth errors, AGENTS.md not loading, context overflow, and infinite loops — with concrete fixes.
Lecture Title: Pi Architecture from the Inside: Four Packages, One Agent
Description:
This lecture cracks open the pi-mono monorepo and traces every prompt from your keyboard to the LLM and back. You'll understand why Pi tops Terminal-Bench 2.0 with just 4 tools and a ~200-token system prompt, how the ReAct loop works in ~40 lines of TypeScript, and why session branching is a superpower most developers ignore.
Key Highlights:
The Four-Package Monorepo pi-ai (LLM abstraction) → pi-agent-core (agent loop + events) → pi-tui (terminal UI) → pi-coding-agent (the complete product). Each layer is independently usable.
Cross-Provider Context Handoff pi-ai normalizes every LLM API into one Context JSON array — so you can start a conversation with Claude and finish it with GPT or Gemini without losing history.
The ReAct Loop Think → Act → Observe → Repeat, implemented in ~40 lines. Walk through a 4-turn example: reconnaissance, structure analysis, implementation, verification.
16 Event Hooks Every step of the loop emits typed events (text_delta, tool_execution_start, agent_end, …) — the foundation for Extensions, logging, and real-time monitoring.
4 Tools > 20 Tools Why fewer tools yield sharper decisions — and the benchmark proof: Pi (#1) vs. Claude Code and OpenCode on Terminal-Bench 2.0.
~200-Token System Prompt The full structure of Pi's system prompt revealed. No excessive rules — because modern models are smart enough. Context belongs in AGENTS.md.
Session Tree vs. Linear History JSONL branching lets you experiment without losing work. /fork, /clone, /tree — and how to resume any point in history.
Compaction How Pi automatically summarizes old context before the window fills, and when to trigger it manually with /compact.
Lecture Title: AGENTS.md — The Agent's Living Instruction File
Description:
This lecture shows you how to turn a generic AI model into a project-aware teammate using a single Markdown file. Backed by peer-reviewed research (arXiv:2602.11988), you'll learn the five-section anatomy of an ideal AGENTS.md, the five anti-patterns that make it worse than useless, and how to keep it alive across the project lifecycle.
Key Highlights:
What AGENTS.md Does Without it the agent is a smart stranger. With it — an experienced teammate who knows the stack, conventions, off-limits zones, and how to verify its own work.
The Science A February 2026 arXiv study: a well-written AGENTS.md raises task success by 18–34%. A poorly written one performs worse than having none at all.
The Hierarchy Global (~/.pi/agent/) → parent directories → project root → sub-directory. All files merge; the closest one wins on conflicts.
The Golden Rule Write only what the agent cannot discover on its own — commands, constraints, non-obvious architectural decisions, and environment quirks.
The Five-Section Template Stack & Environment / Commands / Architecture & Structure / Rules & Conventions / Context & Quirks — with real-world examples for Python (FastAPI), TypeScript (Fastify), and monorepos.
Five Anti-Patterns Too long, stating the obvious, stale context, contradictions, and missing commands — each one explained with a concrete bad example.
Dynamic Updates Ask the agent to update AGENTS.md mid-session, then /reload — no restart needed. Changes apply on the very next request.
The 150-Line Rule Why AGENTS.md must fit within 150–200 lines, and a prompt to have Pi generate the first draft for any project.
Lecture Title: Skills — Books on the Shelf: On-Demand Modular Instructions for Pi
Description:
This lecture introduces Pi Skills: self-contained capability packages that load into context only when relevant, keeping AGENTS.md lean and every request cost-efficient. You'll build a full multi-file skill with Python scripts, a Gantt chart generator, and prompt templates — then learn when Skills, AGENTS.md, and Slash Commands each belong.
Key Highlights:
The "Books on the Shelf" Model AGENTS.md is what the agent knows by heart. Skills are reference books it pulls only when the task matches — fewer tokens per request, less noise, better quality.
Skill Anatomy A SKILL.md file with YAML frontmatter (name, description, allowed-tools, metadata) plus optional scripts/, assets/, and references/ directories following the Agent Skills specification.
How Pi Selects Skills For every request Pi makes a fast secondary LLM call to match the request against each skill's description field — the single most important field to write well.
Storage Hierarchy ~/.pi/agent/skills/ (global) and .pi/skills/ (project), with arbitrary nesting by topic (api/, devops/, testing/) for large projects.
Hands-On: time-estimator Skill A complete worked example: task JSON → calculator.py (schedule) → gantt.py (matplotlib PNG) → report via a prompt template. Full source included.
assets/ and references/ Best practices for storing runtime media/templates vs. documentation — keeping skills self-contained and portable.
Manual Skill Invocation /skill:time-estimator — when and why to force-load a skill instead of relying on auto-detection.
Skills vs. AGENTS.md vs. Slash Commands A decision tree: always-needed info → AGENTS.md; task-type-triggered → Skill; explicit per-call action → Slash Command.
Curated Skill Libraries badlogic/pi-skills, VoltAgent/awesome-agent-skills (1000+ skills from Stripe, Cloudflare, Vercel, Figma, and more), and agent-skills.cc aggregator.
Lecture Title: Slash Commands (Prompt Templates) — Macros for Repetitive Tasks
Description:
This lecture teaches you to build your own library of /review, /test, /commit, /pr, and /debug commands — Markdown files that Pi transforms into callable slash commands with bash-style argument substitution. You'll also implement the sub-agent pattern: launching a child Pi process to isolate heavy analysis from the main context.
Key Highlights:
Two Types of Slash Commands Built-in Pi commands (/compact, /model, /reload) vs. Prompt Templates — your own Markdown files that become /filename commands.
Template Anatomy YAML frontmatter with description (shown in autocomplete) and argument-hint, followed by the prompt body. Intentionally minimalist.
Bash-Style Variables $1, $2, $@, ${@:2} — full argument substitution, demonstrated with /review, /component, and /commit examples.
Storage Locations ~/.pi/agent/prompts/ for personal global macros and .pi/prompts/ for project-specific commands that belong in the repo.
Ready-Made Template Library Six complete templates — explain.md, docs.md, review.md, test.md, debug.md, commit.md (Conventional Commits + auto-branch ai), pr.md (merge to test, push, PR description).
The Sub-Agent Pattern Launch pi --print --no-tools --thinking off -p "..." as a child process inside a skill. The child reviews code in a clean context; only a structured summary returns to the main agent — preserving the token buffer.
code-review-subagent Skill Full implementation: SKILL.md + assets/review-prompt.md + prompts/code-review-summary.md. Diagram of the main → child → summary pipeline included.
Advanced Frontmatter Unofficial model: and thinking: fields via the pi-prompt-template-model extension — switch to a cheap fast model for mechanical tasks automatically.
Lecture Title: Extensions API — TypeScript Hooks for Pi
Description:
This lecture crosses the line from content configuration into engine-level engineering. You'll write TypeScript Extensions that hook into Pi's full lifecycle — adding custom tools, slash commands, UI status indicators, safety guards, and even calling a LangGraph agent as a native Pi tool, all wired through the ExtensionAPI interface.
Key Highlights:
Extensions vs. Skills/Commands Skills and Slash Commands change what the model says. Extensions change how the agent itself works — middleware, custom nodes, and observability at the engine level.
Auto-Discovery Pi scans ~/.pi/agent/extensions/ and .pi/extensions/ for *.ts or */index.ts files automatically — no manual registration needed for local extensions.
ExtensionAPI: Five Blocks lifecycle (subscribe to all agent events), tools (register callable functions), commands (custom /commands + hotkeys), ui (status bar, notifications, editor buffers), provider (switch model/provider at runtime).
Quick Start: tool-logger A minimal real extension — counts tool calls per session and updates the Footer in real time. Three lifecycle events, ~15 lines of TypeScript.
Custom /todo Command A two-file extension (index.ts + todo.ts) that runs git grep for TODOs and loads results into Pi's editor buffer — with proper error handling for "no matches" vs. "git error".
Safety Guard Pattern Intercept every tool_call_start event, inspect the bash command, and call event.cancel() to block rm -rf and other dangerous commands before they execute.
Auto-Test Hook On every turn_end that included a write or edit, automatically run pytest -q and notify success or failure in the TUI — a feedback sensor in Martin Fowler's sense.
LangGraph Integration Register a Pi tool that POSTs to a local FastAPI server running a LangGraph agent — Pi calls the workflow, renders progress, and returns the result in the main TUI context.
This lecture explains why the next step after prompt engineering and context engineering is harness engineering: building a system that constrains, informs, validates, and corrects AI coding agents automatically. It introduces Archon as an open-source workflow engine for AI coding, shows how commands and YAML workflows work in practice, and connects the idea to real reliability gains in multi-step software development.
Key Highlights:
Three Eras of AI Interaction — Prompt Engineering focused on phrasing, Context Engineering focused on feeding the right repository knowledge, and Harness Engineering focuses on reliable systems around the agent.
What Archon Is — Archon is a workflow engine for AI coding agents and is presented as the first open-source harness builder for AI coding.
Commands as Atomic Units — In Archon, a command is a Markdown file in .archon/commands/ that gives the AI one focused task.
Workflows as Reproducible Pipelines — A workflow is a YAML file in .archon/workflows/ that executes nodes in dependency order and can combine planning, implementation, validation, review, and self-correction.
Fresh vs Shared Context — Archon supports context: fresh for independent verification steps and shared context for continuation steps.
Parallel Reviews — Multiple review nodes can run concurrently after validation, each in a fresh AI session.
Artifacts and Variables — Commands can use variables like $ARGUMENTS, $ARTIFACTS_DIR, and positional inputs such as $1, $2, $3.
Reliability Over Raw Chat — The lecture frames Archon as the layer above a coding agent that turns one-off prompting into repeatable engineering workflows.
By 2026, the word agent has come to mean everything: an LLM with tools, a node in a graph, a module in a multi-agent system, a coding assistant config. This lecture cuts through the marketing noise with a clean four-layer taxonomy. You will walk away with a clear map of the tooling landscape and a reliable answer to the question: which layer am I building, and which tool should I reach for?
Key Highlights:
Four System Layers — Model Layer (the LLMs themselves) → Agent Layer (one smart worker with tools) → Harness / Orchestration Layer (the system that manages agents and the process) → Product Layer (the CLI, IDE, or UI where it all lives).
Pi: Terminal Minimalism — A single-agent terminal harness. One developer, one project, deep inline editing with diffs and skills. Ideal for focused terminal work.
Archon: Command Center — YAML workflows that orchestrate coding agents across plan → implement → test → review → approve → PR. Available from CLI, Web UI, Slack, Telegram, and GitHub.
LangGraph: The Graph Orchestrator — Stateful multi-agent workflows with typed state, checkpoints, time-travel debugging, and LangSmith observability. Not coding-specific.
ADK: Enterprise Multi-Agent — Google's production platform for large-scale agent systems on Vertex AI and Google Cloud with A2A protocol support.
Pi vs Archon — Pi is your personal terminal interface; Archon is the automation layer above it. In this module, Pi acts as the assistant inside an Archon workflow.
Decision Framework — One developer in a terminal → Pi. Repeatable coding pipeline for a team → Archon. General agentic systems beyond code → LangGraph/ADK. Google Cloud enterprise context → ADK.
This lecture walks you through spinning up Archon in Docker, wiring it to Pi and OpenRouter, registering a practice project, and launching your first read-only workflow that builds a plan without touching a single file. You will leave with a working local Archon instance and a clear mental model of how Docker, environment variables, and YAML workflows connect.
Key Highlights:
Docker-First Setup — The primary practical path for this course. No local Node install required; one docker compose command starts everything.
Environment Variables That Matter — CLAUDE_USE_GLOBAL_AUTH=false, PI_CODING_AGENT_DIR, DEFAULT_AI_ASSISTANT=pi, and DATABASE_URL explained in plain terms.
Pi as the Default Assistant — How to wire Pi through OpenRouter as the underlying coding agent inside Archon, including the global .archon/config.yaml.
Registering a Project — How Archon maps a container-side path to your codebase, and why /.archon/projects/ is the right place to start.
plan_only Workflow — Your first YAML workflow: allowed_tools: [] keeps the agent read-only, worktree.enabled: false simplifies the learning scenario, and interactive: true lets you watch execution live in the Web UI.
Best Practices at Install Time — Separate experiments from real projects, start with read-only scenarios, verify API limits before bulk runs, and document every workflow.
This lecture takes you from a read-only planning workflow to a full three-node pipeline that generates code and verifies it automatically. You will build a DAG that plans a Python calculator, implements it in two files, and runs pytest in a deterministic bash node — no manual copy-pasting required. Along the way you will learn the five node types in Archon, how depends_on and context: fresh wire nodes together, and how Dockerfile.user extends the base image with Python and pytest.
Key Highlights:
DAG Fundamentals — Nodes, edges (depends_on), parallelism, and conditional loops: how Archon models a workflow as a directed acyclic graph.
Five Node Types — prompt, bash, script, loop, and approval — and when to use each one.
$plan.output Variable Injection — Pass the output of one node directly into the prompt of the next without any glue code.
context: fresh — Start a brand-new AI session at a node so it evaluates the situation independently, without inheriting previous history.
allowed_tools and output_format — Lock the agent to only Read and Write, and enforce a structured JSON response that Archon validates.
retry with on_error: all — Automatically retry the implement node up to three times on any error.
Dockerfile.user — Extend the base Archon image with Python and pytest using a two-file override pattern.
Hybrid Model — AI where generation is needed, deterministic shell where verifiability is needed.
A linear workflow is great when everything passes on the first try. But in real development, the agent writes code, tests fail, you copy the error back into chat, the agent tries again. This lecture moves that manual cycle into the workflow itself. You will build a loop node that automatically runs "fix → verify" iterations until pytest goes green — and you will learn every knob that controls it: until, until_bash, fresh_context, $LOOP_PREV_OUTPUT, and max_iterations.
Key Highlights:
Loop Node Model — Each iteration is a full AI run with tool access. The loop exits on the first satisfied condition: LLM completion signal, deterministic bash exit code 0, or max_iterations reached.
until: ALL_GREEN — How the agent signals completion with a structured tag inside its text response.
until_bash — A shell check that runs after every iteration and is completely independent of the LLM.
fresh_context: true — Why starting each iteration with a clean AI session prevents context drift and confirmation bias.
$LOOP_PREV_OUTPUT — Passing a summary of the previous iteration into the next prompt without bloating the context.
$ARTIFACTS_DIR — Storing test logs so the final report node can read them.
orchestrator.ts Patch — Why worktree.enabled: false needs a one-time patch to run the loop in the correct working directory.
Six Rules for Loop Nodes — Always set max_iterations, use deterministic until_bash, keep each iteration scoped, and store logs in artifacts.
This lecture adds three mechanisms that turn a basic workflow into a truly flexible system: reusable commands (atomic Markdown instructions for the AI), conditional node skipping with when:, and precise control over AI session context. You will build a two-workflow project around a Python calculator — one that checks completeness before running tests, and one that routes to a fix branch or a verify branch based on structured JSON output.
Key Highlights:
Commands as Atomic Units — A Markdown file in .archon/commands/ is the smallest reusable instruction. It can run standalone or be wired into any workflow node.
Variable Substitution — $ARGUMENTS, $1, $2, $ARTIFACTS_DIR, $WORKFLOW_ID, $BASE_BRANCH, $DOCS_DIR — all resolved before the AI sees the file.
when: Conditional Skipping — String, numeric, and compound expressions (&&, ||) evaluated before a node starts. Fail-closed: invalid expressions skip the node with a warning.
context: fresh vs context: shared — When to give the AI a clean slate and when to let it carry conversation history forward.
$nodeId.output and $nodeId.output.field — Reference any upstream node's output, including structured JSON fields, as long as depends_on is declared.
output_format for Reliable Branching — Structured JSON responses enable deterministic when: expressions against specific fields.
trigger_rule — Control how join nodes behave when some upstream nodes were skipped.
Two Practical Workflows — calc-verify (completeness check → conditional test run → report) and calc-smart (classify → route to fix or verify → summarize).
Automated tests confirm functional correctness, but they cannot answer "Is this the right approach?" or "Does this violate the team's architectural invariants?" This lecture adds formalized human control points — approval nodes — to your workflows, and teaches you how to branch a DAG based on task classification. You will build a full calculator workflow with a review gate, implement an AI rework loop on rejection, and add a BUG vs FEATURE routing pattern.
Key Highlights:
Three Layers of Trust — Functional correctness (tests), architectural correctness (team invariants), and business correctness (right problem, no side effects). Tests only cover the first layer.
Approval Node Mechanics — Workflow pauses, Archon notifies the reviewer, human approves or rejects. On rejection, on_reject.prompt triggers an AI rework cycle before the gate repeats.
capture_response: true — The reviewer's comment is stored as $review-gate.output and can be injected into downstream prompts.
$REJECTION_REASON — Automatically substituted into the on_reject prompt so the agent knows exactly what to fix.
interactive: true — Required at the workflow level for approval messages to appear in the Web UI chat.
Approval vs Interactive Loop — Use approval when the workflow should proceed by default and a human is only a gatekeeper. Use interactive loop for active AI–human dialogue.
Conditional DAG Branching — when: + output_format + trigger_rule: all_done to route BUG and FEATURE tasks through separate nodes while sharing a single review gate.
Fork Archon — The lecture references a pre-patched fork that includes Web UI support for the approval node type.
This lecture introduces the two primary SDKs provided by Anthropic: the low-level Anthropic SDK for direct API calls and the high-level Claude Agent SDK for building agentic frameworks. It covers their differences, use cases, and provides a quick start guide for implementing both in your AI startup.
Key Highlights:
Two SDKs, Two Roles Understanding the fundamental difference between manual API calls and an automated agent loop.
When to Use What A clear breakdown of scenarios to choose between the Anthropic SDK and Claude Agent SDK.
Under the Hood How the agent loop works and how Claude Agent SDK abstracts away the complexity of tool use and message history.
Message Types A guide to handling SystemMessage, AssistantMessage, and ResultMessage in the Agent SDK.
Model Selection An overview of the latest Claude models (Opus 4.7, Sonnet 4.6, Haiku 4.5) as of May 2026.
Comparison A side-by-side comparison of Anthropic SDK, Claude Agent SDK, and Google ADK.
This lecture dives deep into the Messages API, the foundational layer of the Anthropic SDK. It covers everything from making basic stateless requests to handling various stop reasons and streaming responses. You will also learn about the Batch API for cost-effective processing and Claude's robust multilingual support, bringing all these concepts together in a comprehensive EdTech content pipeline script.
Key Highlights:
Stateless Architecture Understanding how the Messages API works without server-side history and why max_tokens is mandatory.
Stop Reasons A complete guide to handling stop_reason events like end_turn, max_tokens, tool_use, and refusal.
Streaming Responses Implementing simple streaming and async Server-Sent Events (SSE) using FastAPI for real-time text delivery.
Batch Processing How to save 50% on API costs by processing up to 100,000 requests asynchronously.
Multilingual Capabilities Leveraging Claude's language auto-detection and prompting strategies for global applications.
EdTech Pipeline A real-world combo script demonstrating batch generation, streaming, stop reason handling, and multilingual tutoring.
This lecture explores the advanced capabilities of Anthropic's Claude models, including Extended and Adaptive Thinking, the Effort parameter, Structured Outputs, and Citations. You will learn how to configure these features to optimize performance, manage costs, and build reliable, context-aware AI applications.
Key Highlights:
Extended & Adaptive Thinking: How to enable Claude to "think aloud" and automatically adjust its reasoning depth.
Effort Parameter: A high-level setting to control reasoning depth without manual token budgeting.
Structured Outputs: Reliable methods for forcing Claude to return JSON using tools or system prompts.
Citations: A built-in mechanism to retrieve structured answers with precise source quotes.
This lecture explores the built-in (server-side) and client-side tools available in the Anthropic Claude SDK. You will learn how to implement and use tools like Web Search, Web Fetch, Code Execution, Advisor, Bash, Computer Use, and Text Editor to enhance Claude's capabilities, automate tasks, and perform complex data analysis.
Key Highlights:
Server-Side Tools: Web Search, Web Fetch, Code Execution, and Advisor tools that run directly on Anthropic's servers.
Client-Side Tools: Bash, Computer Use, and Text Editor tools for local execution and GUI automation.
Code Execution: Performing statistical analysis and generating visualizations using Python in a secure sandbox.
Dynamic Filtering: Optimizing web search results to reduce token usage and improve accuracy.
This lecture covers how the Claude language model handles context windows, strategies for managing long conversations (compaction), the Files API, PDF support, and image processing (Vision). It includes practical Python code examples for implementing these features using the Anthropic SDK.
Key Highlights:
Context Windows: Understanding context limits and strategies for tracking and managing token usage.
Compaction: Automatic and manual context compression techniques for long agent sessions.
Files API & PDF Support: Working with documents, text files, and images across multiple prompts.
Images and Vision: Processing visual data, performing OCR, and analyzing multiple images.
This lecture explains how the Agent Loop works within the Claude Agent SDK, which is the same loop used inside Claude Code. You will learn the 5-step process of prompt processing, tool execution, and context management. It covers how to use query() as the main entry point, handle different message types, manage results and errors, and configure agent options like permissions and budgets.
Key Highlights:
Agent Loop Steps: Understanding the 5 steps: receive prompt, evaluate, execute tools, repeat, and return result.
Message Types: Handling SystemMessage, AssistantMessage, UserMessage, StreamEvent, and ResultMessage.
Result Handling: Checking subtype for success or errors (like max turns or budget limits) before accessing results.
Agent Configuration: Using ClaudeAgentOptions to set allowed tools, reasoning effort, permission modes, and limits.
This lecture explores the 11 built-in tools provided by the Claude Agent SDK, which Claude uses autonomously. You will learn about file operations, command line execution, search tools, web utilities, and interactive prompts. It also covers permission management, parallel tool execution, and how to configure custom tools.
Key Highlights:
Built-in Tools: Exploring Read, Write, Edit, Bash, Glob, Grep, WebSearch, WebFetch, Monitor, AskUserQuestion, and ToolSearch.
Permissions: Understanding allowed_tools, disallowed_tools, and permission_mode to secure your agent.
Parallel Execution: How read-only tools run simultaneously while state-modifying tools run sequentially.
Custom MCP Tools: Naming conventions and using readOnlyHint for custom tools.
This lecture details how the Claude Agent SDK handles session management. You will learn the lifecycle of a session, how it stores conversation history (not the file system), and the differences between Continue, Resume, and Fork operations. It also covers using ClaudeSDKClient for automatic session tracking and managing session metadata (list, rename, tag).
Key Highlights:
Session Lifecycle: How the SDK automatically saves conversation history to disk.
Continue vs. Resume: Using continue_conversation=True for the most recent session vs. resume=session_id for specific or multiple sessions.
Forking Sessions: Creating independent conversation branches to test alternative approaches using fork_session().
ClaudeSDKClient: Using the client for continuous, multi-turn conversations within a single process.
This lecture covers the streaming capabilities of the Claude Agent SDK. It details the differences between single message and streaming input modes, how to handle partial messages for real-time streaming, the anatomy of StreamEvent objects, and advanced streaming input patterns such as dynamic context injection and interactive permissions. It includes practical Python code examples.
Key Highlights:
Streaming Input Modes: Understanding the differences between single message and streaming input modes.
Real-Time Streaming: Handling partial messages with include_partial_messages to stream responses as they are generated.
StreamEvent Anatomy: Extracting text and tracking tool calls using StreamEvent objects.
Advanced Patterns: Implementing dynamic context injection and interactive permissions via can_use_tool.
This lecture covers how to create and manage custom tools in the Agent SDK using an in-process MCP server. It explains the differences from Client SDK tool use, how to define tools with the @tool decorator, and how to set up tool annotations and permissions.
Key Highlights:
Why Custom Tools: Understanding when to use custom tools versus built-in tools.
The @tool Decorator: Defining tools, input schemas, and handling responses and errors.
In-process MCP Server: Creating a server with create_sdk_mcp_server and managing permissions via allowed_tools.
Tool Annotations: Using ToolAnnotations to control parallel execution and provide metadata hints.
This lecture covers the Model Context Protocol (MCP) capabilities in the Claude Agent SDK. It details the supported transports, server authentication, dynamic tool loading via tool_search, creating in-process and external FastMCP servers, and critical security considerations when working with MCP servers.
Key Highlights:
MCP Transports: Understanding stdio, HTTP, SSE, and in-process SDK MCP servers.
Authentication: Managing tokens and credentials for local and remote servers.
Dynamic Tool Loading: Utilizing ENABLE_TOOL_SEARCH to reduce context costs and improve accuracy.
Creating Servers: Building in-process servers with create_sdk_mcp_server versus external servers via FastMCP.
Security Warnings: Mitigating risks from local and remote MCP servers through permissions and best practices.
This lecture covers the subagent capabilities in the Claude Agent SDK. It details how Claude invokes subagents using the Agent tool, configuring AgentDefinition, managing context isolation, resuming subagents, handling parallel execution, and leveraging SubagentStart and SubagentStop hooks for monitoring and control.
Key Highlights:
The Agent Tool: How Claude automatically delegates tasks to subagents based on descriptions.
AgentDefinition: Full configuration of subagents including tools, models, MCP servers, and background execution.
Context Isolation: Understanding what subagents inherit and how parent and subagent communicate.
Resuming Subagents: Continuing a subagent's work with its full historical context.
Hooks & Parallelism: Using SubagentStart / SubagentStop for decision control and running subagents simultaneously.
This lecture provides an overview of the various hook events available in the Claude Agent SDK. You will learn how to intercept and modify tool executions, handle user prompts, manage agent lifecycles, and implement security measures using hooks like PreToolUse, PostToolUse, and more.
Key Highlights:
Hook Events: Understanding the core hook lifecycle events in the Python SDK.
Security & Modification: Using PreToolUse for short-circuit blocking and input modification.
Auditing & Context: Using PostToolUse and UserPromptSubmit to audit results and inject dynamic context.
Lifecycle Management: Archiving history with PreCompact and handling agent termination with Stop.
This lecture covers the creation and usage of Skills, Slash Commands, and Plugins in the Claude Agent SDK. You will learn how to structure reusable workflows, invoke them automatically or explicitly, build custom commands, and extend functionality using local plugins.
Key Highlights:
Skills: Structuring and using .claude/skills/*/SKILL.md for autonomous execution.
Slash Commands: Using built-in commands (/compact, /clear) and defining custom legacy commands.
Plugins: Extending the SDK with local plugins, namespaces, and the plugin.json manifest.
Integration: How the Skill tool works and how to load plugins programmatically.
This lecture covers structured output and file checkpointing in the Claude Agent SDK. You will learn how to enforce JSON Schema output, handle validation retries and errors, and use file checkpointing to track and rewind changes made by the agent.
Key Highlights:
Structured Output: Enforcing strict output formats using JSON Schema, Pydantic, and Zod.
Retry Logic: How the SDK handles validation failures and error_max_structured_output_retries.
File Checkpointing: Tracking file changes made by agent tools and restoring previous states.
Rewind Functionality: Reverting file changes without affecting the conversation history.
Demo for participation in "The Hermes Agent Accelerated Business Hackathon presented by NVIDIAAI × stripe × NousResearch"
This lecture introduces the core concepts of autonomous AI agents, distinguishing them from standard LLM assistants and automated workflows. It covers the four fundamental systems of an agent, reasoning patterns like CoT, ReAct, and ToT, and explains why agentic AI is becoming widely adopted. Finally, it outlines current limitations and briefly connects these concepts to frameworks like OpenClaw and Hermes.
Key Highlights:
Three Entities People Confuse Understanding the difference between an LLM Assistant, a Workflow, and an Autonomous Agent.
Four Systems of Any Agent A breakdown of Perception, Reasoning, Memory, and Action systems.
Reasoning Patterns How Chain-of-Thought, ReAct, and Tree-of-Thought work.
Why Now? The technical and market catalysts driving the adoption of AI agents.
Current Limitations A realistic look at the challenges, such as the 95% problem and long-horizon planning.
OpenClaw and Hermes How these frameworks solve specific agent problems like persistence and self-learning.
This lecture dives deep into the architecture of OpenClaw, a framework that acts as an operating system for AI agents. It explores the history of its creation, its core philosophy, the six-layer hub-and-spoke architecture, the Gateway mechanism with its Lane Queue concurrency control, the eight-phase message lifecycle, and the Workspace files that define an agent's behavior and personality.
Key Highlights:
Background How a simple WhatsApp script evolved into a massive open-source project.
OS Philosophy Why OpenClaw is considered an AI runtime rather than just a chatbot application.
Six Architecture Layers A breakdown from Data Storage up to Control Interfaces.
Gateway & Lane Queue The single-process hub and its brilliant solution for race conditions and concurrency.
Message Lifecycle The 8 phases a message goes through, from ingestion to lane release.
Workspace Files How files like AGENTS.md, SOUL.md, and MEMORY.md shape the agent's behavior without coding.
This lecture covers the step-by-step process of installing OpenClaw on a Virtual Private Server (VPS) and using Docker. It explains server selection, basic security setup (SSH, UFW, Fail2ban), and the installation of NemoClaw. The lecture also details configuring messaging channels like WhatsApp and Telegram, managing the Control UI dashboard, and troubleshooting common issues.
Key Highlights:
VPS Setup Choosing a provider and preparing the Linux environment with essential security measures.
NemoClaw Architecture Understanding the three layers: NemoClaw CLI, OpenShell Gateway, and the Sandbox.
Docker Configuration Setting up Docker with proper network policies for secure agent communication.
Messaging Channels Configuring Telegram and WhatsApp Web messaging with access control and pairing.
Dashboard Access Using SSH tunneling to securely access the OpenClaw Control UI.
Troubleshooting Diagnosing issues with the Gateway, Telegram connectivity, and Dashboard pairing.
This lecture dives into the architecture of Hermes Agent, an operating system for AI agents created by Nous Research. It covers its core philosophy, the primary agent loop, the context file system, built-in self-learning capabilities, memory layers, and the multi-layered security model. Additionally, it highlights advanced evolutionary tools and compares Hermes to other modern frameworks.
Key Highlights:
OS Philosophy How Hermes acts as an operating system with memory, skills, scheduling, and isolation.
Core Agent Loop Understanding the prompt building process and context compression techniques.
Context Files System How files like SOUL.md, AGENTS.md, and MEMORY.md progressively inject context.
Self-Learning & Curator The semi-automated process of skill creation and lifecycle management.
Memory Layers Exploring the hot-to-cold memory hierarchy from Session Memory to external backends.
Security Scanners Multi-tiered security including Unicode, Tirith, and dangerous command detectors.
In this lecture, we will explore the production installation of the Hermes Agent with a focus on security, configuration, and Hermes-specific details. We synthesize the best practices from official installation methods, the official security model, real instance structure, Docker Compose for production, and a multi-layered security model.
Key Highlights:
Official Methods Utilizing the best from official installation methods (README, scripts).
Security Model Understanding the official security model from SECURITY.md.
Instance Structure Analyzing the real structure of a running instance.
Docker Compose Using Docker Compose for production deployments.
Multi-layered Security Implementing a multi-layered security approach.
DeepSeek AI just shipped its own open-source agent harness — and it stakes out a radically different position from Pi Agent and OpenClaw. This lecture breaks down the formula Agent = Model + Harness, walks through DeepSeek Harness's "everything is a plugin" architecture built on the Cordis engine, and places it side by side with Pi Agent's minimalist core and OpenClaw's ready-made product so you know exactly when to reach for which one.
Key Highlights:
Agent = Model + Harness The model is the "brain" that generates plans and text; the harness is the "body" that gives it tools, memory, file access, and the loop that turns text into real-world action.
DeepSeek Harness (dsh) An MIT-licensed, plugin-first harness released by DeepSeek AI in August 2026 — model, tools, sessions, sandbox, storage, the agent loop, even the UI are all swappable plugins on the Cordis engine. "There is no privileged core to patch."
4 Launch Modes Standard, PTC (Programmatic Tool Calling), Minimal, and Creator (cordis in the repo) — each a different tradeoff between power and surface area.
Pi Agent's Counter-Bet "Primitives, not features": just 4 built-in tools (read, write, edit, bash), a fixed agent loop, and JSONL session trees with branching, forking, and resume.
OpenClaw as a Product Not a harness built from scratch but Pi Agent plus a product wrapper — 10+ channels (Telegram, WhatsApp, Slack), batteries-included tools, and the largest install base of the three.
One Shared LLM Layer All three tools — supposedly competitors — route non-native providers (OpenAI, Anthropic, Bedrock) through the same pi-ai package. The real competition is at the harness layer, not the provider-adapter layer.
Choosing Between Them A practical decision guide: stability today (Pi Agent), a ready-made agent across every chat app (OpenClaw), or a harness where even the agent loop itself is replaceable (DeepSeek Harness).
A deep technical dive into how DeepSeek Harness is actually built: the ~8.7k-line Cordis plugin kernel it sits on, the Capability Seam pattern that lets you swap any model or provider without touching the rest of the system, the four launch modes and when to reach for each one, the two-layer OS-level sandbox that keeps the agent from writing outside its workspace, the runtime self-modification tools in Extensions, and the append-only event log that makes resume/fork/search/replay possible.
Key Highlights:
Cordis Kernel An ~8,725-line TypeScript core vendored directly into the repo, on top of which 234 packages and ~216,000 lines of harness code run as plugins — "everything is a plugin" as a measurable fact, not a slogan.
Capability Seam Pattern Every swappable behavior — models, file systems, even the agent loop itself — follows the same three-role contract: Service Definition, Service Provider, Consumer.
Bring Your Own Model Model routing lives entirely in config (apiKeyEnv, baseURL, custom routes) via the shared pi-ai adapter — no code changes needed to point at a new provider, gateway, or local model.
Four Launch Modes Standard for everyday coding, PTC for batch operations compiled into one TypeScript program, Minimal for apples-to-apples benchmarking, Creator for building your own presets — they form a pipeline, not a menu of alternatives.
Two-Layer Sandbox A file-path fence (dsh-fs-sandbox) that's a policy check, not a kernel boundary, plus real OS-enforced process isolation (bubblewrap/Landlock on Linux, Seatbelt on macOS, a restricted ACL token on Windows) — fail-closed on both.
Extensions ≠ Security Boundary dsh-tool-cordis lets the model define, run, and tear down plugins live in the running process — powerful, but explicitly not a sandbox; treat it like bash access.
Event Log as Source of Truth The core architectural bet against Pi Agent: the append-only session log is the context, and the agent loop is just a replaceable projection over it — which is what makes resume, fork, search, and full reasoning-trace replay possible.
A hands-on walkthrough of getting DeepSeek Harness from zero to a running agent: registering for an API key, installing via npx or from source, surviving your first launch, and using the built-in / commands and Skills menu. From there we move into no-code customization through Creator-mode presets, and finally into the plugin ecosystem — what a plugin actually is, how it differs from a preset, and the install quirks (including a scary-looking but harmless dependency download) you'll hit the first time you add one.
Key Highlights:
Two Different dsh Packages @deepseek-ai/dsh (the official Node.js harness) and deepseek-harness on PyPI (an unrelated third-party API adapter) share almost the same name — installing the wrong one is the #1 first-week mistake.
Three Layers of Customization Preset (no code, just prompt + enabled tools) → Plugin (TypeScript, new capabilities) → Extension (in-memory, agent-authored, gone on restart) — each layer trades power for permanence.
Commands vs. Skills Built-in / commands are Cordis-plugin code and invisible to the model's context; Skills are plain Markdown files that do enter context — the right no-code equivalent to Pi Agent's slash-command templates.
Creator Mode = Preset Factory A specialized session type where the agent inspects its own registered tools and writes a complete agent.cordis.yml for you — no hand-written YAML required.
Plugins Are Bundles Installed via dsh plugin --profile <name> add, verified not with pnpm why (which silently lies) but with --dump-config, which prints the real, final configuration tree.
The optionalDependencies Scare Installing one plugin can trigger an 8-platform, ~600MB download of the Claude Agent SDK's native binaries — only your platform's copy lands in the profile; the rest goes into pnpm's shared, one-time global store.
This is the hands-on finale of the DeepSeek Harness series. We delegate real bugs to built-in sub-agents and to an external Claude Code process, build two file-based plugins from scratch (a greeter tool and a secret-redacting guard), and finish with Creator mode's most unusual feature — dynamic Cordis plugins that a model can write, run, and iterate on inside a single chat session, without ever restarting the process.
Key Highlights:
Delegation Stack How subagent, tool-subagent, and tool-subagent-control work together, and why the Settings → Plugins list shows a dozen identical-looking tool-subagent cards.
Six Sub-Agent Providers From in-process spawn/fork to full external runtimes — Codex, Claude Code, any ACP-speaking agent, and a second DSH instance over JSON-RPC.
Practice A vs. Practice B Watching the built-in subagent split a three-bug project across parallel workers, then forcing a single bug to an external Claude Code process by name.
Debugging a Failed Delegation Reading stage/category diagnostics, the OAuth-vs-API-key trap, and how the model reacts to three failed retries.
Building Your Own Plugin The file://-URL requirement on Windows, the --patch overlay workflow, and the three code details every defineTool call trips on.
secret-guard: A Real Security Plugin Redacting credentials from tool output before they ever reach the session log, and blocking the model from re-using a captured secret.
Dynamic Cordis Plugins Creator mode's node:vm sandbox, why it's explicitly not a security boundary, and how an agent can write, run, and fix a tool in the same conversation — then promote the working code to a permanent file-based plugin.
Triangle reflects on the limitations of a single-supervisor graph architecture, realizing that real-world organizations are built on communicating teams — not rigid flowcharts. Setting the stage for AG2, he prepares to evolve from coordinating individual agents into building full multi-team systems capable of dynamic, situational collaboration.
Key Highlights:
Beyond the Single Supervisor Recognizing that a single orchestrator over a flat graph cannot capture how real organizations actually operate.
The Shift to Teams Moving from nodes and edges to departments that argue, interrupt, and hand off tasks based on context — not predefined routes.
From Graphs to Conversations Transitioning from static flowcharts into living agent networks where teams communicate on their own terms.
Triangle opens the AG2 docs and runs straight into a warning banner: the API he half-remembers is now "AG2 Classic." He sorts out the split between the two branches, meets the single Agent class that replaces ConversableAgent, and ships his first working script against OpenRouter.
Key Highlights:
AG2 Classic vs AG2 v1.0 Why import autogen and import ag2 are now two separately maintained projects, not one library with a new version number.
AgentOS, Not a Graph Orchestrator LangGraph draws every transition on a graph in advance; AG2 gives an agent a role and tools and lets it decide.
The Agent Class One base class, one entry point — agent.ask() — replacing the whole ConversableAgent lifecycle.
A Look Ahead: Network, Hub, Channel Where multi-agent teamwork lives in v1.0, instead of GroupChat.
The Parameter Map Every named keyword on Agent — tools, hitl_hook, assembly, tasks — is a preview of a later lesson in the module.
Triangle gives his agent hands. He works through plain-function tools, sync/async execution, strict Pydantic schemas, hidden variables/Context data, Depends gates, middleware and human approval, provider-native tools, and sandboxed code execution — then wires it all into one end-to-end warehouse-audit agent that writes its own reconciliation code, checks a real database, and asks a human before writing anything off.
Key Highlights:
The Tool Itself Turning a plain typed, docstringed Python function into something an LLM can call, no second executor agent required.
Toolkits Grouping tools into one reusable, nameable object, plus AG2's ready-made toolkits for files, search, and shell commands.
Sync, Async, and Strict Schemas Letting the framework handle blocking calls safely, and tightening tool arguments with Annotated[..., Field(...)].
Context, Variable, and Depends Passing secrets and session data around a tool without ever putting them in the prompt, and running setup/gate logic before a tool's body runs.
Middleware, Approval, and Provider-Native Tools Wrapping every call for logging or human sign-off, and reaching for a provider's own web search, memory, or code execution instead of writing it yourself.
Triangle stops accepting free text from his agent and starts demanding a form. He works through response_schema, the raw-vs-validated split between reply.body and reply.content(), retry-driven self-correction, ResponseSchema(embed=False), custom @response_schema validators with Depends/Variable injection, PromptedSchema for providers without native structured output, and a dynamic @agent.prompt — then builds a bug-triage agent for Joi's NeoMatrix project that turns raw complaints into typed tickets instead of prose.
Key Highlights:
response_schema as a Contract How AG2 builds a JSON Schema from a type and hands it to the provider's native structured-output API — and what happens when the provider doesn't actually enforce it.
Taming OpenRouter's Instability Using extra_body's provider.require_parameters and sort to stop a router from silently drifting to a backend that ignores your schema.
Raw Text vs. Validated Data reply.body versus await reply.content(), and how retries lets the model see its own validation error and fix itself mid-conversation.
Custom Validators and DI Markers @response_schema functions that clamp or reshape a value, and the difference between a constraint the model can see (Field(ge=..., le=...)) and one it can't (an if in the function body).
A Prompt That Isn't One Fixed String @agent.prompt functions that mix in text based on live conversation state, plus one-off fragments passed straight into ask(prompt=...).
Triangle moves beyond text-only agents. He works through image, document, audio and video inputs, uploaded files, persistent knowledge stores and event logs. Then he builds an apartment-inspection agent that reads defect photos and acceptance documents, recreates its checklist after a crash and continues from the same conversation.
Key Highlights:
One Input Pattern for Four Formats: Using ImageInput, DocumentInput, AudioInput and VideoInput with URLs, file IDs, raw bytes and local paths.
Uploads Instead of Repeated Payloads: Managing provider files with FilesAPI and reusing them through FileIdInput.
Persistent Knowledge: Comparing MemoryKnowledgeStore with SqliteKnowledgeStore, and understanding what actually survives a restart.
Event Logs and Resume: Saving conversation events with EventLogWriter and restoring them with agent.resume() without inventing a new history.
A Real Multimodal Inspection: Combining a defect photo, a PDF acceptance act and a second process that recovers the complete checklist.
Triangle gives his agent brakes. He adds human questions inside tool execution, approval gates for dangerous actions, middleware for cross-cutting control and observers that detect loops and excessive token use. Then he builds an on-call SRE agent that can be stopped before it restarts a production service.
Key Highlights:
Human Input During Execution: Using context.input() and hitl_hook to pause a tool and wait for a person's answer.
Approval Around Dangerous Tools: Applying approval_required as tool middleware rather than confusing it with general agent middleware.
Custom Middleware Layers: Logging, retries, history limits and token limits through ordered hooks and ConditionalMiddleware.
Live Steering with AgentRun: Starting runs, filtering streams and using run.enqueue() to intervene before the current turn ends.
Observers and Fatal Alerts: Detecting repeated behavior with LoopDetector and TokenMonitor, then escalating serious problems through AlertPolicy.
Triangle moves from one controlled agent to a team that talks through shared infrastructure. He builds a medical case conference with a GP, cardiologist and neurologist, using a hub, passports, channel protocols and a write-ahead log instead of manually forwarding every message.
Key Highlights:
Hub and LocalLink: Opening a hub over a knowledge store and connecting agents through a transport-independent client API.
Identity and Registration: Using Passport and separate registration methods for software agents and human participants.
Three Conversation Protocols: Comparing consulting, conversation and discussion, including automatic closing and turn order.
Custom Channel Adapters: Building TriageVoteAdapter with quorum-based completion and explicit channel state.
WAL and Recovery: Reading network envelopes, inspecting channel history and rebuilding state with hub.hydrate().
Triangle turns a discussion into an actual business process. He builds a microloan pipeline where intake, scoring, KYC and underwriting pass work to one another through explicit transitions, with governance rules controlling who may speak and when the pipeline must stop.
Key Highlights:
Workflow Channels: Using type="workflow" and TransitionGraph to describe routes as data rather than hard-coded conditions.
Transitions and Targets: Choosing the next speaker with AgentTarget, RevertToInitiatorTarget, StayTarget and TerminateTarget.
Conditions and Priorities: Routing with Always, FromSpeaker, ToolCalled and ContextEquals, evaluated in priority order.
Governance Rules: Blocking forbidden communication with AccessBlock and enforcing timeouts with Expectation.
A Complete Compliance Pipeline: Moving an application through scoring, KYC, underwriting and escalation while preserving an auditable decision trail.
Triangle gives Cafe 808 a memory that survives staff changes. He attaches a persistent KnowledgeStore, lets the agent organize guest preferences and equipment notes, and controls how that knowledge enters the prompt through compaction and context-assembly policies.
Key Highlights:
KnowledgeConfig and KnowledgeStore: Attaching memory through dependency injection and choosing SQLite, memory, disk or Redis backends.
Agent-Managed Knowledge: Allowing the model to read, write, list and delete knowledge through an exposed action group — or hiding it with expose_tool=False.
Bootstrap and Working Memory: Loading initial instructions and persistent notes without mixing them into dialogue history.
Compaction Policies: Using CompactTrigger, SummarizeCompact and TailWindowCompact to keep context within useful limits.
Injection Before Reduction: Ordering assembly policies so working memory and alerts enter the prompt before sliding-window and token-budget reductions.
Triangle splits startup due diligence into market, finance, team and legal reviews. He compares temporary worker clones with named subagents, runs independent research in parallel and learns how isolation, streams and token reporting work in real delegation.
Key Highlights:
TaskConfig and Automatic Tools: Using run_subtask and run_subtasks to create fresh workers with their own prompts, tools and memory.
Named Delegates: Turning a specialist into a tool with subagent_tool, including a fixed prompt and a chosen tool name.
Controlled Delegation Depth: Understanding why automatic clones cannot replicate themselves while named subagent tools can still create a deliberate second level.
Live Progress Streams: Filtering TaskStarted, TaskCompleted and TaskFailed, and keeping a separate MemoryStream for a specific delegate.
Isolation and Cost: Copying variables into subtasks, returning only text results and rolling subtask token usage into the parent report.
Triangle stops treating a convincing answer as evidence of quality. He builds a bug-triage evaluation suite, writes custom scorers and uses regression diffs to discover that a shorter prompt improves speed while damaging component accuracy.
Key Highlights:
Evaluation Suites: Creating tasks with Suite.from_list or Suite.from_jsonl, including inputs and reference outputs.
Custom Scorers: Using @scorer for booleans, numeric scores, strings, skipped cases and detailed Feedback.
The Boolean Trap: Understanding why returning 1 or 0 can produce score_stats instead of pass_rate, since bool is a subclass of int.
Budgets and Stored Runs: Measuring pass rate, token use and latency with BudgetThresholds and persistent run directories.
Regression Diffs: Loading previous runs with load_run and comparing results through RunResult.diff() instead of trusting memory or intuition.
Triangle has three prompt variants that all pass the suite, so pass rate alone can no longer choose a winner. He compares them with controlled sweeps, an LLM judge and a deterministic rubric, then discovers that the two evaluators disagree.
Key Highlights:
Controlled Variant Sweeps: Using run_variants and Variants(axis=...) to change only the prompt while keeping every other condition fixed.
Ties and Missing Winners: Understanding why best() can return None instead of forcing a winner from equal scores.
Pairwise Comparison: Running head-to-head tests with run_pairwise, including swapped A/B positions to detect positional bias.
Win Rates and Uncertainty: Reading Wilson confidence intervals and avoiding strong conclusions from a tiny sample.
Evaluator Agreement: Using Cohen's kappa and result flips to measure disagreement between the judge and the rubric.
Triangle removes the need for a person to ask the agent first. He builds a farm-monitoring agent that reacts to sensor readings, time schedules and sequences of events, then learns why a poorly designed trigger can create a false emergency.
Key Highlights:
EventWatch: Triggering on event fields and combined conditions rather than simply reacting to an event type.
Time-Based Watches: Comparing CadenceWatch, IntervalWatch, CronWatch and one-off DelayWatch.
Composite Conditions: Using AllOf, AnyOf and Sequence to describe meaningful situations instead of isolated readings.
Unpredictable Trigger Order: Observing why a delay can fire before a cadence batch and why logs should not be treated as a deterministic timeline.
False Alerts and Specifications: Debugging a humidity condition that matches a numeric threshold but has the wrong meaning, plus handling missing tools with AgentSpec.
Triangle moves the reporter and factchecker out of the editor's process and onto a real WebSocket connection. He finishes the “Strip” newsroom, where agents collaborate through the same public API regardless of location and the WAL records both planned and unexpected consultations.
Key Highlights:
One API, Two Transports: Using LocalLink for in-process access and WsLink for network clients without changing the newsroom's public calls.
Real WebSocket Infrastructure: Starting serve_ws on an OS-assigned port and connecting independent clients to a live hub.
Consulting Channels: Running a strict question-and-answer protocol that closes automatically when the exchange completes.
Audit and Side Conversations: Reading registration, channel and shutdown events, including a factchecker that consults the reporter on its own.
WAL and Hydration: Rebuilding every channel and its exact state from the log, then examining why replay and idempotency matter after disconnection.
Triangle reviews the complete journey from a single agent call to a distributed editorial team. Snow begins over New Seoul-7, and a Japanese story about Yuki-onna leads to a final contrast: agents may disappear when the work is done, but the WAL preserves every step.
Key Highlights:
Agents With Controlled Tools: Reviewing structured output, context injection, multimodal input, middleware and human approval.
Networks With Clear Contracts: Connecting identity, channels, transitions and governance into an inspectable communication system.
Knowledge and Delegation: Choosing persistent stores, temporary workers and named specialists without losing track of state or cost.
Evidence Instead of Confidence: Measuring behavior, comparing variants, handling evaluator disagreement and rebuilding state from logs.
The Bridge to Deep Agents: Moving from scaling teams wide to helping one agent work deep in time, leading directly to Cafe 808 and the next module.
This course contains the use of artificial intelligence.
Not affiliated with Anthropic, LangChain, NousResearch, TypeSafe, NVIDIA, Google, Microsoft or 杭州深度求索人工智能基础技术研究有限公司.
Welcome to the most complete AI Engineering Bootcamp :)
This is not a theory course. From day one, you write real code, build real AI Agents, Agentic AI and ship real systems. Whether you're a developer, data scientist, or complete beginner — by the end you'll be able to design, build, and deploy production-grade AI systems confidently.
What you'll build:
MCP — connect agents to GitHub, databases, filesystems, and any external tool
Conversational AI assistants with memory, tools, and streaming
RAG pipelines that load PDFs, CSVs, web pages, and query them with LLMs
Vector RAG (Qdrant; Milvus)
Hybrid RAG (BM25; BM42)
Graph RAG (neo4j)
Agentic RAG
Multi-agent systems with orchestration patterns: Sequential, Parallel, Loop, Swarm, Supervisor
Autonomous agents using ReAct, MCTS, BeamSearch, and Tree of Thoughts
Jev — a System One decision model (not a reasoning model): typed Choice, Score, and Noul answers in a single pass, for routing and guardrails instead of step by step thinking
Personalized AI assistants powered by OpenClaw & Hermes Agent (Nvidia NemoClaw OpenShell) — with custom routing, tool & API integration, sub-agent orchestration, and multi-step task delegation
Cross-framework agent networks via A2A protocol — connecting ADK, LangChain, LangGraph, and AG2
Production-ready systems with guardrails, evaluation, observability, and HITL
Fine-tuning with Unsloth fast and VRAM-efficient LLM training with support for RL/RLHF methods (GRPO, PPO, DPO, ORPO, KTO) for reasoning and preference alignment.
Technologies covered:
Python — syntax, data types, functions, object-oriented programming, file handling, virtual environments.
LangChain — LCEL chains, RAG, memory, MCP, agents
LangGraph — stateful graphs, persistence, Time Travel, Send API, Subgraphs
Pi — skills, extensions, slash commands, session trees, sub-agent patterns, JSONL branching
Archon — YAML pipelines, harness engineering, deterministic multi-agent orchestration
Anthropic SDK & Claude Agent SDK — Client SDK, Tool Use, streaming, prompt caching, Claude Agent SDK, subagents, hooks, MCP
OpenClaw & Hermes Agent — messaging routing, tool & API integration, sub-agent orchestration, multi-step task delegation, personalized assistants, workflow automation
DeepSeek Harness — Cordis plugin kernel, capability seams, profiles & bundles, four presets (Standard/PTC/Minimal/Creator), custom plugins, dynamic Extensions, OS-level sandbox, append-only event log
AG2 (AutoGen) — GroupChat, CaptainAgent, ReasoningAgent, DocAgent
Jev — a System One decision model (not a reasoning model): fast typed decisions the harness can call for routing, escalation, and tool-call gating instead of a full agent turn
Google ADK — callbacks, plugins, artifacts, evaluation, UserSimulator
A2A Protocol — agent interoperability across all frameworks
Unsloth — fast LoRA/QLoRA fine-tuning, memory-efficient training, model quantization, export to GGUF/vLLM
Every module follows a hands-on structure:
each lesson has working code, real tasks, quizzes, and a final project that ties everything together.
By the end of this course, you won't just understand AI — you'll build it.
P.S.
The course is currently in early access mode — 6 modules are already available.
Get in now at the lowest price. As new modules are added, the price will increase. The earlier you enroll, the more you save.
Lock in your spot today before the next price bump.