🚀 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

Foundations of agents as systems
Code as the primary action space
Skills, MCP and code execution
From shallow loops to deep, event driven agents
Durable execution and resilient backends
Training agents, not just prompting them
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.

🎯 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.

Yellowbook Agents Related Posts