Day 17 — Synthesis: Building Your Agent Strategy

Core Concept

What an “Agent Strategy” Actually Is — the Five Axes and the Six Layers

Imagine you ran a logistics company in 1995, and someone said “we need an internet strategy.” The naive answer was “buy a server, put up a website.” The strategic answer was four orthogonal questions: which workflows move online vs. stay phone-and-fax? do we run our own datacenter or rent? do we standardize on TCP/IP only or also Novell? do we own the customer, or syndicate through Yahoo and AOL? Different combinations produced different companies. UPS and Pets.com both had “internet strategies” in 1999 — one was a coherent set of bets that compounded, one was a slogan. An agent strategy is the same kind of artifact: not a tool choice, but a coherent set of bets across a small number of orthogonal axes that compound or contradict each other.

The first 16 days of this curriculum unpacked the building blocks: the ReAct loop (Day 01), four memory tiers (Day 02), planning algorithms (Day 03), RAG (Day 04), frameworks (Day 05), benchmarks (Day 06), multi-agent systems (Day 07), GUI automation (Day 08), code agents (Day 09), long-horizon decomposition (Day 10), safety (Day 11), economics (Day 12), self-improvement (Day 13), OpenClaw (Day 14), A2A (Day 15), and agentic commerce (Day 16). The capstone reorganizes those building blocks along five strategic axes — the things you actually have to decide — and one reference stack of six layers that any production agent system has to populate.

The five strategic axes

1

Axis

Capability vs. Reliability

How far down the autonomy gradient do we let the agent go before a human checkpoint?

The single highest-leverage choice. The Pan et al. production survey (Day 06 territory) found 68% of production agents take at most 10 steps before requiring human intervention — the long-horizon autonomy that demos sell is rarely what ships. Picking 3-step vs. 30-step horizons changes everything: prompts, tool design, eval harness, error budgets, even your insurance posture.

Reliability pole

3-step bounded loops, hard schemas, deterministic tools, every output reviewed

Capability pole

30+ step deep agents, free-form planning, post-hoc audit only

2

Axis

Build vs. Buy — the Layer Question

At which of the six stack layers do we differentiate, and where do we rent?

Forrester is forecasting that ~75% of enterprises trying to build their own agentic systems from scratch will fail; the leading pattern is to buy the runtime and orchestration layers (LangGraph, LlamaIndex, Bedrock AgentCore, Vertex Agent Builder), and build only the skill / tool / domain-data layers where you have real proprietary advantage. The trap is inverting that: building your own runtime, then buying generic skills.

Build the runtime

Full control, slow ship, brittle — the Day 05 framework war is over and you lost

Buy the runtime

Ship in weeks, focus your engineering on tools, evals, and the domain

3

Axis

SLM-first vs. LLM-only

Do we route the routine 80% of agent calls to small specialized models, or pay frontier prices on every step?

The Belcak / Heinrich paper from NVIDIA Research (June 2025, revised Sep 2025) argues that small language models are not a fallback — they are the structurally correct choice for most agent invocations, because agent calls are repetitive, narrow, and latency-sensitive. The economic gap (Day 12) is 10–30× on cost-per-task. Heterogeneous routing — SLM by default, LLM on escalation — is the compromise frontier teams now ship.

LLM-only

One frontier model on every step. Easy. Bleeds money at scale.

SLM-routed

Cheap distilled or fine-tuned model handles classification, parsing, summarization; LLM only for hard reasoning

4

Axis

Single-agent vs. Multi-agent

When does adding a second agent help, and when does it just multiply your failure modes?

Day 07 was emphatic: multi-agent “debate” and committee patterns add cost faster than they add quality on most tasks. The empirical trend in 2026 (LangChain’s State of Agent Engineering, Anthropic’s post-mortems, the Pan et al. survey) is that most production systems are single planner + many tools, and only escalate to true multi-agent (orchestrator + specialists, A2A handoffs from Day 15) when domains are deeply heterogeneous.

Single planner

One agent, many tools. Fewer moving parts. Easier to evaluate.

Orchestrated multi

A2A handoffs across specialists. Justified only when domains differ structurally.

5

Axis

Closed Stack vs. Open Protocols

Do we lock into one platform’s ecosystem (Claude / Gemini / OpenAI), or invest in the protocol layer (MCP, A2A, AP2, x402)?

