AI AGENT HANDBOOK
Understand AI agents from zero, then build them yourself — the agent loop · prompt and context engineering · tools and MCP · memory · planning · multi-agent systems · evaluation and security
50+ pages isn't a library you have to read cover to cover — it's a roadmap you can compose to fit your needs
Interviewing for agent roles within 1–3 months: go straight to JD benchmarks, resume rewrites, and the interview question bank — every page maps to what gets asked.
View the route →Time to build a solid foundation: work week by week from the Guide through Hands-On Guides, layering principles, frameworks, case studies, and practice.
View the route →Working builders rarely read cover to cover: use the problem-to-page index to find what you need and get back to work. Treat it like a reference book.
View the route →If you only read ten pages, read these
How to use this site's three learning routes — a 2-week job-hunting sprint, an 8-week systematic deep-dive, and a desk-reference index for working builders — with day-by-day plans, weekly milestones, and a 20-question self-check.
GuideA precise definition and formula for AI Agents (LLM + planning + memory + tools), compared against the canonical statements from Anthropic, OpenAI, and IBM; the technical preconditions behind the 2023–2026 agent boom; and a complete minimal agent loop in 30 lines of pseudocode.
GuideThe paradigm shift from prompt engineering to context engineering — why context is a scarce resource, how the four strategies of writing/selection/compression/isolation land in practice, and the production-proven techniques for session compaction, tool masking, and KV-cache optimization validated by Manus and Claude Code.
Core ComponentsThe Agent Loop is the heart of every agent — the perceive-think-act-observe cycle dissected, complete pseudocode you can copy directly, a close reading of the ReAct pattern, a comparison of the loop designs of Claude Code, SWE-agent, and OpenHands, plus a countermeasures table for the three runaway patterns: infinite loops, thrashing, and premature exits.
Core ComponentsThe complete function-calling sequence and host-execution model, tool design principles that make the model "pick right and call right," answers to tool explosion (Tool Search / tiered exposure), the MCP protocol architecture and the 2026 ecosystem — plus a minimal runnable hand-written MCP server example.
Core ComponentsA systematic treatment of AI agent evaluation: why it's an order of magnitude harder than model evaluation, the four-layer framework from unit to trajectory to outcome to system, LLM-as-judge biases and calibration, the current landscape of SWE-bench, GAIA, OSWorld, τ-bench and other benchmarks, and how to build a contamination-resistant private eval.
AdvancedWhen multi-agent is worth it — and when it's over-engineering. This page unpacks the opposing positions of Anthropic Research and Cognition, five orchestration patterns, the state of the A2A protocol, real-system case studies, and quantified costs, giving you a decision framework for moving from a single agent to many.
AdvancedThe 2026 agent framework landscape — from bare SDKs and the OpenAI Agents SDK to the Claude Agent SDK, LangGraph, CrewAI, Microsoft Agent Framework, and low-code platforms — with a comparison table, hidden-cost analysis, and a decision tree you can actually follow.
Frameworks & PlatformsA deep dissection of the benchmark coding agent: its evolution from CLI to Web/SDK, the main agent loop + Task subagent architecture, the philosophy of general-purpose atomic tools, context compaction and subagent isolation, the permission model and hooks mechanism, plus a complete checklist of designs worth reusing in your own agent.
Case StudiesHand-write a working minimal Agent with nothing but the LLM API—no frameworks. Start from a 50-line Agent Loop, then layer on tool error feedback, a step cap, todo planning, and context compression, with complete runnable code and the expected traces at every step.
Hands-On GuidesPaper-by-paper deep dives into 10 foundational Agent papers: ReAct, Toolformer, MRKL, Chain-of-Thought, Tree of Thoughts, Reflexion, Generative Agents, Voyager, SWE-agent, and CodeAct — with arXiv IDs, method diagrams, experimental data, and their influence on later frameworks.
PapersA complete Agent engineer interview question bank: 10 concept questions, 8 system design questions, 4 hand-written coding questions, plus project deep-dives, open-ended opinion questions, and a list of questions to ask the interviewer. Each question comes with what it tests and a full answer framework, not a one-line canned answer.
Careers & JDsBrowse by section, or search directly
From ELIZA in 1966 to the 2025 coding-agent arms race — sixty years of intellectual history and five years of technical explosion for AI agents, explaining why ReAct, function calling, MCP, A2A, and other milestones appeared when they did, and distilling three reusable historical patterns.
Dissecting a production-grade agent system into six layers — perception, cognitive core, planning, action, memory, and governance — covering each layer's responsibilities, key design decisions, and common implementations, with a complete layered architecture diagram and a guided tour of one request through the system.
Untangling the most confused terms in the agent field — Anthropic's authoritative workflow-vs-agent split, and the boundaries between Agent, Chatbot, Copilot, RAG, Agentic AI, RPA, multi-agent, and Harness. Each concept gets a one-line definition, typical examples, and a "when you see X, it's Y" test — plus a technology-selection decision flowchart.
How to use this site's three learning routes — a 2-week job-hunting sprint, an 8-week systematic deep-dive, and a desk-reference index for working builders — with day-by-day plans, weekly milestones, and a 20-question self-check.
A precise definition and formula for AI Agents (LLM + planning + memory + tools), compared against the canonical statements from Anthropic, OpenAI, and IBM; the technical preconditions behind the 2023–2026 agent boom; and a complete minimal agent loop in 30 lines of pseudocode.
The paradigm shift from prompt engineering to context engineering — why context is a scarce resource, how the four strategies of writing/selection/compression/isolation land in practice, and the production-proven techniques for session compaction, tool masking, and KV-cache optimization validated by Manus and Claude Code.
The LLM itself is stateless — an agent's memory is entirely a system-design problem. This piece unpacks the short-term/long-term memory taxonomy (CoALA), summary compaction and salience retention, four long-term memory implementations (vector retrieval, structured profiles, file notes, knowledge graphs), and the hardest parts: write strategies and evaluation.
A systematic tour of the four classic agent planning patterns (ReAct, Plan-and-Execute, Tree of Thoughts, Reflexion), the engineering value of todo-list mechanisms, the debate over explicit planning in the reasoning-model era, and countermeasures for failure modes like over-planning and plan rigidity.
Prompt engineering for agent scenarios in practice — a four-layer anatomy of the System Prompt, tool descriptions and instruction hierarchy, advanced patterns like ReAct/planning/reflection, the limits of injection defense, and an eval-driven methodology for iterating on prompts.
An end-to-end engineering dissection of the RAG pipeline, from document parsing to reranked generation — chunking strategies compared, hybrid retrieval and reranking, vector database selection, what really makes Agentic RAG different, RAGAS evaluation, and a failure-troubleshooting checklist.
The Agent Loop is the heart of every agent — the perceive-think-act-observe cycle dissected, complete pseudocode you can copy directly, a close reading of the ReAct pattern, a comparison of the loop designs of Claude Code, SWE-agent, and OpenHands, plus a countermeasures table for the three runaway patterns: infinite loops, thrashing, and premature exits.
The complete function-calling sequence and host-execution model, tool design principles that make the model "pick right and call right," answers to tool explosion (Tool Search / tiered exposure), the MCP protocol architecture and the 2026 ecosystem — plus a minimal runnable hand-written MCP server example.
Breaking down the real token-consumption structure of agent tasks and where 10-100× costs come from, with practical techniques for model-tiered routing, prompt caching, context slimming, latency engineering, and rate-limit design — plus a before/after cost-optimization case with stated assumptions.
A systematic treatment of AI agent evaluation: why it's an order of magnitude harder than model evaluation, the four-layer framework from unit to trajectory to outcome to system, LLM-as-judge biases and calibration, the current landscape of SWE-bench, GAIA, OSWorld, τ-bench and other benchmarks, and how to build a contamination-resistant private eval.
A systematic treatment of human-in-the-loop engineering: risk-tiered approval models, allowlists and batch approvals that fight approval fatigue, checkpoint-based interrupt and resume, control-handover protocols, permission-design breakdowns of Claude Code / Cursor / Devin, and an unattended guardrail checklist.
When multi-agent is worth it — and when it's over-engineering. This page unpacks the opposing positions of Anthropic Research and Cognition, five orchestration patterns, the state of the A2A protocol, real-system case studies, and quantified costs, giving you a decision framework for moving from a single agent to many.
The three pillars of agent observability, the trace data model (runs/spans/events), a current-state comparison of LangSmith / Langfuse / Helicone and the OTel GenAI semantic conventions, a debugging methodology for working backward from failed traces to root causes, and the production monitoring metric set.
A systematic breakdown of the AI agent attack surface and defenses: why prompt injection (direct and indirect) is the number-one threat, post-mortems of real incidents like EchoLeak and the GitHub MCP exploit, engineering practices for least privilege and sandbox isolation, a reading of the OWASP LLM Top 10 2025, and how to red-team your own agent.
Microsoft Research's conversational multi-agent framework — the Core/AgentChat/Extensions three-layer architecture after the 0.4 rewrite, Team orchestration modes, and the Magentic-One system — plus the real 2026 selection advice now that AutoGen has been folded into Microsoft Agent Framework.
The agent harness that powers Claude Code, opened up as an official SDK — file/Bash tools out of the box, with subagents, Skills, hooks, MCP, and a permission system built in. Build production-grade long-running agents in a few dozen lines of Python or TypeScript.
CrewAI defines agents with "role + goal + backstory," uses Crews for autonomous collaboration and Flows for event-driven control — one of the fastest multi-agent frameworks to ship with. Based on the v1.15.x docs, this page covers the core concepts, runnable code, the philosophical differences from LangGraph/AutoGen, and real community criticism.
The 2026 agent framework landscape — from bare SDKs and the OpenAI Agents SDK to the Claude Agent SDK, LangGraph, CrewAI, Microsoft Agent Framework, and low-code platforms — with a comparison table, hidden-cost analysis, and a decision tree you can actually follow.
LangGraph is the agent orchestration layer of the LangChain ecosystem — a graph state machine that gives you explicit control over every step an agent takes. Based on the v1.x docs as of August 2026, this page covers State/Node/Edge, the Checkpointer, human-in-the-loop with interrupt, deployment with LangSmith Deployment, how the ecosystem divides responsibilities — and an honest take on the complexity controversy.
OpenAI's official lightweight agent framework — the production-grade successor to Swarm. Six primitives (Agent / Handoff / Guardrail / Session / Tracing) cover most agent applications; it defaults to the Responses API but is not locked to OpenAI models.
Released in March 2023 as the fastest-growing repo in GitHub history, AutoGPT ignited the first wave of agent mania—and then taught the whole industry a lesson through its own failure. This page reviews the flaws of its original architecture, the engineering lessons it left, and its 2026 transformation into the visual AutoGPT Platform.
A deep dissection of the benchmark coding agent: its evolution from CLI to Web/SDK, the main agent loop + Task subagent architecture, the philosophy of general-purpose atomic tools, context compaction and subagent isolation, the permission model and hooks mechanism, plus a complete checklist of designs worth reusing in your own agent.
ByteDance's low-code agent building platform: bot orchestration, plugins, workflows, knowledge bases, and multi-channel publishing in one place; coze-studio and coze-loop open-sourced in July 2025, with Coze 3.0 pivoting to multi-agent collaboration in 2026. This page dissects its capabilities, inferred architecture, pricing, and the boundaries with Dify/n8n.
From Copilot alternative to a multi-billion-dollar-ARR agentic IDE: a teardown of Cursor's Tab completion, Agent mode, codebase semantic indexing, and the in-house Composer models—plus the contest between the "IDE-embedded" and "terminal-autonomous" agent product routes.
A full retrospective of Cognition's "AI software engineer" Devin: from the sensational 2024 launch at 13.86% on SWE-bench and the Upwork demo controversy, through the 25x price cut of 2025 and the Windsurf acquisition, to the 2026 $26B valuation and $492M annualized revenue—plus the real lessons it left for agent engineering.
A deep dive into Dify, the open-source LLM application development platform: the 140K-star project from the Suzhou Yuling team, covering visual Workflow/Agent orchestration, the RAG engine, the plugin system, and two-way MCP support, with self-hosting architecture, commercialization model, and comparisons against Coze/n8n/LangFlow.
The general-purpose AI agent that broke out in March 2025 on the strength of one demo video: invite codes scalped for tens of thousands of dollars, self-reported SOTA across all three GAIA tiers, then a $2 billion sale to Meta a year later that Chinese regulators blocked. This page dissects its multi-agent architecture, VM sandbox, and that Context Engineering blog post the whole industry forwarded.
From OpenDevin to OpenHands: dissecting this open-source, community-driven full-stack development agent platform—the event stream architecture, the CodeAct "actions as code" action space, the Docker sandbox runtime, microagents, plus its real SWE-bench performance and its design divergence from SWE-agent.
The most successful productization of search × LLM: a teardown of Perplexity's retrieval-augmented answer generation, citation provenance, and the Deep Research multi-step research agent; tracing its evolution from answer engine to the Comet browser, its business model, and its copyright controversies.
The Princeton team's classic 2024 work introducing the Agent-Computer Interface (ACI): tool interfaces should be designed for the model, not for humans. Interface optimization lifted SWE-bench solve rates from 3.8% to 12.5%, and mini-SWE-agent's 100 lines of code made the reverse case that scaffolds have a shelf life.
Eight Agent design principles distilled from front-line practice at Anthropic, SWE-agent, Claude Code, and others: simplicity first, design interfaces for the model, observability, design for recovery, context is scarce, tiered permissions, evals first, and simplify as models evolve. Each comes with its source, positive and negative examples, and actionable check items.
Hand-write a working minimal Agent with nothing but the LLM API—no frameworks. Start from a 50-line Agent Loop, then layer on tool error feedback, a step cap, todo planning, and context compression, with complete runnable code and the expected traces at every step.
A complete eval suite for the tutorial's research assistant Agent: a 20-50 task tiered task set, a two-layer grader combining code assertions with LLM-as-judge (including the full judge prompt), trajectory and cost logging, a CI regression workflow, a runnable Python eval script, and a real "eval caught a regression → diagnosis → fix" post-mortem.
The compendium of Agent development failures: 12 high-frequency anti-patterns, each broken down as "symptom → root cause → fix," from multi-Agent over-engineering and context bloat to prompt tuning without evals, plus post-mortems of public incidents like Replit's database deletion and Cursor's support-bot hallucination.
Six job-hunting Agent portfolio projects, from shallow to deep, covering RAG, the Agent Loop, deep research, browser automation, multi-Agent orchestration, and human approval—each with milestone breakdowns, resume phrasing, and likely interview follow-ups.
Three progressive projects built with the OpenAI Agents SDK: a weather chat Agent you can get running in 30 minutes, a research assistant with a todo list and file-based memory, and a researcher/writer/critic multi-Agent setup with a minimal eval script—plus a comparison table of the three versions' complexity and capability boundaries.
AGENTS.md has become the cross-tool open standard adopted by 60,000+ open-source projects, and CLAUDE.md is Claude Code's counterpart. This guide gives a structure template you can apply directly, side-by-side good and bad examples, layered scope rules, and maintenance discipline, so the "onboarding document" in your repo genuinely changes the agent's behavior in every session.
Paper-by-paper deep dives into 10 foundational Agent papers: ReAct, Toolformer, MRKL, Chain-of-Thought, Tree of Thoughts, Reflexion, Generative Agents, Voyager, SWE-agent, and CodeAct — with arXiv IDs, method diagrams, experimental data, and their influence on later frameworks.
A survey of seven frontier directions in Agent research for 2025-2026 — Agentic RL, Deep Research, Computer Use, self-improvement, lifelong learning, multi-agent protocols, and safety research — with representative work for each and a clear "worth watching or hype" verdict.
Organizing the 2022-2026 Agent research landscape into a navigable map: nine sections covering reasoning and planning, tool use, memory, multi-agent, embodied AI, Coding Agents, evaluation, safety, and surveys — each with verified representative papers' arXiv IDs and a one-line status assessment.
A three-stage Agent paper reading list: 5 beginner papers to build intuition (ReAct, CoT, Toolformer, MRKL, Generative Agents), 8 intermediate papers to build system-level skills (Reflexion, Voyager, SWE-agent, CodeAct, and more), and a frontier stage focused on 2025-2026 agentic RL, Deep Research, and self-improvement. Each entry includes an arXiv ID, a one-line value statement, estimated reading time, and prerequisites.
An introduction to the paper deep-dive module: why Agent engineers need to read papers, how this module selects its papers, how to apply the three-pass reading method to Agent papers, how to spot benchmark contamination and cherry-picking, and the arXiv toolchain that still works in 2026.
The special resume rules for Agent roles: why projects matter more than credentials, how to apply the STAR method to Agent projects (with 3 full rewrite cases), the red lines of tech-stack keywords, and the portfolio/open-source paths for people with zero experience—plus a 20-item pre-application self-check.
A complete Agent engineer interview question bank: 10 concept questions, 8 system design questions, 4 hand-written coding questions, plus project deep-dives, open-ended opinion questions, and a list of questions to ask the interviewer. Each question comes with what it tests and a full answer framework, not a one-line canned answer.
Translating the high-frequency keywords of Agent job JDs into actionable test points: what LangGraph questions actually get asked, the shallow and deep tiers of RAG experience, the standard answer for Agent architecture, the real bar for prompt engineering, plus the post-2025 MCP requirement—with capability profiles and learning priorities.
About 20 live Agent-track JDs compiled from real searches in August 2026: domestic coverage includes ByteDance, Alibaba, Tencent, Meituan, and MiniMax; overseas includes OpenAI, Anthropic, Cursor, Cognition, and Sierra—each with a source link, ending with a word-frequency summary of high-frequency JD requirements.
Breaking down the five job types of the 2025-2026 Agent wave (Agent Engineer, AI Application Engineer, Platform Engineer, AI Infra, Agent-track Product Manager), with verified salary bands at home and abroad, hiring-demand data, and three transition routes from backend/ML/frontend.
A navigation guide to Agent learning resources organized into seven categories—official docs, books and courses, engineering blogs, open source frameworks, benchmarks and datasets, community sources, and awesome lists—each entry carrying a one-line verdict on its value and who it suits. All links verified.
A collection of 120+ core AI Agent terms organized into seven groups — foundational concepts, reasoning & planning, tools & protocols, memory & retrieval, architecture & orchestration, engineering & operations, and products & ecosystem. Each entry carries a precise one-sentence definition plus links for deeper reading on this site, with anchors for cross-jumping between entries — a pocket dictionary to keep at hand across the whole site.
A close reading of six published or leaked system prompts — Claude, ChatGPT/Codex, Cursor, Devin, Manus, and Perplexity — dissecting their structure, distilling reusable tool-description and boundary-setting techniques, and summarizing ten traits shared by top-tier Agent prompts.
