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.

Enterprise Loopcraft Checklist

Six questions before stacking higher: Does every loop run inside an enforced budget and rate limit it cannot remove, with allocations inheriting from parent to spawned child? Does every loop carry a distinct identity, so five-layers-deep actions still resolve to an accountable principal? Is the spawn chain traced — every loop's creator, authority, and steps reconstructable from the harness record? Is there an outermost watch loop — online evals and guardrail metrics — that no work loop can switch off? Are approval gates placed at the stack's consequential crossings, and only there, so the gates survive the throughput? And is there a depth-and-fleet ceiling — a structural answer to "what stops the stack from stacking itself"? Six yeses is enterprise loopcraft; the noes are the distance between an architecture and an incident report.

The Future of Loopcraft: What We'll Be Watching

Predictions, lightly held. Expect the practice to formalize the way its parent did: loop engineering went from build logs to a named discipline with patterns in under a year, and loopcraft's patterns — triage stacks, improvement loops that edit specs and skills, watch loops as standing infrastructure — are already visible in the parallel-agent tooling every major harness now ships. Expect the governance conversation to arrive on its usual lag, and to arrive hard, because stacked autonomy concentrates exactly the risks boards are being briefed on: unattended spend, unattended tool reach, and accountability that thins with depth — at which point budget inheritance, spawn-chain traces, and depth ceilings stop being this page's framing and start being procurement language. And expect the deepest question of the coming year to be Karpathy's, inverted: he says the game is stacking loops effectively and removing yourself as the bottleneck; the enterprise's version is deciding which self to remove — the human as throughput bottleneck can go, but the human as accountability anchor cannot, and the entire art of enterprise loopcraft is building the stack so that removing the first never quietly removes the second. We will keep this guide updated as the craft matures; the claim that won't need revision is the one every layer of the stack repeats: autonomy compounds, and so must the controls.

Loopcraft FAQ

What is loopcraft in AI?

Loopcraft is the practice of producing work by designing autonomous loops — self-driving agent cycles with built-in verification and retry — and stacking them: composing loops that spawn, direct, evaluate, and improve other loops, with the human designing the architecture rather than prompting inside it. The term was popularized by Latent Space in June 2026, naming converging practice from Peter Steinberger, Boris Cherny, and Andrej Karpathy.

How is loopcraft different from loop engineering?

Loop engineering is the discipline of building one autonomous loop well — its triggers, verification, budgets, and stopping conditions. Loopcraft is the compositional layer above: which loops to build, how they stack, where verification lives at each level, and where remaining human judgment is spent. You need loop engineering to practice loopcraft; loopcraft is why loop engineering compounds.

What are the risks of stacking autonomous loops?

The failure modes are stack-shaped: runaway recursion (loops spawning loops), combinatorial cost multiplication, accountability thinning with depth, and drift compounding through layers no human reads. Bounding them requires configured gateway limits on matching traffic, sensitive-tool approvals, root-and-subagent traces — and application-level designs for budget allocation, per-loop identity, supervisory processes, and depth ceilings.

What infrastructure does enterprise loopcraft require?

A governed plane every loop runs on: per-loop budgets and rate limits with parent-to-child inheritance, distinct identities per loop, harness execution with step-level traces recording the spawn chain, guardrails on every model and tool call, traces and connected evaluators as evidence for a separately designed supervisory process — the orchestrator or application decides when to stop, retry, escalate, or modify lower-level loops, and human approval gates at the stack's consequential boundaries.

References

• The term and its sources — Latent Space / AINews, "Loopcraft: The Art of Stacking Loops" (June 2026: the naming; the Steinberger, Cherny, and Karpathy positions on designing loops, loops doing the work, stacking loops, and removing oneself as the bottleneck — the one direct quotation and all paraphrases are from this issue's recap of their public statements).
• TrueFoundry documentation — Agent Harness (step traces; approval gates; official diagram); budgets (official image); guardrails.
• This blog — loop engineering at enterprise grade; operating loops at fleet scale; ETCLOVG: the reliability discipline; the agentic token explosion in CI/CD; the software factory, explained; online evaluation at the gateway.

One direct quotation under fifteen words is used, attributed inline to Boris Cherny as recapped in the cited Latent Space issue; the Steinberger and Karpathy positions are paraphrased from the same recap of their public statements. The stack-governance framing — budget inheritance, spawn-chain traces, depth ceilings — is TrueFoundry editorial onto capabilities paraphrased from public documentation current at the time of writing; the product images are TrueFoundry's own documentation assets, reproduced with attribution. Latent Space, Peter Steinberger, Boris Cherny, Andrej Karpathy, and Anthropic do not evaluate or endorse TrueFoundry. This is a living reference and will be revised as the practice and vocabulary evolve.

‍