OODA Loop

Observe → Orient → Decide → Act: cycle faster than the environment — you set the conditions.

Origin: John Boyd and Aerial Combat

┌──────────────────────────────────────┐
│  Observe → Orient → Decide → Act    │
│      ↑                       │       │
│      └───────────────────────┘       │
│          (result of Act =            │
│           new observation)           │
└──────────────────────────────────────┘

Four Phases

ReAct Loop = OODA

The ReAct (Reason + Act) pattern used in LLM agents is isomorphic to OODA:

OODA phase   │  ReAct step          │  Concrete agent action
─────────────┼──────────────────────┼──────────────────────────────────────
Observe      │  Observe (perception)│  Reads tool-result, errors, env-state
Orient       │  Think / Reason      │  System prompt + context + memory
Decide       │  Plan next action    │  Chooses tool and arguments
Act          │  Act (tool call)     │  Calls tool → result feeds back
             │                      │  into Observe of next iteration

Context engineering (what goes into the system prompt, what into working context, what into retrieval) — this is direct tuning of the Orient phase. That is why it is the main quality lever of the agent.

Tempo: Who Is Faster and More Accurate

Loop speed is not the only metric. Boyd emphasized two conditions simultaneously:

• Faster — the cycle completes faster than the environment changes (advantage ≥ 1).
• More accurate — Orient is adequate to reality (context is current, memory is not cluttered).

🎛 Interactive: Loop Tempo vs. Environment

The environment changes with a characteristic time of T_env = 10 sec. Move the slider — see how the "loop advantage" changes.

Formula: advantage = T_env / T_loop = 10 / T_loop

OODA Antipatterns in Agents

Practice: OODA in Agent Design

Implicit vs Explicit Orient: Where the "World Model" Lives

For an agent, the Orient phase is implemented in two ways — this is a key architectural choice:

Stopping Criterion: When the Loop Must End

OODA is a cycle, but any agent cycle must have an exit condition, otherwise it spins forever (or burns budget). Here satisficing by Herbert Simon applies: the agent does not optimize to perfection, but stops at "good enough" by an explicit threshold.

• Success criterion reached — result passed the check (bridge to Check/eval from M4 and Measurable from M7).
• Budget exhausted — step / token / time limit.
• No progress — N iterations in a row without improving observations → exit and escalate.

Boundary of OODA: The Chaotic Domain

OODA assumes that observation is informative. But if there is no data yet — the environment is new and unpredictable — there is nothing to "observe." In the chaotic domain the order flips: first act to create information (act → sense → respond), rather than getting stuck in Observe. This is part of the broader Cynefin framework — "which decision mode for which situation"; the full map of domains will be covered in M8.

Check Yourself

Module 3: GTD — Getting Things Done

David Allen · "Mind Like Water" · Five steps from chaos to action · Transfer to AI agents

Why the Brain Is Bad at Storing Tasks

Five Steps of GTD

Transferring GTD to AI Agents

Antipatterns

Interactive: GTD Inbox Processing Funnel

Walk through the steps — this is how Clarify works in GTD and how an agent should reason when processing an incoming item.

GTD Contexts for the Agent: Machine Triggers

For a human, GTD contexts are @calls, @computer: where and with what you can do the action. For an agent, "context" becomes a concrete machine condition — the action is unlocked only when it is executable:

• @has_tool — the required tool is available in the current state (otherwise this is not a next-action, but a "waiting-for").
• @context_fits — the required data fits in the window (otherwise retrieval/summarization first).
• @needs_verify — the result requires verification before committing (bridge to Check from M4).
• @budget_left — token/time budget remains for this action.

Engage by context for an agent = choose from the queue an action whose triggers are all green.

WIP Limit: Capture Without a Ceiling = Infinite Inbox

GTD says "collect everything", but without limiting the number of simultaneously active tasks (work-in-progress) the agent overloads context and scatters attention — it's the same overreach disease. The Kanban remedy: a hard cap on parallel tasks (often WIP = 1 for an agent — one active task at a time), the rest waits in queue.

Check Yourself

Module 4: PDCA — Spiral of Improvement

Plan → Do → Check → Act: how an agent learns from mistakes between runs

Origin and Essence

