Loop Engineering: The Complete Landscape — Who's Building What in 2026

Mid-June 2026. Peter Steinberger, creator of OpenClaw, posts twelve words that break the AI-coding internet: "You shouldn't be prompting coding agents anymore. You should be designing loops that prompt your agents." Boris Cherny, head of Claude Code at Anthropic, had said the same thing on stage a few days before. Addy Osmani published an essay giving the practice a name — loop engineering — and an anatomy. It crossed 6.5 million views in under 24 hours.

Now everyone is talking about it. But what is it, who's doing it, and what's actually out there? This is the landscape — broad, not deep. The map of who's building what, what tools exist, and what approaches are emerging.

What Is Loop Engineering?

Strip the discourse and the definition is compact. For two years, working with a coding agent meant holding it: you prompt, you read, you prompt again — the human is the loop. Loop engineering replaces that with a designed system: something finds the work, hands it to an agent, checks the result with a verifier that isn't the maker, records what happened in state that outlives the conversation, and decides what's next. You build it once; it prompts the agents from then on.

As Adnan Masood, PhD, put it: "Prompt phrasing stopped being the bottleneck somewhere in early 2026, and what replaced it is loop design: the trigger, the topology, the verifier, and the stop rules that decide what an agent does next and when it quits." [Link]

Osmani places it "one floor above" harness engineering — the harness runs one agent through one task; the loop decides which tasks, when, and what counts as done. The key insight: the primitives that used to be a pile of personal bash scripts are now shipping inside the products themselves. Claude Code, Codex, Cursor, Grok — they all landed on similar building blocks. The loop shape is becoming tool-agnostic.

The Origin Story

The concept predates June 2026. Agent loops have existed since the ReAct paper in 2022 — Simon Willison was writing about designing agentic loops back in September 2025 [Link]. But what changed in mid-2026 is that the pieces stopped being custom hacks and started shipping as first-class features. That's the moment a practice stops being a workaround and starts being infrastructure.

The timeline:

• June 7, 2026 — Peter Steinberger's post about designing loops that prompt your agents [Link]
• June 2026 — Boris Cherny speaks at Acquired Unplugged: "My job is to write loops" [Link]
• June 2026 — Addy Osmani's seminal essay, 6.5M views in 24 hours [Link]
• June 2026 — Cobus Greyling publishes practical reference and CLI tools on GitHub [Link]
• June 2026 — Linas Beliūnas (390k+ newsletter) publishes the "complete guide" [Link]
• June 24, 2026 — Data Science Dojo publishes "10 Loop Engineering Design Patterns" [Link]
• June 2026 — O'Reilly Radar publishes on loop engineering [Link]

Key Voices & Thought Leaders

Addy Osmani — Coined the term. Defined the anatomy: six primitives (automations, worktrees, skills, connectors, sub-agents, memory). Key insight: the loop shape is converging across tools, so stop arguing about which tool and just design the loop.

Boris Cherny (Anthropic, head of Claude Code) — "My job is to write loops." Shifted from prompting to loop design. Spoke at Acquired Unplugged presented by WorkOS [Link].

Peter Steinberger — Creator of OpenClaw (most-starred new GitHub repo in history). His 12-primitive list maps onto both Codex and Claude Code. Sparked the conversation with twelve words [Link].

Cobus Greyling — AI evangelist. Most practical output: GitHub repo with CLI tools (loop-audit, loop-init, loop-cost), Medium articles, and the loopengineering.app tools directory curating 23+ tools [Link].

Louis Bouchard (louisbouchard.ai) — Emphasizes skills as underused: "A loop with no reusable skills just rediscovers your project from zero every run." [Link]

AI Jason — "Loop Engineer: Systemization and Artifacts" — compounding loops (support/SEO/product/Reddit), artifact/contract/log file architecture.

Andrew Ng — Four foundational patterns that informed the design pattern taxonomy.

Harkirat — YouTube video "Forget Everything You Know About Writing Code in 2026."

Adnan Masood, PhD — "The trigger, the topology, the verifier, and the stop rules that decide what an agent does next and when it quits."