The protocols recap from Days 14–16: MCP (Day 03/14) for tools, A2A (Day 15) for inter-agent trust, AP2/ACP/x402 (Day 16) for value transfer. A closed-stack bet is fast and integrated; an open-protocol bet is portable and futureproof. Most serious enterprises now ship both: one preferred platform for the user-facing agent, but every tool and skill exposed via MCP so the underlying business logic is portable.

Closed stack

One vendor, one SDK, max integration. Hostage on roadmap and pricing.

Protocol-first

MCP / A2A / AP2 everywhere. More plumbing today, optionality tomorrow.

The six-layer reference stack

Every production agent system — whether it’s Claude Code, a Vertex AI Agent, a CrewAI workflow, or a homemade LangGraph — populates these six layers. Knowing the layers lets you point at any vendor pitch and say “you sold me layer 3 and called it the whole stack.”

Layer 6 · UX

The interaction surface. Chat UI, IDE, voice, browser extension, computer-use canvas. This is where most CGOs default-think the agent “is.” It’s actually the thinnest layer.

Layer 5 · Orchestration

The control flow. ReAct loop, ReWOO, Tree-of-Thoughts, deep-agents harness. LangGraph, AutoGen, CrewAI, OpenAI Agents SDK live here. Day 03 + Day 05.

Layer 4 · Memory + Retrieval

The state of the agent. Working memory, episodic store, semantic vector index, RAG pipeline. Day 02 + Day 04. The Pan et al. survey called state management “the leading source of production incidents.”

Layer 3 · Tools + Skills

The agent’s effector arms. MCP servers, function-calling schemas, OpenClaw skills (Day 14), computer-use primitives (Day 08). This is the layer most worth differentiating on.

Layer 2 · Models + Routing

The brains. Frontier LLM, specialized SLMs, the router that picks between them. Day 12 economics + the Belcak SLM thesis live here.

Layer 1 · Trust + Eval + Safety

The ground floor. Sandboxing (Day 11), prompt-injection defense, observability, eval harnesses (Day 06), agent-to-agent trust models (Day 15), payment mandates (Day 16). The layer everyone underspecs and the one auditors will drill into first.

Two practical observations once you draw your stack on a whiteboard. First, very few teams own all six layers; most own three (typically 6, 3, and 1) and rent the rest. Second, the layer where you don’t differentiate becomes the layer that locks you in — if you let one vendor own your orchestration and your model routing and your tools, you have not bought an “agent” in any meaningful sense; you have bought a black box that happens to talk.

A useful test for any board-deck claim: ask the team to literally circle which of the six layers they own and which they rent. If the answer is “all six” or “the model handles it”, you have not yet found your strategy — you’ve found a marketing slide.

Production Reality Check

Three Numbers That Should Anchor Every Agent Decision

68%

Production agents that take at most 10 steps before human checkpoint Pan et al., arXiv:2512.04123

~75%

Forrester forecast for enterprise “build-your-own” agent systems that won’t make it to production

10y

Karpathy’s timeline for “decade of agents” — the baseline you should plan against

Every strategic conversation should reference at least one of these. The first says the agent is shorter than your demo. The second says the moat is not the runtime. The third says this is a compounding bet, not a sprint. If a vendor pitch is incompatible with all three numbers, walk.

Papers To Know

Three Pieces of Reading That Synthesize the Field

arXiv preprint 2025 First-of-Kind

Measuring Agents in Production

Melissa Z. Pan and 24 co-authors · arXiv:2512.04123 · submitted Dec 2, 2025 (v3 Feb 2026)

The first large-scale empirical study of how AI agents are actually built in production. Combines a 306-practitioner survey with 20 in-depth case studies across 26 domains. The headline finding: production agents are far simpler than the literature suggests — 68% bounded to ≤10 steps, 70% rely on prompting off-the-shelf models (no fine-tuning), 74% rely primarily on human evaluation. Reliability, not capability, is the named #1 challenge.

Why it matters: The first paper that makes “what does production actually look like” a citable answer. Use it to push back on demos that show 50-step autonomous agents and call them “the future” — current production reality is a different shape.

arxiv.org/abs/2512.04123

arXiv preprint 2025 Position

Small Language Models are the Future of Agentic AI

Peter Belcak, Greg Heinrich, Shizhe Diao, Yonggan Fu, Xin Dong, Saurav Muralidharan, Yingyan Celine Lin, Pavlo Molchanov · NVIDIA Research / Georgia Tech · arXiv:2506.02153 · v1 June 2025, v2 Sep 2025