The PDCA cycle was invented by Walter Shewhart in the 1930s, and W. Edwards Deming popularized it in post-war Japan as a tool for kaizen — continuous improvement. It is not a one-off project, but a spiral: each completed cycle starts the next one from a higher baseline.

PDCA vs OODA: Two Different Loops

Both cycles are feedback mechanisms, but they operate on different time horizons and solve different problems.

Transfer to AI Agents

Each PDCA step maps directly to agent development terms:

The "Confidently Wrong" Agent = PDCA Without Check

An agent can consistently produce confident answers that are factually wrong. If after every run there is no honest check of the result — there is no signal for Act, no correction for the next Plan. The cycle is open.

Verification gap — the gap between what the agent claims about its output and what is actually verified through eval. Closed only through Check.

Spiral of Improvement — Interactive Model

Model: error_n = error_0 · (1 − r)^n, where error_0 is the initial error rate (%), r is the share of errors eliminated per PDCA cycle (Check+Act effectiveness), n is the cycle number.

Set r = 0 — you'll see a flat line: without Check there is no improvement.

Practical Application: Cycle Checklist

1. Plan. Formulate a concrete hypothesis: "If I change [X] in the prompt, then the error rate on task [Y] will drop from [A%] to [B%]."
2. Do. Run the agent on a fixed test set with the changed prompt. Don't change several variables at once.
3. Check. Run eval. Compare numbers with the hypothesis. Don't interpret subjectively — look at the metric.
4. Act. If the hypothesis is confirmed — lock in the change (update system prompt, add a few-shot example, update CLAUDE.md / AGENTS.md). If not — roll back and formulate a new hypothesis.

Single-loop vs Double-loop: Improve the Method OR Change the Goal

Chris Argyris distinguished two levels of learning, and PDCA by default works only on the first:

For an agent this is critical: single-loop honestly optimizes a proxy metric — and runs straight into Goodhart's Law (M7). If eval measures the wrong thing, single-loop will diligently improve "the wrong thing." Double-loop is a periodic step back: "does our Check measure the real goal?"

Quiz

Module 5: First Principles

First Principles Thinking — break down to the foundation, rebuild from scratch

What Is First-Principles Reasoning

Aristotle defined a first principle as "the first basis from which a thing is known." Descartes elevated methodical doubt to a method: discard everything that can be doubted — and rebuild knowledge on what stands. The modern popularizer — Elon Musk: "think physics," not analogy.

Case: Batteries (Illustrative Argument)

This example illustrates first-principles logic in the spirit of Musk's battery argument. Numbers are illustrative; the point is to show the gap between "market analogy" and "first-principles floor."

First-Principles Cost Calculator

Enter component costs and the market price of the finished pack. The calculator will show the "first-principles floor" (sum of materials) and the gap between it and the market.

