Anthropic Officially Defines Four Agent Loop Quadrants in Claude Code

Event Overview

On June 30, 2026 at 17:28 UTC, Anthropic's official blog published *Getting started with loops*, authored by Delba de Oliveira and Michael Segner of the Claude Code team.

For the first time, Anthropic formally categorized the term *agent loop*—used loosely by vendors and open-source communities for two years—into four types and provided official recommended usage for each.

The Four Loop Types

1. Turn-based loop

• Trigger: Each user prompt
• Stop condition: Claude judges completion or needs more context
• Use case: Non-periodic, non-repetitive short tasks
• Core mechanism: Read code → modify code → run tests → self-check → repeat → return result
• Optimization direction: Encode manual verification steps into SKILL.md so Claude can self-check end-to-end

2. Goal-based loop (/goal)

• Trigger: Real-time user prompt
• Stop condition: Goal achieved or maximum rounds reached
• Use case: Tasks with verifiable exit criteria
• Core mechanism: Use deterministic standards such as /goal get the homepage Lighthouse score to 90 or above, stop after 5 tries, where an evaluator model verifies completion; if unmet, the task loops back
• Key design principle: Deterministic conditions (test pass count, score threshold) are more effective than free-form judgment

3. Time-based loop (/loop + /schedule)

• Trigger: Fixed time interval
• Stop condition: User cancel or task complete (PR merged, queue cleared)
• Use case: Periodic work (e.g., daily morning Slack digest) or external system interfaces
• Core mechanism:
• /loop 5m check my PR, address review comments, and fix failing CI — local time-based loop
• /schedule — moves the loop to the cloud
• Optimization direction: Replace time-driven with event-driven triggers (only act on changes)

4. Proactive loop

• Trigger: Events or schedule, no human in the loop
• Stop condition: Each task exits on goal completion; the routine continues until the user disables it
• Use case: Long-running workflows (bug report triage, dependency upgrades, issue routing)
• Core mechanism: Combine /schedule + /goal + dynamic workflows + auto mode
• Full example: /schedule every hour: check #project-feedback for bug reports. /goal: don't stop until every report found this run is triaged, actioned, and responded to. When fixing a bug, use a workflow to explore three solutions in parallel worktrees and have a judge adversarially review them.

Additional Recommendations

• Maintain code quality — Encode 'what counts as good' in SKILL.md; use a second agent for code review (independent context, not polluted by the main agent's reasoning)
• Manage token usage — Dynamic workflows may spin up hundreds of agents; pilot small first, then scale; avoid using reasoning when scripts can do the job

Reference Links

• Official blog: https://claude.com/blog/getting-started-with-loops
• Claude Code docs: https://code.claude.com/docs/en/goal, https://code.claude.com/docs/en/routines, https://code.claude.com/docs/en/workflows

Deep Analysis

The blog's real significance is not the /goal command itself, but Anthropic's official layering of the *agent paradigm*. Over the past 18 months, the term *agent* has been used inconsistently across the industry. This post draws the first engineering classification chart, categorized along the axes of trigger method, stop condition, and user presence.

1. Choosing a loop type means choosing user intervention frequency

| Loop type | User intervention frequency | Task length | Risk | |---|---|---|---| | Turn-based | Every interaction | Short | Low | | Goal-based | At setup and termination | Medium | Medium (poor evaluator causes runaway loops) | | Time-based | At configuration | Medium-long | Medium (polling wastes tokens) | | Proactive | Almost none | Long | High (unattended, high cost of error) |

Higher tiers mean higher automation and higher invisible cost when errors occur—captured in the blog's advice: *Don't run routines more often than you need to.*

2. The real innovation of /goal: separating 'goal' from 'rounds'

Previously, users conflated goal and iteration count in a single request. /goal makes them explicit parameters:

• Goal: Lighthouse ≥ 90
• Rounds: 5
• Verification: An evaluator (independent model) checks completion

This is essentially contract-based testing applied to agent design: you sign a contract with the agent, which explores inside the contract and must stop outside it.

3. Proactive loop = the embryo of 'agent as a service'

A persistent routine that triggers on events, auto-defines goals, self-terminates on completion, and self-restarts on failure is essentially the agent version of SaaS. Anthropic's example—hourly bug report checks, triage, fix, respond—is the 'long-running AI employee' product pattern. While similar experiments appeared in late 2025 (Grok Build /goal, Google Labs proactivity papers), Claude Code's official endorsement moves this path from 'folk experiment' to 'main flow'.

4. SKILL.md re-emerges

The post again highlights SKILL.md as the 'skill definition file' that specifies what counts as done, how to verify completion, and which tools to use. SKILL.md + goal + dynamic workflows form Anthropic's 'agent engineering trio'. The broader meaning: where we once wrote prompts, we will now write SKILL + goal + routine—prompts degrade to high-level intent, execution details sink into agent-owned engineering artifacts.

Why This Matters

1. Anthropic's official four-quadrant classification of agent loops is the first time a major vendor has mapped the 'agent paradigm' into clear product tiers; others will follow. 2. /goal separates goal and rounds explicitly—this contract-based approach is a key step in agent engineering and will become industry standard. 3. Proactive loop = 'agent as a service'—long-running AI routines will be the new product shape over the next 6–12 months. 4. SKILL.md engineering turns 'what counts as good' from human memory into code files, becoming infrastructure for scaling agent teams.

Risks and Open Questions

• Proactive loop security boundaries — unattended agents running on user machines could be hijacked via prompt injection (referenced in the 06-29 cron brief on 0DIN's Claude Code repository poisoning research)
• The /goal evaluator is itself a new model — evaluator quality determines goal-based loop quality; weak evaluators cause premature stops or wasteful iteration
• Dynamic workflows spinning up hundreds of agents — token cost and context management are new problems; the blog recommends 'pilot small first' without a standard playbook
• Anthropic's own steganography incident (same-day Topic 3) makes 'I trust Claude Code to run autonomously on my machine' a delicate question

Anthropic's blog is less a tutorial than a manifesto: agent is not a 'tool' concept, it is an 'engineering paradigm' concept. Whoever builds the best agent-engineering infrastructure over the next three years will capture the next wave of value.