A position paper arguing that the agentic-AI literature’s default of “always call the biggest LLM” is structurally wrong. Most agent invocations are narrow, repetitive, and latency-sensitive — the exact regime where small specialized models dominate on cost, latency, and reliability. The paper sketches a heterogeneous-agent architecture (SLM by default, LLM on escalation) and an LLM-to-SLM conversion algorithm.

Why it matters: Reframes Day 12’s economics as an architecture choice rather than an optimization. If you can only read one paper to understand why “agents are too expensive to ship” is a strategy bug not a price bug, this is it.

arxiv.org/abs/2506.02153

arXiv preprint 2025 Survey

Agentic AI: A Comprehensive Survey of Architectures, Applications, and Future Directions

multi-author survey · arXiv:2510.25445 · October 2025

A PRISMA-style review of 90 studies (2018–2025) that organizes the agent literature along a dual paradigm: symbolic / classical (algorithmic planning, persistent state) versus neural / generative (stochastic generation, prompt-driven orchestration). Includes domain reviews in healthcare, finance, and robotics, and a paradigm-by-paradigm ethical analysis.

Why it matters: The single most useful taxonomy paper if you have to brief a board on “what are agents really.” Use the symbolic/neural axis — combined with the five strategic axes above — as the scaffolding for any agent strategy doc.

arxiv.org/abs/2510.25445

GitHub Pulse

The 2026 Reference-Stack Repos

Six repos that, between them, populate every layer of the reference stack. Star counts are approximate, captured from public listings around April 2026 — treat them as “order of magnitude” signals, not benchmarks.

langchain-ai/langchain Foundational ~135K

The aggregation library that started the agentic ecosystem. Now mostly stable scaffolding for chains and integrations.

Layer 5 (orchestration). The 1.0 release narrowed scope — abstractions over LangGraph rather than a competing runtime.

langchain-ai/langgraph Production-default ~30K

Stateful graph runtime for resilient long-running agents — streaming, checkpointing, human-in-the-loop, durable execution.

The 2026 default for production-grade Layer-5 orchestration. Where LangChain became serious.

microsoft/autogen Maintenance ~56K

The original conversational multi-agent framework. Officially in maintenance mode — succeeded by Microsoft Agent Framework (Semantic Kernel + AutoGen merged).

Important to know what was there. Plan migrations off this for any new work.

crewAIInc/crewAI Fastest-growing ~45K

Role-based multi-agent orchestration — agents declared as personas (analyst, writer, critic) with crew-level workflows.

Layer 5 alternative when team semantics matter more than graph semantics. Native MCP and A2A in v1.10.x.

openai/openai-agents-python New ~18K

OpenAI’s production successor to the experimental Swarm framework. Provider-agnostic, supports 100+ LLMs.

Bridges Codex / GPT-5.x agent semantics into a portable SDK. Lightweight; pairs well with existing orchestration.

modelcontextprotocol/servers Protocol ~79K

Reference and community-built MCP server implementations — the de facto standard for connecting tools, databases, and apps to any agent.

Layer 3 (tools). MCP became the protocol-of-choice in 2025; over 1,200 community servers now listed.

A repo that doesn’t fit a layer is worth being suspicious of. CrewAI and LangGraph both look like Layer 5 but pull in retrieval and memory pieces — that’s fine for a starter, but watch for them quietly migrating into your Layer 4 if you weren’t paying attention.

Community Pulse

What the Field’s Loudest Voices Are Actually Saying in April 2026

AK

Andrej Karpathy

@karpathy · OpenAI co-founder, ex-Tesla AI, Eureka Labs

“It will take about a decade to work through all of those issues.”

Karpathy on the Dwarkesh Podcast (Oct 2025), pushing back on the “2025 is the year of agents” framing. The named issues: continual learning, multimodality, computer use, and raw intelligence — not engineering polish, but research questions. Anchor your roadmap on this timeline, not on demo-day cycles. [source]

AK

Andrej Karpathy

@karpathy · March 2026, on autoresearch

Karpathy has argued in 2026 that the personal-coding split has flipped: from 80/20 in favor of writing his own code to roughly 20/80 in favor of delegating to agents. His framing for operators: “parallelize your judgment, not just your code.”

From his March 2026 commentary on autoresearch (the experiment that ran 700 ML experiments unattended over two days). The strategic point: the bottleneck moves from typing to deciding which agent runs to inspect and which to merge. [autoresearch]

