“The unit of AI is no longer the message. It's the task.”

#The hook

This is the field manual for the architecture, with six interactive demos.

#Why this matters in 2026 — the receipts

#The agent loop

#See the loop

#Tools — the agent's hands

An agent with no tools is a chatbot. The right set of tools is what makes an agent powerful.

#MCP — the universal tool interface

#Memory — what the agent remembers

A useful agent remembers things across actions and across sessions. There are four kinds of memory:

#Multi-agent — when one isn't enough

For complex tasks, multiple agents collaborate — a planner agent decomposes the work, specialist agents handle subtasks, a supervisor reviews. CrewAI, AutoGen, LangGraph all bet on this model.

#Tree of thought — explore multiple plans

The reasoning pattern that broke math benchmarks: instead of generating one chain of thought, generate many — and pick the best one.

#A real-ish agent — runnable

# A toy agent loop in pure Python
import json

# Pretend tools — in a real agent these'd hit real APIs
def search_docs(query):
    return f"[search results for '{query}']: docs about RAG, agents, MCP"

def write_file(path, content):
    return f"wrote {len(content)} chars to {path}"

TOOLS = {"search_docs": search_docs, "write_file": write_file}

# Pretend LLM — in a real agent, ask Claude/GPT for the next action
def llm_decide(goal, history):
    """Toy planner: decides what tool to call next based on history length."""
    if len(history) == 0:
        return {"tool": "search_docs", "args": {"query": "agent loop"}}
    elif len(history) == 1:
        return {"tool": "write_file",
                "args": {"path": "summary.md", "content": "Agents = LLM + tools + loop."}}
    else:
        return {"tool": None, "answer": "Done!"}

# The agent loop
goal = "Write a summary of how agents work to summary.md"
history = []

print(f"Goal: {goal}\n")
for step in range(5):
    decision = llm_decide(goal, history)
    if decision.get("tool") is None:
        print(f"Step {step}: FINISHED -> {decision['answer']}")
        break
    tool_name = decision["tool"]
    args = decision["args"]
    print(f"Step {step}: calling {tool_name}({json.dumps(args)})")
    result = TOOLS[tool_name](**args)
    print(f"  result: {result}")
    history.append({"tool": tool_name, "args": args, "result": result})

#What's been built with agents

#The 2026 frontier

#Where to go next

1. AI Agents track — 16 lessons: agent loop, tool use, MCP, multi-agent, computer use.
2. Claude Code Mastery — the canonical coding agent.
3. NLP & Transformers — every agent has an LLM in its planner box.
4. RAG Systems — agents need memory. RAG is the foundation.

#Key takeaways

#References & further reading

• Anthropic — Building Effective Agents (2024). The most important field-guide article.
• Yao et al. — ReAct: Synergizing Reasoning and Acting (ICLR 2023). The reasoning-acting interleave pattern.
• Shinn et al. — Reflexion: Language Agents with Verbal Reinforcement Learning (NeurIPS 2023). Reflection.
• Model Context Protocol spec (modelcontextprotocol.io). Anthropic's open standard.
• SWE-bench (swebench.com) — the canonical agent benchmark.
• Lilian Weng — LLM-powered Autonomous Agents (lilianweng.github.io). Foundational survey.