Most frustrations with AI tools come down to one of four problems: the AI didn't see the right information, it misunderstood the situation, it chose a poor next step, or it did something nobody checked. Those four problems map neatly onto a decision-making model that's decades older than modern AI: the OODA loop.

This guide explains the OODA loop, shows how it describes both how AI agents work and how you should work with them, and turns it into a practical checklist. It's the last step in the "Start here" stage of our AI learning path, right before you start building with AI.

✅Key takeaways: (1) OODA stands for Observe, Orient, Decide, Act, repeated in a loop. (2) AI agents already run this loop: read, plan, call a tool, read the result. (3) Orient is where most AI work succeeds or fails; give the model clear context, constraints, and a definition of done. (4) Observe for real: check actual outputs, diffs, and test results, not the AI's summary of them. (5) Let AI act freely only on small, reversible steps; keep humans on irreversible ones. (6) Tight loops beat big-bang requests.

What is the OODA loop?

The OODA loop was developed by John Boyd, a US Air Force fighter pilot and military strategist, who presented it in a series of briefings in the 1970s through the 1990s. His question was why some pilots, and later some organizations, consistently won in fast-changing situations. His answer was a cycle:

  1. Observe: take in information about what's happening, including the results of your own last action.
  2. Orient: make sense of it, using your experience, mental models, culture, and the new information.
  3. Decide: choose what to do next.
  4. Act: do it, which changes the situation and gives you something new to observe.

Two of Boyd's ideas matter most for AI work:

The model spread far beyond aviation, into business strategy, product development, and cybersecurity, where incident responders use it to structure detection and response. Our cybersecurity basics guide covers the defensive side.

      +-------------+          +-------------+
  +-->| 1. OBSERVE  |--------->| 2. ORIENT   |
  |   | what        |          | what it     |
  |   | happened?   |          | means       |
  |   +-------------+          +-------------+
  |                                   |
  |                                   v
  |   +-------------+          +-------------+
  +---| 4. ACT      |<---------| 3. DECIDE   |
      | small, safe |          | the next    |
      | steps       |          | step        |
      +-------------+          +-------------+

Why OODA fits AI so well

AI agents already run this loop

An AI agent is a model that works in a loop: it reads its situation, reasons about it, uses a tool (reads a file, runs a search, edits code, calls an API), looks at the result, and continues until the task is done. Researchers described an early version of this pattern as ReAct, short for reasoning and acting, where a model alternates between thinking and taking actions. Anthropic's guidance on building effective agents describes the same idea: agents get "ground truth" from their environment at each step, such as tool results or code execution, to judge their progress.

In OODA terms:

OODA phase What an AI agent does Example in a coding agent
Observe Reads inputs and tool results Reads files, error messages, test output
Orient Interprets them using its instructions and context Applies the project's conventions and the task description
Decide Plans the next step "Fix the failing import, then rerun the tests"
Act Calls a tool Edits a file, runs the test command

You run the loop around the AI

When you work with an AI assistant, you're running your own, slower OODA loop around the AI's fast one: you observe what it produced, orient (is this right? what did it miss?), decide what to ask next, and act by prompting, approving, or editing. The quality of the result depends on both loops, and on where you place yourself in the agent's loop.

How to use each phase, step by step

1. Observe: look at what actually happened

AI tools are good at describing their work. Observation means checking the work itself.

2. Orient: give the AI the right context

Orientation is where most AI work succeeds or fails. A model with weak context will confidently solve the wrong problem. Give it what a capable new colleague would need:

Orientation is also your job. Update your own mental model as you go: what the AI is good at for this task, where it keeps slipping, and what you've learned about the problem.

3. Decide: choose the next step and the guardrails

Good decisions in AI work are about scope and reversibility:

4. Act: small, safe, checkable actions

A real example: how this site uses the loop

The way we publish this site is an OODA loop, run by a human editor and AI agents. One real cycle:

Phase What happened
Observe A new guide included a five-column table. A browser check at phone width showed the page was wider than the screen.
Orient The cause wasn't one article: plain markdown tables had no styling at all, and wide tables broke small screens site-wide.
Decide Fix the root cause in the stylesheet rather than reformatting one table, and make it a protected change reviewed in a pull request.
Act Added table styling with horizontal scrolling on small screens, then rebuilt.
Observe again Re-ran the phone-width check across the new pages: no overflow. Older articles with tables were fixed too.