Numbers are illustrative (in the spirit of Musk's battery argument), not precise historical accounting. The point is to show the gap between "market analogy" and "first-principles floor."

Transfer to AI Agents

1. Anti-Cargo-Cult Prompting

Cargo-cult — copying "magic" formulations without understanding the mechanism. First-principles question: what fundamental mechanism makes this work?

"You are a genius world-class expert.
Others use it → we copy it."

1. What actually affects quality?
   → context, instructions, examples, eval.
2. Test A/B: with and without the phrase.
3. Keep only what is confirmed.

2. Decomposition to Atomic Verifiable Claims

Complex agent task → break down to atomic verifiable claims: statements each of which can be checked independently. This is a direct bridge to eval from Module 4: each claim becomes a test case.

Task: "Summarize news correctly"
↓ decomposition
├── Claim 1: facts from the source are preserved
├── Claim 2: no added claims
├── Claim 3: tone is neutral
└── Claim 4: length is within limits

Each claim = a separate eval test.

3. Bottom-Up Estimation: "Too Expensive / Too Many Tokens"

Before accepting "impossible" — calculate from fundamental components.

"This is too expensive in tokens" — analogy.

First principles:
1. How many tokens does each part of the prompt take?
2. Which of this carries information? Which is ballast?
3. Where is the real bottleneck: context, cost, latency?
→ We calculate, not assume.

4. Connection to SMART / OKR (Module 7)

Practice: Applying the Method

Task: [description]

1. DECOMPOSITION
   What fundamental elements is the task made of?
   → [element 1], [element 2], ...

2. ASSUMPTIONS QUESTIONED
   What is "accepted" as a constraint?
   → Assumption X: can it be verified?

3. VERIFIABLE TRUTHS
   What can be measured / derived directly?
   → Fact 1: [number / experiment result]

4. REBUILD BOTTOM-UP
   Based on p.3, what solution follows?
   → [conclusion]

Agent-Native Example: Bottom-Up Model Budget

The battery case is about the physical world. Let's transfer the method to an agent. Analogy (reasoning by example): "the task is complex → use the strongest model for everything, it's safer." First-principles question: what share of tasks actually needs the strong model? Let's calculate the cost from components and compare "everything on strong" vs routing.

Numbers are illustrative. The point: "expensive and no other way" is analogy; first-principles calculation almost always reveals a gap (here — routing cheap model for simple tasks).

Check Yourself

Theory of Constraints (TOC)

Eliyahu Goldratt, "The Goal" (1984) — any system is limited by one bottleneck, which determines the throughput of the entire chain.

1. Key Idea: A Chain Is Only as Strong as Its Weakest Link

Eliyahu Goldratt formulated a principle that changed production management: in any system there is at least one constraint (bottleneck) — the slowest link through which all work flow passes. This constraint determines throughput — the capacity of the entire system.

Classic trap: a team spends a month optimizing the fastest stage, celebrates a 2× speedup, but final throughput doesn't change at all. This is called "local optimization not at the bottleneck."

2. Five Focusing Steps

3. TOC in Agent Pipelines

An agent pipeline is the same conveyor of stages, each with its own throughput:

4. Interactive: Pipeline Throughput = min(stages)

Set the speeds of four stages (requests/min). The system will show the bottleneck and total throughput. Try: raise Retrieval from 100 to 200 — throughput won't budge (stays 20). Then raise Reasoning from 20 to 40 — throughput grows to 40, and the bottleneck moves to Verify.

🎮 Mini-game: Unclog the Pipeline on a Budget

You have 14 upgrade points. One point raises a chosen stage by +5 req/min. Goal — squeeze maximum throughput (= minimum across stages). Hint: pouring points into a stage faster than the current bottleneck is useless. The optimum is achievable — find it.

5. Connection to Other Course Tools

6. RICE / WSJF: Which of Many Tasks to Do First

TOC answers "where is the bottleneck in one conveyor." But often in front of an agent is a backlog of dozens of independent improvements, and there is no single bottleneck: tasks must be ranked. Here scoring by value works.

For an agent: Reach = how many requests/tasks the improvement affects; Impact = how much it helps each; Confidence = how certain you are (take from eval data, not feelings); Effort = cost in agent/human time. Calculate RICE for each candidate → do the one with the highest score first.

Connection of lenses: RICE/WSJF complement TOC. TOC is priority inside a flow (unclog the constraint); RICE is priority between independent backlog tasks.

7. Check Yourself

Module 7: SMART and OKR

From vague intentions to measurable goals — and how this works for AI agents

SMART: Anatomy of a Verifiable Goal

George Doran proposed the SMART acronym in 1981 as a tool for turning foggy intentions into concrete, verifiable goals. Five criteria form a checklist:

Example: Vague Goal → SMART

OKR: Objectives and Key Results

OKR (Objectives and Key Results) — a goal-setting system developed by Andy Grove at Intel in the 1970s based on Peter Drucker's MBO. John Doerr brought it to Google in 1999; since then thousands of companies use OKRs.

History and Grading 0..1

At Google every Key Result is scored on a 0.0 — 1.0 scale at the end of the period. The Google norm: ~0.7 = "good". This is not accidental:

• Stable 1.0 means goals are too easy — the system doesn't stretch the team.
• Results close to 0 signal: the goal was unachievable or misunderstood.
• The 0.6–0.8 zone — "ambitious but realistic": the team tried, achieved more than without OKR, but there is still room to grow.

Key Distinction: Outcome vs. Activity

Transfer to AI Agents

SMART and OKR are not just HR tools. For agent systems they define the verification architecture.

Interactive: Agent OKR Grader

Set the current score for each Key Result (0.0 — not achieved, 1.0 — fully). The average and verdict are recalculated automatically.

Guardrail Metrics: Antidote to Goodhart's Law

Since an agent optimizes exactly what is measured (Goodhart's Law), a single KR is dangerous: the agent will "win" it by breaking something unmeasured. The cure is guardrail metrics (counter-metrics): for every optimized metric add a protective one that must not worsen.

For agent eval this means: the test suite always includes not only "passed the task," but also "didn't hallucinate / didn't exceed budget / didn't break previous behavior." This is direct application of double-loop from M4: the guardrail catches the moment when proxy optimization started harming the real goal.

🎮 Mini-game: Break the Metric (Goodhart's Law)

The agent optimizes one metric — % of passed tests. But the real goal is real utility. Choose actions and watch how the two metrics diverge. Then enable the guardrail and try the same hacks again.

Committed vs Aspirational: Two Types of OKR

Important for a hybrid audience: an agent usually receives goals, not sets them itself. And goals come in two sorts:

Quiz

Module 8: Synthesis — Agent Operating System

Assembling all six methods into a unified working stack: two loops, three lenses, one coherent process.

Three Lenses of the Management Cycle

Each method from modules 2–7 closes its part of the cycle. Let's order them by the three questions the agent asks on every iteration.

Central Idea: Two Nested Loops

OODA spins many times inside one "Do" of the PDCA cycle. SMART/OKR sets the goal that both loops converge toward. TOC tells which stage of the loop to fix. GTD keeps external memory clean. First principles don't let the loops optimize nonsense.

End-to-End Scenario: Code-Assistant Agent

Guide Table: Symptom → Method → Place in Stack

Launching the Agent OS: Step-by-Step Algorithm

Methods are applied not "all at once," but in a specific order — from goal setting to achievement. Here is a working runbook for one task cycle:

🩺 Method Diagnostics

Pick a symptom — get a recommendation with explanation and a link to the right module.

Cynefin: Which Decision Mode for Which Situation

So far we have studied tools. Cynefin (Dave Snowden) is a meta-framework above them: it classifies the situation and suggests which type of reaction is appropriate. "Apply everything at once" is inefficient — first determine the domain.

All Methods on One Page

False Friends: One Word — Different Meanings

Methods from different schools reuse terms. Don't confuse:

• Act in OODA (execute decision in the moment) ≠ Act in PDCA (lock in or roll back process change after Check).
• Check in PDCA (measure result against expectation, learning) is broader than "Verify" of a single tool; in M7 this is Measurable/eval.
• Objective in OKR (qualitative goal) ≠ Key Result (quantitative outcome) ≠ task/activity.
• Orient (OODA) ≠ simply "context": it is context + world model + past experience.

When Methods Conflict

"Apply everything at once" is impossible — sometimes recommendations argue. Conflict is resolved by splitting across time and criticality, not by a "rule for all cases."

Check Yourself

3 Actions for Tomorrow

Done 🎉

8 modules completed. Here is what you now have in your agent management toolkit:

• See the agent as a self-managing system: goal → decision loop → prioritization.
• OODA: build a fast Observe-Orient-Decide-Act loop and understand that Orient (context/world-model) is the main lever.
• GTD: unload the agent's "working memory" into external memory; two-minute rule, contexts, regular review.
• PDCA: slow improvement loop through verification gate; learn from mistakes between runs.
• First Principles: decompose the task to verifiable axioms instead of reasoning by analogy (cargo-cult prompts).
• Theory of Constraints: find the conveyor bottleneck and don't optimize everything at once.
• SMART / OKR: turn a vague goal into a measurable specification and eval.
• Synthesis: assemble everything into an "agent operating system" — two loops (fast OODA + slow PDCA) on top of goals and priorities.

What to Read Next

• John Boyd — "Patterns of Conflict" / R. Coram "Boyd". Primary source of the OODA loop.
• David Allen — "Getting Things Done". Canonical GTD.
• W. Edwards Deming — "Out of the Crisis". Shewhart/PDCA cycle and kaizen.
• Eliyahu Goldratt — "The Goal". Theory of Constraints on a production case.
• John Doerr — "Measure What Matters". OKR from Intel/Google (Andy Grove → Google).
• Anthropic — engineering notes on agents, context, and eval. Transferring these methods to LLM agents.

▶ Retake the course