SW

Simon Willison

@simonw · Datasette / LLM tools

“An LLM agent runs tools in a loop to achieve a goal.”

Willison’s widely-shared definition from September 2025 — the moment he stopped scare-quoting “agent.” Useful as a sanity check: anything called an “agent” should pass this test. If it’s not running tools, it’s a chatbot; if it’s not in a loop, it’s a single tool call; if there’s no goal, it’s a workflow. [source]

HC

Harrison Chase

@hwchase17 · LangChain CEO · Interrupt 2026 keynote

Chase has argued that “deep agents” aren’t a new architecture — they’re the same loop with sophistication around the loop: planning, context management, sub-agents, file-system-as-state. LangGraph is the runtime, LangChain is the abstraction, deep agents are the harness with batteries included.

From the LangChain blog and 2026 podcast appearances. Practical takeaway: most teams don’t need a new framework — they need richer prompts, better state management, and a planning sub-system on top of the same ReAct skeleton. [reflections]

GB

Greg Brockman

@gdb · OpenAI President

Brockman has argued throughout 2026 that the user’s role is shifting from operator to overseer — “the CEO of an autonomous corporation, or a fleet of agents” — and that responsibility entrusted to the agent must be ramped together with security, observability, and oversight.

From his April 2026 Big Technology interview discussing GPT-5.5 and the Codex agent harness. Treat “ramp responsibility with observability” as a hard rule: agent capability without proportional eval coverage is a liability not an asset. [interview]

Platform Deep-Dive

How the Four Major Platforms Each Want You to Build Your Strategy

None of these vendors agree on the strategy — that’s the point. The shape of their bet leaks in their docs, their pricing pages, and where they put their best engineers.

Platform	Strategic posture	Recent move (last 30 days)
Claude (Anthropic)	“Computer-use anywhere” + Constitutional safety. Wants to own Layer 6 and Layer 1 (UX + trust). Pushes Skills (Day 14) and MCP (Day 03) for Layers 3 and 5.	Skills marketplace expansion; Project Deal commerce experiments; Cowork (this product) extends Claude into desktop control.
Codex / GPT-5.5 (OpenAI)	“Superapp” vision — one harness for chat, code, browser. Wants to own Layer 5 and Layer 6 inside ChatGPT, with the OpenAI Agents SDK as the escape hatch.	GPT-5.5 release with explicit agentic capabilities; Codex agent harness positioned as a general agent runtime.
Gemini 3.1 (Google / Vertex)	Protocol-first — AP2 (Day 16) for payments, A2A (Day 15) for inter-agent, MCP for tools. Bets on owning Layer 1 and Layer 2 via Vertex.	Vertex Agent Builder GA; AP2 partner expansion; Gemini 3.1 multi-agent reasoning improvements.
OpenClaw 2.1	Hub-and-spoke skill ecosystem (Day 14) — bets on Layer 3 (skills) and Layer 1 (sandbox + signed skills) being where the value lives. Protocol-agnostic at Layer 5.	SKILL.md schema v2; signed skills enforced after the 9-CVE / 1184-malicious-skills incident; payment_protocol field for ACP / AP2 / x402.

The synthesis read: Anthropic and OpenAI are competing for the same Layer 5+6 surface; Google is competing on protocols (Layer 1+2); OpenClaw is competing on skills (Layer 3). A serious enterprise strategy almost always picks one Layer 5+6 (Claude or OpenAI) for the user-facing agent, layers Google’s protocols for trust and payments, and ships OpenClaw or MCP at Layer 3 for portability. The naive bet is to pick one vendor for all four.

Watch for the “agent washing” pattern: a vendor showing you their Layer-6 chat surface and using the word “agent” eight times in one slide. Ask which of the other five layers they actually own. If the answer is none, you’re looking at a chat product priced as an agent.

Vocabulary

Eleven Strategic Terms That Belong in Every Agent Strategy Doc

decade-of-agents

A planning-horizon framing borrowed from Karpathy: progress on agents is a 10-year arc gated by research breakthroughs (continual learning, real multimodality, computer use, intelligence). Implies “compounding bets” not “quarterly milestones.”

Avoid: using it as fatalism (“so we shouldn’t bother”) — the point is to plan against the right cadence.

“Our roadmap assumes a decade-of-agents shape: we ship today on bounded autonomy, but our data and tools compound for a deeper agent in 2030.”