The same loop runs at the scale of the whole site: we observe gaps in each learning path, orient around what readers need next, decide which article to write, act by drafting and passing the build's safety checks, and observe again through human review.

A second example: using AI for a work task

Say you need a one-page summary of customer feedback for a meeting.

  1. Observe: export the feedback. Skim 20 entries yourself so you know what's actually there.
  2. Orient: tell the assistant who the summary is for, what decision it supports, the format you want, and that every theme needs two example quotes. Remove personal details before sharing data with any AI tool.
  3. Decide: ask for themes first, not the final document. Review them.
  4. Act: ask for the summary using the themes you approved.
  5. Observe: check the counts and quotes against the data. Fix what's wrong, then loop again with specific feedback.

Two short loops with checks in between beat one long prompt and a hopeful read-through.

Designing an agent with OODA

If you're building agents with the Claude API or another platform, OODA doubles as a design checklist. Our Building with the Claude API review covers the API side.

Phase Design questions
Observe What can the agent see? Are tool results structured and complete? Is untrusted content clearly marked as data? Are actions logged?
Orient What instructions, examples, and retrieved knowledge does it get? Is the definition of done explicit?
Decide When does it plan? What are its stop conditions and budgets? When must it ask a human?
Act Which tools does it have, with what permissions? Which actions require approval? Can actions be undone?
Loop How does it detect failure or lack of progress? How do humans review results and improve the setup?

The NIST AI Risk Management Framework offers a broader structure for governing AI systems, and our AI workflows for cloud security guide applies these ideas to security operations.

Common mistakes, by phase

Phase Mistake Fix
Observe Trusting the AI's summary of its own work Read the output and run the checks
Observe Letting agents follow instructions found in web pages or files Treat all observed content as data; limit permissions
Orient Vague prompts with no goal, constraints, or examples Write the context a new colleague would need
Orient Never updating standing instructions Add lessons learned to project instructions
Decide Asking for everything at once Plan first, then take small steps
Decide No stop conditions for agents Set step, time, and cost limits
Act Giving agents broad permissions "to save time" Least privilege, plus approval for irreversible actions
Act Changes with no way back Branches, pull requests, backups

The OODA checklist for any AI task

Before you start:

After every step:

Frequently asked questions

What is the OODA loop in simple terms?

A four-step cycle for making decisions in changing situations: observe what's happening, orient by making sense of it, decide what to do, and act, then observe the results and repeat.

Who created the OODA loop?

John Boyd, a US Air Force fighter pilot and military strategist, who developed it through briefings from the 1970s to the 1990s.

How does the OODA loop apply to AI agents?

Agents run a version of it: they observe inputs and tool results, interpret them with their instructions, decide on a next step, and act by calling a tool, then observe the result. Designing each phase carefully makes agents more reliable and safer.

What's the most important phase when working with AI?

Usually Orient. Clear context, constraints, examples, and a definition of done prevent most AI mistakes, and checking real outputs (Observe) catches the rest.

Check your understanding

Answer each question from memory before opening it. Recalling, not rereading, is what makes learning stick (here's why).

1 What do the four letters in OODA stand for?

Observe, Orient, Decide, Act.

2 Which phase did John Boyd consider the most important, and what does it mean for AI work?

Orient. For AI work, orientation is the context the model works from: instructions, examples, constraints, and a clear definition of done. Weak context leads to confident work on the wrong problem.

3 Why should you treat what an AI agent observes, such as web pages, files, and tool outputs, as data rather than instructions?

Because that content can contain prompt injection: text written to hijack the agent. Agents should observe it, not obey it, and actions should be limited by permissions and human approval.

4 What makes a decision a good candidate to hand to an AI agent without checking first?

It's small, reversible, and easy to verify, such as editing a file on a branch and running tests. Irreversible or outward-facing actions, like publishing, deleting, paying, or sending, need a human approval step.

5 What does it mean to keep the loop tight?

Make small changes and check the result after each one, instead of asking for one huge change and reviewing it all at the end. Short loops catch mistakes early, when they're cheap to fix.

Where to go next

You've finished the "Start here" stage of the AI learning path. Next:

Sources

← All AI & Workflows