#🚀 The Yellowbook Of Agents

🔥 NEW: Agentic Cost vs Latency Calculator — Interactive tool to compare cost and latency tradeoffs across different agentic architectures and LLM choices. Try it now!

🚀 The Yellowbook Of Agents
A field guide to how AI agents learned to think, act, and endure

This Yellowbook is a living one pager that will be updated whenever a new, truly pivotal idea lands in agent design. It is not a random link dump but a lineage: each piece builds on the last, from first principles to deep, durable, trainable agents.

---

#Table of Contents

1. Foundations of agents as systems
2. Code as the primary action space
3. Skills, MCP and code execution
4. From shallow loops to deep, event driven agents
5. Durable execution and resilient backends
6. Training agents, not just prompting them
7. A living Yellowbook

---

#1️⃣ Foundations of agents as systems

Start here to get the mental model right.

• Original Google Agents whitepaper (Part 1)
  https://archive.org/details/google-ai-agents-whitepaper
  This is the conceptual baseline that defines an AI agent as model plus tools plus orchestration plus runtime and walks through the five step think → scan → plan → act → observe loop. It introduces the first taxonomy from “simple connected problem solvers” up toward basic multi agent systems and shows how context curation, not just model quality, is the core skill.

• Agents Companion (Part 2)
  https://www.kaggle.com/whitepaper-agent-companion
  The Companion is the 102 follow on that takes the same architecture and pushes it into production realities. It dives into agent evaluation and LM judges, Agent Ops, observability, traces, regression testing, multi agent patterns and agentic retrieval, with concrete case studies. This is where the theory turns into a playbook for building and operating serious systems.

• Introduction to Agents and Agent Architectures (Nov 2025)
  The later Google whitepaper ‘Introduction to Agents and Agent Architectures’ (https://www.kaggle.com/whitepaper-introduction-to-agents) refines all of this into the Level 0–4 ladder and formalizes agents as ‘context window curators’. It pulls Part 1 and the Companion together into a single, up to date architecture document.

🎯 Yellowbook intent Read these three as a mini book: Part 1 for definitions, Companion for operations, and the November 2025 architecture paper for the current taxonomy and synthesis.

#2️⃣ Code as the primary action space

Next, learn how agents stopped speaking JSON and started writing code.

• CodeAct: Executable Code Actions Elicit Better LLM Agents
  Paper and repo: https://machinelearning.apple.com/research/codeact and https://github.com/xingyaoww/code-act
  CodeAct shows that when agents emit executable Python instead of rigid tool calls, they become far better at composing tools, managing state and iterating on mistakes. It ships an instruction tuning dataset and open models that act through code, not bespoke schemas.

• Building Effective AI Agents (Anthropic)
  https://www.anthropic.com/engineering/building-effective-agents
  This piece bridges ReAct style loops and more structured architectures, covering task decomposition, tool design, error handling and human in the loop. It is a practical bridge between the Google foundations and the emerging code first patterns.

🎯 Yellowbook intent
After this stage you should see “agent action” as writing and running code over tools and data, with the orchestration layer deciding when to think, when to call code and when to involve humans.

#3️⃣ Skills, MCP and code execution

Now, move from raw tools to structured skills and protocols.

• Anthropic Agent Skills
  Product and engineering posts plus docs:
  https://www.anthropic.com/engineering/equipping-agents-for-the-real-world-with-agent-skills
  https://claude.com/blog/skills
  https://platform.claude.com/docs/en/agents-and-tools/agent-skills/overview
  Skills are directory based bundles of capability: SKILL.md, scripts and resources that Claude can discover, inspect and execute on demand. They introduce progressive disclosure over a filesystem, so agents only ingest what is relevant, and they rely on an integrated code execution tool.

• Code execution with MCP
  https://www.anthropic.com/engineering/code-execution-with-mcp
  Here MCP is reframed as plumbing, not the main UX. The agent writes code inside a sandbox that imports MCP backed APIs, filters and aggregates data and only surfaces summaries in the model loop. It is CodeAct’s thesis applied to a standard protocol.

• Cloudflare Code Mode
  https://blog.cloudflare.com/code-mode/
  Code Mode automatically generates a typed TypeScript SDK from MCP tools and lets the LLM write and run TS code inside Workers. You get the same code centric pattern with MCP as the transport and Cloudflare as the sandbox.

🎯 Yellowbook intent
This cluster explains why the ecosystem converged on “code over MCP and skills” as the control plane for serious agents.

#4️⃣ From shallow loops to deep, event driven agents

With the substrate in place, step up to deep orchestration and real time behavior.

• Agents 2.0: From Shallow Loops to Deep Agents
  https://www.philschmid.de/agents-2.0-deep-agents
  Deep Agents are defined by explicit planning, hierarchical sub agents, persistent memory and extreme context engineering. This is the high level orchestration pattern that assumes code execution, filesystems and tools are already available.

• LangChain: Doubling down on DeepAgents
  https://blog.langchain.com/doubling-down-on-deepagents/
  DeepAgents is shipped as a harness that bakes in planning tools, sub agents, pluggable backends for files and memories, large result eviction and history summarization, so you can get Agents 2.0 behavior with minimal scaffolding.

• Pepper: Real time event driven agentic systems
  https://rllm-project.com/post.html?post=pepper.md
  Pepper focuses on always on, event driven architectures. Agents subscribe to events, wake up, run their deep plans and publish new events. It moves the whole stack from simple request–response chat to proactive, reactive systems.

🎯 Yellowbook intent
Read these together to see how modern agents become long running, multi agent and event aware, built on top of the code plus skills plus MCP foundations.

#5️⃣ Durable execution and resilient backends

Next, learn how to make those agents survive real infrastructure.

• Restate: Durable agents and workflows
  https://restate.dev
  Restate gives you durable execution, consistent state and reliable messaging for agents and workflows. You write straightforward async code, Restate checkpoints progress and recovers from failures, making long running multi step agent logic behave like a single coherent process.

🎯 Yellowbook intent
This is where “deep, event driven” meets “actually survives crashes and retries.” Pair Restate with Pepper and DeepAgents in your mental model.

#6️⃣ Training agents, not just prompting them

Finally, close the loop with learning.

• Agent Lightning (Microsoft)
  Docs: https://microsoft.github.io/agent-lightning/stable/
  Repo: https://github.com/microsoft/agent-lightning
  Agent Lightning is a framework for reinforcement learning on agents. It consumes traces of prompts, tool calls, observations and rewards from your existing runtime and improves policies without forcing you to rebuild your system around a special trainer loop.

🎯 Yellowbook intent
Once you have instrumentation from Agents Companion and a runtime from the previous sections, Agent Lightning shows how to turn all that signal into better agent behavior over time.

---

#📚 A living Yellowbook

This Yellowbook will be updated whenever a new, clearly transformative idea lands for agent building. The bar is high: new entries must either reshape the core architecture, introduce a fundamentally better execution or safety model, or unlock a new regime of scale or learning.

Use this blog as your map: skim it to understand the lineage, then dive down each link to go deep where you need it most.