Loopcraft, Explained: Composing Autonomous Loops — and the Controls Enterprises Need

The frontier of working with AI agents just got a name for its next level: loopcraft — the art of designing and stacking autonomous loops, popularized by Latent Space's AINews in June 2026 ("Loopcraft: The Art of Stacking Loops") to name a convergence among practitioners whose observations the Latent Space piece collected — Peter Steinberger, Boris Cherny, and Andrej Karpathy (Latent Space, June 2026). The convergence is striking when laid side by side. Peter Steinberger's standing advice: you shouldn't be prompting coding agents anymore — you should be designing loops that prompt your agents. Anthropic's Claude Code lead Boris Cherny, in the thirteen words we quote once: "I don't prompt Claude anymore. I write loops, the loops do the work." And Andrej Karpathy, discussing autonomous research, framing the stakes as large as they go: much of the coming era's work, in the piece's framing is stacking loops effectively — arranging things to be completely autonomous, removing yourself as the bottleneck, resisting the historical instinct to fix things yourself. Read those together and the shift they describe is structural, not stylistic: the unit of work moves from the prompt (a human turn) to the loop (a designed, self-driving cycle), and then from the loop to the stack — loops that spawn, feed, verify, and improve other loops, with the human designing the architecture rather than sitting inside it. Plenty of coverage will explain why this is exciting. This guide is the reference for the part that determines whether it survives contact with an enterprise: what loopcraft is, where it came from, how it differs from the disciplines it builds on — and what a stack of autonomous loops demands from infrastructure, because every layer you remove a human from is a layer where the controls must already be standing. As with all our young-term references, we will keep this page updated as the practice and vocabulary evolve.

What Is Loopcraft? A Definition

Loopcraft is the practice of producing work by designing autonomous loops — self-driving cycles in which an agent acts, verifies its result, and retries or proceeds without a human turn — and, distinctively, by stacking them: composing loops into layered systems where higher loops create, direct, evaluate, and improve lower ones. The primitive is familiar from a year of agentic practice: give an agent a goal, a verification signal (tests, a checker, a rubric), and permission to iterate, and it will drive itself to a result. Loopcraft names what the frontier does next. One loop writes code against tests; a loop above it triages incoming issues and spawns work loops for each; a loop above that reviews the outputs, updates the specs and skills the work loops run on, and retires patterns that fail; an outermost loop watches quality and cost across everything below. The human's position changes at each level — from author of prompts, to designer of a loop, to architect of the stack — and the craft's defining discipline, in Karpathy's framing, is self-removal: arranging things to be completely autonomous, because a human inside the cycle is the throughput ceiling. A disambiguation for adjacent searches: loopcraft is not looping constructs in code (for/while), not control-loop theory from robotics, and not a product — it is a practitioner's term of art for the design skill, the way "statecraft" names the skill and not a state.

A Brief History: From Prompting to Loops to Stacks

The lineage is short and steep. 2023–2024: prompting — the human in every turn, quality bounded by the human's attention. 2025: the loop arrives as agents gain reliable verify-and-retry — the year's practitioner discourse (Cherny's operating patterns, Steinberger's build logs) converges on giving agents checkable goals and letting them iterate, and loop engineering emerges as the named discipline of building one loop well: its triggers, its verification, its budgets, its stopping conditions. Early 2026: the AI Engineer World's Fair makes loops its organizing vocabulary — an inner loop of largely autonomous agent work, an outer loop of engineers overseeing and improving it — and parallel-agent features (subagent spawning, agent teams, multi-agent research) put loop composition into everyday tooling. June 2026: the popularizing piece — Latent Space's AINews issue titles the convergence "Loopcraft: The Art of Stacking Loops," anchored on Steinberger's design-loops-not-prompts advice, Cherny's loops-do-the-work practice, and Karpathy's stack-loops-remove-yourself framing around autonomous research. Our standing historical caveat applies: the naming trails the practice — teams were stacking triage loops on work loops on review loops before anyone gave it a syllable — and the naming matters because it is the moment the practice becomes discussable, teachable, and, for our purposes here, governable. That last conversation has barely started, and it is this page's second half.

Loopcraft vs Prompting, Loop Engineering, and the Software Factory

Three boundaries place the term. Versus prompting: a prompt is a human turn; a loop is a designed cycle that runs without one — the practitioner shift is from writing instructions to writing the system that issues and checks instructions, which is why the skill ceiling moves from phrasing to architecture. Versus loop engineering: loop engineering — the discipline our loop-engineering guide covers — is the craft of one loop: making a single autonomous cycle reliable, bounded, and observable. Loopcraft is the compositional layer above it: which loops to build, how they stack, where verification lives at each level, and where the human's remaining judgment is spent. Loop engineering is to loopcraft what machine design is to production design; you cannot stack loops that aren't individually sound, and sound loops unstacked leave most of the leverage on the table. Versus the software factory: the factory — our software-factory guide covers it — is the industrial organization of this same movement: standardized inputs, agent-staffed stations, QC, evidence-backed outputs. A factory is loopcraft institutionalized; loopcraft is the craft a factory's designers practice. The three terms form a tidy ladder — engineer the loop, craft the stack, industrialize the plant — and the enterprise questions get harder at each rung, because each rung removes more humans from more cycles.

Loopcraft in the Enterprise: Governing the Stack

Here is where TrueFoundry enters, via the observation the excitement tends to skip: every layer you remove a human from is a layer where the human's judgment must already be re-implemented as infrastructure. Inside a prompt-driven workflow, the human is the budget (they stop when it's expensive), the guardrail (they notice when it's wrong), and the audit trail (they remember what happened). A loop removes that human once; a stack removes them at every level; and Karpathy's don't-fix-things-yourself discipline is only safe if the fixing — the bounding, the checking, the recording — happens structurally. The mechanics map partially, and honestly. Mediated operations run inside administrator-enforced gateway limits: budget and rate rules on matching traffic — while per-loop envelopes at each depth remain an application allocation design — so a runaway work loop's matching requests can be cut off once its allocation and stops — budget rules evaluate matching LLM traffic against configured team, user, or metadata scopes — a spawn tree drawing down a parent's envelope is an application-level allocation design, not a documented product behavior, so composed stacks need explicit per-scope rules or orchestrator-level allocation to bound total spend. The compounding arithmetic is not hypothetical — loops spawning loops is precisely the mechanism behind the CI/CD token explosion our token-explosion analysis documents. Every loop carries an identity and leaves a trace: stacked autonomy's quiet failure is accountability laundering — the action taken five layers deep under nobody's name — which is why loops execute on the Agent Harness with step-level traces that record the spawn chain: which loop created which, under whose authority, doing what. Verification is a loop too — the outermost one: the watch loop the stack needs is online evaluation scoring live output continuously plus guardrails checking every model and tool call in flight (guardrails docs) — mechanical vigilance standing in for the human who no longer reads every layer. And the stack's consequential boundaries get gates: the whole point of stacking is that most cycles run unattended, which is exactly why the few crossings that matter — merging to protected branches, touching production data, spawning beyond a depth or fleet size — are harness approval gates, the one place the architect's judgment re-enters the system it designed. This is loopcraft's enterprise form: the reliability discipline our ETCLOVG guide applies to one loop, applied recursively to a stack — and the fleet-scale operations our fleet-runtime guide covers are what the stack looks like from the operations chair.

‍