six-layer reference stack

UX · orchestration · memory/retrieval · tools/skills · models/routing · trust/eval. Any production agent populates these six layers; the layer you don’t own is the layer that locks you in.

“We own layer 3 (skills) and layer 1 (eval). We rent the rest from Anthropic.”

autonomy gradient

The continuum from fully bounded (3-step, every output reviewed) to deeply autonomous (30+ steps, audit-only). Picking a point on this gradient is the single highest-leverage strategy choice.

Avoid: confusing it with capability. A bounded agent can be highly capable; an autonomous agent can be extremely dumb.

heterogeneous routing

Architectural pattern where small specialized models handle the routine 70–90% of agent calls (parsing, classification, summarization), and frontier LLMs are escalated to only on hard reasoning. The Belcak / NVIDIA position paper’s core recommendation.

“Our heterogeneous router cut cost-per-task 18× with 2.3% quality regression on the eval set.”

agent gateway

A control-plane component sitting between users and agents: rate limits, policy enforcement, cost controls, eval sampling, audit logging. Day 11’s safety thinking made concrete as infrastructure.

Avoid: confusing with API gateway. Agent gateways understand multi-step trajectories, not just single requests.

deep agent

Harrison Chase’s term for a ReAct-style agent enriched with explicit planning, sub-agents, file-system-as-state, and richer prompting. Not a new architecture — the same loop with sophistication around it.

“The travel-booking deep agent uses three sub-agents (search, compare, book) and persists context to a virtual filesystem.”

eval coverage

The fraction of agent-decision branches that have automated test coverage. Brockman’s “ramp responsibility with observability” framing operationalized as a percentage. Sub-50% is a yellow flag, sub-30% is red.

Avoid: equating it with prompt-level unit tests. Eval coverage measures trajectories, not single completions.

protocol-first

A strategic posture that invests in MCP, A2A, AP2, x402 (Days 03/14/15/16) as the integration substrate — trading some short-term integration speed for long-term portability across vendors.

“Every internal tool ships as both a Python SDK and an MCP server — we are protocol-first.”

human-in-the-loop checkpoint

An explicit, reviewable break-point in an agent trajectory where the system pauses for confirmation. The Pan et al. survey found 68% of production agents have ≤10 steps before such a checkpoint — not a bug, the dominant production pattern.

Avoid: assuming HITL is a transitional crutch. For most domains it is the architecture.

agent washing

Marketing pattern: re-labeling a chat product, a workflow tool, or a single-shot completion as an “agent.” The Simon Willison test (“tools in a loop toward a goal”) is the cheapest counter.

“Their pitch failed the agent-washing test — no tools, no loop. We passed.”

skill marketplace

A discovery-and-distribution layer for installable agent skills (Day 14’s OpenClaw, Anthropic Skills, GPT Custom Actions). The Layer-3 economic surface where third-party developers monetize.

“Our v2 strategy: ship our domain expertise as five OpenClaw skills, not one closed app.”

Expert Questions

Five Questions That Tell a Senior Engineer You Get It

Q1

When you say “agent,” which layers of the six-layer stack are you actually shipping — and which are you renting from your model vendor? Which layer is your moat, and which is the one most at risk of being absorbed by a frontier-model release?

Q2

The Pan et al. survey found 68% of production agents bound to ≤10 steps. What’s the longest-horizon agent trajectory you ship today, and what specifically would have to change — in eval coverage, error budget, or insurance posture — before you doubled it?

Q3

If small language models really are the future of agentic AI (per Belcak / NVIDIA), what does that imply for your model-routing architecture in 12 months? Where are you still paying frontier prices on calls that an SLM would handle at 1/30th the cost?

Q4

When does adding a second agent help you, and when does it just multiply your failure modes? In the projects where you went multi-agent, what was the threshold — domain heterogeneity, context-window pressure, evaluation isolation — that justified it?

Q5

Karpathy says we’re in the “decade of agents,” not the year of them. Which of your bets compound across that decade, and which are tied to a specific vendor product cycle that could be subsumed by a release in 2027? How do you tell those two categories apart on your roadmap?

CGO Lens

Translating the Synthesis into a botlearn.ai Strategic Bet

The strategy on one page

01

Pick the autonomy gradient explicitly. botlearn.ai’s product surface is education for kids and parents — the right pole is “reliability + bounded autonomy.” Default to 3–7 step trajectories with explicit parent-confirmable checkpoints. Save deep-agent autonomy for back-office content generation, not the parent-facing surface.