The Six Primitives

Osmani's anatomy — which maps near-identically onto both the Codex app and Claude Code — gives the loop six parts:

1. Automations — Scheduled discovery + triage. Codex has an Automations tab; Claude Code has cron/scheduled tasks, /loop, /goal, hooks, and GitHub Actions.

2. Worktrees — Isolated parallel workspaces. Built-in per thread in Codex, git worktree and isolation: worktree in Claude Code.

3. Skills — Reusable project knowledge. SKILL.md files, invoked by $name or implicitly. The underused primitive — a loop without skills rediscovers your project from zero every run.

4. Plugins/Connectors — MCP servers, Linear, GitHub, Slack integrations. The bridge between agent loops and your existing toolchain.

5. Sub-agents — Maker/checker split. TOML-defined in .codex/agents/ or .claude/agents/. The agent writing code is not the same agent judging code.

6. Memory/State — STATE.md, LOOP-STATE.json, Linear boards — anything external to the context window. The model forgets everything between runs, so the memory has to be on disk. The agent forgets, the repo doesn't.

10 Design Patterns

Data Science Dojo's taxonomy organizes patterns into three tiers [Link]:

Foundational (1-4):

• ReAct Loop — Perceive → Reason → Plan → Act → Observe. Universal across all major labs (OpenAI, Anthropic, Google, Microsoft).
• Reflection Loop — Agent critiques its own output before delivering. Simplest self-correction pattern.
• Supervisor-Worker — Orchestrator delegates to specialized sub-agents (Researcher, Coder, QA). The supervisor manages the flow; it doesn't do the work itself.
• Agentic RAG — Multi-source retrieval combined with supervisor-worker.

Practitioner (5-8):

• Verification Loop — Independent checker (separate model) validates output. Maker ≠ checker. The worker does not grade its own homework.
• Parallel Execution — Multiple agents working in isolated worktrees simultaneously.
• Hill Climbing Loop — Agent iteratively improves its own harness/skills over time.
• Human-in-the-Loop — Human gate before sensitive actions or output delivery.

Production Controls (9-10):

• Circuit Breaker — Hard stop on error thresholds, token budgets, or iteration caps.
• Bounded Execution — Time, budget, and iteration limits to prevent runaway loops.

Tooling Landscape

Official (built into products):

• Claude Code: /goal, /loop, scheduled tasks, sub-agents, hooks, GitHub Actions
• Codex: Follow a goal, Automations, AGENTS.md, Skills, Subagents
• Claude Managed Agents — Anthropic's hosted long-horizon agent infrastructure

Open-source:

• cobusgreyling/loop-engineering — CLI tools (loop-audit, loop-init, loop-cost), patterns, starters [Link]
• KanakMalpani/Loop-Engineering — Interoperable stack across Claude Code, Codex, LangGraph, CrewAI, Cursor [Link]
• selmakcby/loop-engineering — Drop-in Claude Code skill with verification gate [Link]
• alchaincyf/loop-engineering-orange-book — Chinese/English plain-language guide [Link]
• GitHub spec-kit — Loop engineering extension for spec-driven development [Link]

Runtimes & Orchestrators:

• Ralphify — Experimental runtime using RALPH.md-style loop definitions [Link]
• ORCH — CLI runtime for managing Claude Code, Codex, Cursor as typed agent teams with state machines [Link]
• TrueFoundry Agent Harness — Enterprise-grade: versioned skill registry, MCP gateway, per-agent identity, durable state, API-triggered runs [Link]

Curated Directories:

• loopengineering.app — 23 tools across categories: Official Docs, Hosted Agents, Loop Runtimes, Agent Orchestrators, Review Loops, Memory Layers, Harness/Safety [Link]
• Agent-Analytics/awesome-multi-agent-orchestrators — Curated list of multi-agent orchestrators [Link]
• andyrewlee/awesome-agent-orchestrators — Agent orchestrator list [Link]

Learning & Reference:

• loopengineering.run — Crash course guide [Link]
• agentfactory.panaversity.org — AI Agent Factory course [Link]
• O'Reilly Radar — Published loop engineering article [Link]
• LangChain blog — "The Art of Loop Engineering" [Link]

Approaches & Philosophies

"Stay the Engineer" (Addy Osmani) — Build loops like you intend to remain the engineer, not just the person who presses go. Guardrails against comprehension debt. [Link]

"Earn Trust One Rung at a Time" (Lushbinary) — Don't jump to auto-merging loops. Climb incrementally, only advancing when current level produces work you'd have done by hand. [Link]

"Loops are a Runtime Problem Wearing a Workflow Costume" (TrueFoundry) — The enterprise gap isn't loop design, it's the runtime: laptop loops die with the laptop, hold credentials in cron, can't pause for approvals, and multiply into automation sprawl. [Link]

"Simplest Pattern That Works" (Tosea.ai) — A single ReAct loop with a deterministic verifier beats an elaborate multi-agent system you can't debug. [Link]

"Compounding Loops" (AI Jason) — Loops that feed each other: support loop → product loop → SEO loop → Reddit loop, with artifact/contract/log architecture.

Key Tensions & Open Questions

Token cost — Usage patterns vary wildly if you're token-rich vs token-poor. Unattended loops spend money unattended. A loop chaining five steps, each 95% reliable, completes cleanly about three-quarters of the time — and an unattended loop's mistakes compound into state, where tomorrow's run builds on them.

Maker grading its own homework — The verification gate must be independent. Separate model, separate agent. This is why the maker/checker split is load-bearing rather than decorative.

Buzzword vs real discipline — Reddit debate: the concept predates June 2026 (agent loops existed since ReAct in 2022), but the term and tooling convergence are new. Is it a valid engineering method or just the next buzzword?

Enterprise readiness — Individual developer pattern vs governed runtime. Who inventories org-wide loops? What can each touch? Who approved? The gap between a loop in your terminal and a loop an enterprise can run unattended at 3 a.m. is exactly the gap TrueFoundry's post is about.

Tool convergence — Claude Code, Codex, Cursor, Grok all landing on similar primitives → loop design becoming tool-agnostic. Once you notice the shape is the same, you stop arguing about which tool and just design a loop that works no matter which one you're sitting in.

Self-improvement loops — Recursive self-improvement (Karpathy's autoresearch, kayba-ai/recursive-improve) — agents that improve themselves overnight, with evals keeping or reverting changes. The frontier and the riskiest.

Where the Field Is Heading

Primitives shipping inside products — Loops becoming first-class, not custom bash. The orchestration, the checker, and the schedule are built-in now where a year ago they were your own shell scripts.

Convergence across tools — Loop design becoming tool-agnostic. The same shape works in Grok, Claude Code, Codex, and OpenClaw.

Enterprise runtimes emerging — TrueFoundry, Anthropic Managed Agents. Skills in versioned registries, connectors behind MCP gateways, sub-agents with their own identity and scope, durable state, and API-triggered runs.

Design pattern standardization — 10 patterns becoming the shared vocabulary. From ReAct to circuit breakers, the taxonomy is crystallizing.

Self-improving/recursive loops — The frontier. Agents that alter their own code (though not the underlying LLM), get better at doing so, and can even alter their meta-mechanisms for improving themselves. IEEE Spectrum reports that frontier labs are beginning to automate large fractions of their research operations, and within a year or two their intelligent agent workforces could grow from thousands to hundreds of thousands of agents [Link].

Conclusion

Loop engineering is the practice of replacing yourself as the person who prompts the agent. You design the system that does it instead. The field is young — the term is months old, the tooling is converging, and the enterprise story is still being written. But the direction is clear: the human is getting out of the loop, and that's exactly the point.

The question is no longer whether loops will replace turn-by-turn prompting. The question is what kind of loops you'll design, what guards you'll put in place, and whether you'll be the engineer who stays in control or the person whose automation sprawl becomes the subject of three uncomfortable meetings.

Build the loop. But build it like someone who intends to stay the engineer.