Loop Engineering: The Anthropic Playbook

Short answer: Anthropic has never published a post called "loop engineering." But their engineering essays - Building Effective Agents, the Claude Agent SDK guide, Effective Context Engineering, and Effective Harnesses for Long-Running Agents - add up to the most battle-tested playbook for it that exists. The through-line is a single loop the Claude Agent SDK runs on every task: gather context, take action, verify work, repeat. Everything else in Anthropic's guidance is advice on how to make each step of that loop reliable. This is the playbook people are searching for when they type "loop engineering the anthropic playbook" - so here it is, mapped move by move.

Loop engineering got its name in mid-2026 when Addy Osmani, LangChain, and others converged on the same idea: stop hand-prompting agents, start designing the loops that prompt them. Anthropic never used that vocabulary. But if you read what their engineering team actually shipped and wrote, they were describing the discipline from the inside the whole time - which is why "designing systems that prompt your agents" reads like a definition of loop engineering and a summary of Anthropic's agent work at the same time.

The loop Anthropic actually ships

Start with the shape. In the Claude Agent SDK guide, Anthropic describes the loop every agent built on their harness runs:

1. Gather context - fetch only what the next step needs. Anthropic makes the point that the file system itself is a context tool: when Claude hits a large log or upload, it uses grep and tail to pull the relevant slice rather than loading the whole thing. The folder and file layout of your project is context engineering.
2. Take action - use tools to change the world. Tools are the only way an agent makes progress; a loop with no tools is just a chatbot in a while statement.
3. Verify work - check the result against the goal. In Anthropic's own web-app example, Claude performed dramatically better once it was given browser-automation tools and told to test features the way a human would - because it could then find and fix bugs that were invisible from the code alone.

Then it repeats. The whole reason this is engineering and not prompting is that you design the cycle - what gets gathered, which tools exist, how "done" is judged, and when to stop - instead of babysitting each turn. That is the same claim our pillar guide makes; Anthropic just arrived at it by building the harness that runs it.

The playbook, move by move

Read across Anthropic's essays and five principles keep recurring. Each maps cleanly onto a loop-engineering decision.

1. Do the simplest thing that works

Building Effective Agents opens by drawing a line between workflows (predefined code paths that orchestrate a model) and agents (models that dynamically direct their own process). Anthropic's advice is blunt: reach for the workflow first, and only accept the cost and unpredictability of a full agentic loop when the task genuinely needs it.

The loop-engineering move: don't build a self-directing loop when a straight pipeline would do. Most "my agent keeps going in circles" problems are really "I gave an open-ended loop a task that wanted three fixed steps." Match the loop's autonomy to the job.

2. Design the loop shape before the prompt

The Agent SDK guide's most important idea is that the loop - gather, act, verify, repeat - is the reusable object. Anthropic built Claude Code around it, then extracted the SDK so teams could "build their own agents on the same machinery instead of maintaining a homegrown loop." They are explicitly telling you the loop is the thing worth engineering, not each prompt inside it.

The loop-engineering move: decide the cycle first. What triggers a turn, what one turn is allowed to do, and what ends the run. Prompts live inside that structure; they don't replace it. This is the exact difference between prompt engineering and loop engineering laid out in our loop-vs-harness explainer.

3. The verifier is the load-bearing step

Notice which step Anthropic spends the most words on: verify work. Their finding - that giving Claude real testing tools and telling it to verify end-to-end was what unlocked reliable output - is the whole thesis of loop engineering restated in Anthropic's own data. A generator that can't check itself just produces plausible-looking work faster.

The loop-engineering move: write the verifier before you scale the generator. In any loop the generator runs cheaply, over and over, so the verifier is the bottleneck that decides whether all that motion becomes value or slop. If you want the deep version of this - how to build verifiers that catch real regressions - our guide to evaluating AI agents is the companion piece.

4. Context is a budget, not a bucket

Effective Context Engineering treats the context window as a finite resource and pushes one rule: give the model the smallest set of high-signal tokens that makes the next step likely to succeed. Dumping everything in doesn't help; it dilutes attention and raises cost.

The loop-engineering move: every iteration, curate. Retrieve the relevant slice, summarize the history, and let the file system hold what doesn't need to be in-window. A loop that re-reads its entire history each turn gets slower and dumber as it runs - the opposite of what an unattended loop needs.

5. For unattended runs, the harness carries the loop

The moment a loop runs for hours without you, a new set of problems appears - and Effective Harnesses for Long-Running Agents is Anthropic's answer to them: budgets, stopping conditions, recovery from failure, and observability so you can see what happened. This is where loop engineering meets harness engineering - the loop decides what happens, the harness decides where it safely happens.

The loop-engineering move: before you walk away, give the loop a way to stop. A retry bound, a token budget, a no-progress detector, and a clean way to resume. An open loop with no stopping condition is the single most common way an unattended agent turns a small mistake into an expensive one.

The one-page version

If you strip Anthropic's guidance down to what you'd actually pin above your desk, it's this:

Nothing here is exotic. That's the point - Anthropic's "playbook" is disciplined defaults applied consistently, not a secret technique. The teams shipping reliable agents aren't the ones with the cleverest prompts; they're the ones who designed the loop and the harness around a plain, testable goal.

Related reading

• Loop Engineering: Stop Writing Prompts, Start Writing Verifiers - the full discipline: open vs closed loops, verifier design, and the starting checklist. Start here if this is your first loop.
• Loop Engineering vs Harness Engineering - the two terms Anthropic's essays keep braiding together, pulled apart.
• How to Evaluate AI Agents - the deep version of Anthropic's "verify work" step.
• Harness Engineering: A Production Guide - what the harness has to provide once the loop runs unattended.

Build the loop, don't just read about it

Reading Anthropic's playbook tells you what good looks like. Building the loop is where it sticks. The Loop Engineering course walks you through it layer by layer - feedback gates that earn the right to walk away, a sandbox that bounds the blast radius, the Ralph loop that runs unattended, and a scheduled automation ladder - until you have a loop that wakes on schedule, pulls the top task off your backlog, and ships a PR behind quality gates while you're away. It's the practical sequel to Harness 101, and it turns the five principles above into a loop you actually run.