02

Own Layers 3 and 1; rent everything else. Our differentiation is the curriculum data, the assessment rubrics, and the trust posture (parents care about this more than features). That maps to Layer 3 (skills / tools) and Layer 1 (eval / safety). Buy LangGraph or the OpenAI Agents SDK at Layer 5; route between Claude, GPT-5.5, and Gemini at Layer 2.

03

Go heterogeneous-routing in Q3. The cost-per-session math from Day 12 only closes if we route 70%+ of calls to specialized SLMs (graded reading, vocab quiz, lesson summarization). Start the LLM-to-SLM conversion playbook with the three highest-volume task types this quarter.

04

Single planner first, multi-agent only when forced. Don’t ship the “classroom of agents” demo because it’s photogenic. Stay single-planner until we hit a domain that’s structurally different (e.g. parent-side billing assistant vs. kid-side tutor). Multi-agent only when an A2A handoff is the cleaner answer than a tool call.

05

Protocol-first at the edges. Every internal tool ships as an MCP server. Every payment integration goes through ACP / AP2 (Day 16). Every external partner uses A2A (Day 15). We pay a small integration tax for portability against any single platform changing pricing or shutting down a feature (cf. ChatGPT Instant Checkout in Q1).

06

Plan on Karpathy’s decade clock, not vendor demo cycles. Roadmap rolls in 18-month bets, not quarterly “agent capabilities.” Build durable assets — eval datasets, the curriculum graph, the parent-trust signals — that compound regardless of which frontier model wins this round.

The 17-day curriculum, in one sentence each

DAY 01

ReAct loop is the spine; everything else is sophistication around it.

DAY 02

Memory is four tiers, and the OS analogy is load-bearing.

DAY 03

Planning + tools = MCP-shaped problems; ReWOO and ToT add depth.

DAY 04

RAG is chunking + hybrid search + eval, not just embeddings.

DAY 05

The framework war ended; LangGraph & CrewAI are how teams ship.

DAY 06

SWE-bench, OSWorld, GAIA define what “good” means in 2026.

DAY 07

Multi-agent has narrow legitimate uses; orchestration beats committees.

DAY 08

Computer-use agents finally cracked the GUI surface.

DAY 09

Code agents are the highest-ROI agent category in 2026.

DAY 10

Long horizons require checkpoints + decomposition + recovery.

DAY 11

Prompt injection is the new SQL injection; sandboxes mandatory.

DAY 12

Cost-per-task is the metric; SLM routing is the unlock.

DAY 13

Self-improvement and meta-learning are the live research frontier.

DAY 14

OpenClaw’s skills + 9 CVEs taught us “sign your supply chain.”

DAY 15

A2A turns agents into a network; Agent Cards are the DNS.

DAY 16

Agentic commerce: $0.20 transactions break Visa-economics.

DAY 17

Five strategic axes × six reference layers = your agent strategy.

Curriculum Tracker

The Whole Run, in One View

D01 Full Agent Stack · ReAct loop, LLM + Memory + Planning + Tools

D02 Memory Architecture · RAG + 4 tiers + MemGPT

D03 Planning & Tool Use · ReWOO, ToT, MCP

D04 RAG Deep Dive · chunking, hybrid search, eval

D05 Agent Frameworks · LangGraph, AutoGen, CrewAI, LlamaIndex

D06 Benchmarks & Eval · SWE-bench, OSWorld, GAIA, AgentBench

D07 Multi-Agent Systems · orchestration, A2A basics

D08 Computer-Use Agents · GUI automation, vision-based

D09 Code Agents · SWE-agent, Devin, Codex CLI

D10 Long-Horizon Tasks · decomposition, checkpointing

D11 Agent Safety · prompt injection, sandboxing, red-team

D12 Agent Economics · cost-per-task, ROI

D13 Research Frontiers · self-improvement, meta-learning

D14 OpenClaw Deep Dive · SKILL.md, CVEs, hub-and-spoke

D15 A2A Protocols · Agent Cards, OAuth 2.0, 50+ partners

D16 Agentic Commerce · ACP, AP2, TAP, x402

D17 Synthesis · five axes × six layers · your strategy

17 days, ~2,300 minutes of reading, ~200 papers and repos surveyed. The point was never to make you an engineer. The point was to make you the operator engineers respect.