The Loop Is the New Prompt

The hand-cranked way

Every major lab has quietly rebuilt itself around the same idea: a loop that keeps working after you stop typing. This is the field guide to how loops actually work as of July 25, 2026, across Claude, GPT, Gemini, Grok, Meta's Muse Spark, Mira, and the open-weight wave, with every claim sourced.

Watch someone use AI at work and you will usually see the same ritual. Type a request. Wait. Read the answer. Spot the problems. Explain the problems. Wait again. Paste the result somewhere else. Come back tomorrow and do it all over, from zero.

Here is the uncomfortable part: that ritual IS a loop. Ask, check, correct, repeat. The only difference between that and what the labs now ship is who turns the crank. When you do it by hand, you are the trigger, the memory, the verifier, and the stop condition, and you are expensive.

Over the past year, every serious AI lab converged on the same fix: move the crank inside the machine. Anthropic publishes an official taxonomy of loops for Claude. OpenAI rebuilt ChatGPT around a work mode that runs multi-step jobs on its own. Google sells research loops you rent by the task. Meta trained its Muse Spark model specifically to orchestrate fleets of sub-agents. Even the smallest player in this story, a two-person startup with a Telegram bot called Mira, is really selling loops to people who will never open a terminal.

And the ground is still moving as I write this. In the seven days before this update alone: Anthropic shipped a new Opus built for everyday agentic work, Alibaba previewed a 2.4-trillion-parameter Qwen, and the largest open-weight model ever released is about 48 hours from publishing its weights.

The result is the biggest quiet shift in how this technology gets used since chat interfaces appeared: the unit of work is no longer the prompt. It is the loop, a cycle of work that keeps going until a condition you defined is met.

This piece is the long version of that story. What a loop actually is, stripped of hype. What each lab's loop stack looks like right now, including the models that did not exist a month ago. What actually works, which turns out to be strikingly consistent across every vendor. And the failure modes and costs the launch posts do not mention.

A note on method, because the AI discourse is drowning in confident nonsense: everything below is grounded in the labs' own documentation and announcements, or in named independent evaluations, checked live in the week ending July 25, 2026. Where a number is self-reported by a vendor, I say so. Where something is unverified or still a preview, I say that too. Full source list at the bottom.

Part 1: What a loop actually is

Strip the jargon and a loop is four beats plus a reason to stop.

Anthropic's Claude Code team, which published the closest thing this field has to a canonical definition, puts it in one line: loops are "agents repeating cycles of work until a stop condition is met". OpenAI's own agent guide says the same thing in engineer-speak: "Every orchestration approach needs the concept of a 'run', typically implemented as a loop that lets agents operate until an exit condition is reached", where exit conditions include a final output, an error, or a maximum number of turns.

The four beats, in plain language:

1. Trigger. Something starts the run. You, a schedule, an alert, a new pull request, an email arriving.
2. Work. The model gathers context and takes an action with tools: reads the files, runs the query, drafts the message, edits the code.
3. Check. The result gets verified against something real. Tests pass or fail. The number matches the source. A second model grades the draft against your criteria.
4. Repeat or stop. If the check fails, the loop goes around again with what it learned. If the check passes, or a cap is hit, it stops.

That is the whole trick. A prompt is one pass through beats two and three, with you doing beat three in your head. A loop is the same thing with the checking and repeating handed to the machine, plus two safety rails: a stop condition so it cannot run forever, and a budget so it cannot spend forever.

The supporting cast

Around those four beats, every serious loop stack ships the same five supporting pieces, whatever the vendor calls them:

• Memory. Notes that survive between runs, so run forty knows what run one learned.
• State. Where the loop currently is: what is done, what failed, what is next.
• Verifier. The thing that decides "good enough." The single most important design choice you will make.
• Stop condition. "Tests pass," "queue is empty," "stop after five tries," "it is 9am and the digest shipped."
• Cost meter. Tokens and dollars per cycle, because loops multiply whatever they touch, including your bill.

The four kinds of loop

Anthropic's taxonomy is worth learning because it maps cleanly onto every other vendor's products, even though the names differ. Their team sorts loops by what you hand off:

• Turn-based loops. You prompt, the agent does one cycle (gather, act, check, respond), you review, you prompt again. You are still the stop condition. This is where everyone starts, and Anthropic notes every prompt already runs this micro-loop internally.
• Goal-based loops. You hand off the stop condition. You define what done looks like, and the agent iterates until it gets there or hits a turn cap. In Claude Code this is literally a /goal command, and each time the model tries to stop, "an evaluator model checks your condition and sends it back to work until the goal is met". Deterministic criteria work best: tests passed, score cleared, checklist done.
• Time-based loops. You hand off the trigger. The loop runs on an interval or a schedule and reacts to what changed: summarize Slack every morning, check the pull request until CI passes.
• Proactive loops. You hand off the prompt itself. An event or schedule starts the run with no human in real time: new bug reports get triaged as they arrive, dependencies get upgraded weekly, and each task exits when its own goal is met.

Hold that ladder in your head (hand off the check, then the stop condition, then the trigger, then the prompt) and the rest of this article is just watching seven vendors climb it from different directions.

Part 2: The state of play, in one snapshot

Before the lab-by-lab tour, orientation, because the frontier moved absurdly fast in the five weeks before this article: Grok 4.5 shipped July 8, Meta's Muse Spark 1.1 and OpenAI's GPT-5.6 both shipped July 9, Thinking Machines released its first model July 15, Moonshot's Kimi K3 landed July 16, Alibaba previewed Qwen3.8-Max on July 19, and Anthropic released Claude Opus 5 on July 24, the day before this update.

For a neutral yardstick, the independent evaluator Artificial Analysis scores general capability on its Intelligence Index. As of this week's snapshot (v4.1), the published top of the table reads:

• Claude Fable 5 (Anthropic): 59.9
• GPT-5.6 Sol Max (OpenAI): 58.9
• Kimi K3 (Moonshot, open weights imminent): 57.1, fourth overall
• With Claude Opus 4.8, Grok 4.5, Muse Spark 1.1, GLM-5.2, and the rest of the field below

Two caveats worth their space. Claude Opus 5 is a day old at this writing and not yet indexed. And a single composite index cannot capture long-horizon agentic work, which is the thing loops actually do, so where a lab has published agent-specific results I cite them in that lab's section, flagged as self-reported when they are.

Two things to notice all the same. The top of the table is now a spread of less than three points, which is to say: for loop-building purposes, model choice inside that band matters less than the loop around it. And an open-weight model now sits inside that band for the first time.

Claude: the loop as a first-class primitive

The models. Claude Fable 5, released June 9, 2026, is Anthropic's most capable model and the one most explicitly built for this style of work. Anthropic's own framing is that, run inside a harness like Claude Code, it can "work for days at a time: planning across stages, delegating to sub-agents, and checking its own work". Its thinking is adaptive and always on, tuned by an effort setting, with a one-million-token context window. It still tops the independent index above. Its sibling Mythos 5, released alongside it, is the specialist Anthropic rates strongest on cybersecurity tasks.

The news this week is Claude Opus 5, released July 24: Anthropic describes it as coming close to Fable 5's frontier intelligence at half the price ($5 per million input tokens and $25 out), the new state of the art on knowledge-work evaluations like GDPval-AA per the announcement, and the new default model on Claude's Max plan. For loop builders the pitch is blunt: near-frontier cycles at half the cost changes what you can afford to run all day.

The loop stack. What makes Anthropic distinctive is that loops are not a feature buried in an app. They are named primitives you can type:

• /goal defines done and lets an evaluator model bounce the agent back to work until the condition is met or a turn cap hits. This is the goal-based loop, literally productized.
• /loop re-runs a prompt on an interval on your machine; /schedule moves that loop to Anthropic's cloud as a routine, where it keeps running with your laptop closed, triggered by schedules, API calls, or GitHub events.
• Dynamic workflows handle the extreme end: Claude writes an actual orchestration script that can coordinate up to 1,000 sub-agents in a single run. The flagship anecdote is a developer porting the Bun runtime, roughly 750,000 lines, from Zig to Rust in about eleven days with hundreds of parallel agents.
• Skills, hooks, and sub-agents fill in the supporting cast: skills encode how to verify work, a fresh-context second agent does code review, and memory persists in files between sessions.

The philosophy. Anthropic's guidance is unusually explicit about restraint: not every task needs a complex loop, start with the simplest primitive, set deterministic stop criteria, pilot a small slice before a big run, and watch usage with built-in commands. Their line that the whole field keeps rediscovering: agents that can check and improve their own output are fundamentally more reliable.

Read it as: the developer's loop lab. The most legible, most composable version of every loop type, and now with a cheaper near-frontier engine to run inside it.

OpenAI: three modes and a separate approver

The models. OpenAI's GPT-5.6 generation went GA on July 9, 2026 in three tiers: Sol (flagship, $5 in / $30 out per million tokens), Terra (the balanced middle), and Luna (fast and cheap), all with a roughly one-million-token context window. Sol sits second on the independent index, essentially tied with Fable 5. Its headline loop feature is an ultra mode that coordinates four agents in parallel by default on hard problems.

The consumer loop stack. OpenAI's story here is a rebuild. The standalone "ChatGPT agent" of 2025 was discontinued; in its place, ChatGPT now has three modes: Chat for conversation, Work for long multi-step tasks that produce finished deliverables, and Codex for software. Work runs jobs in the cloud, can pause at approval checkpoints, and crucially can run on triggers: Scheduled Tasks now include monitoring tasks that check something on an interval and only notify you when there is something to report. That is a time-based loop sold to consumers, no code involved. An agent mode also lives inside the Atlas browser for act-on-the-web tasks.

The developer loop stack. The dividing line is stated plainly in OpenAI's docs: "Use the Responses API when you want to own the loop. Use the Agents SDK when you want the SDK to run it." The Responses API is agentic by default, letting the model call web search, file search, computer use, code execution, and your functions within one request. Two GPT-5.6-era additions matter for loops specifically: Programmatic Tool Calling, where the model writes a small JavaScript program in a sandbox to coordinate its own tool calls, and a multi-agent beta where a root agent spawns and manages a tree of sub-agents.

The distinctive idea: separate the doer from the approver. OpenAI's most interesting loop contribution is Auto-review(April 30, 2026): when a Codex agent wants to do something outside its sandbox, a separate reviewer model, not the agent itself, decides whether the action is consistent with what the user asked. Their reasoning is blunt: the main agent is optimized to finish the task, which creates pressure to treat an approval boundary as just another obstacle. Keeping the approval decision in a different model call makes it auditable. Result, per OpenAI: sessions stop to ask a human roughly 200 times less often, and the reviewer approves about 99 percent of what still gets escalated. Those numbers are self-reported, but the design principle travels: never let the model that wants to finish also be the model that decides it is finished.

Read it as: the consumer's loop on ramp, plus a serious developer stack. And a memento mori for platform builders: OpenAI deprecated its visual Agent Builder within a year of launching it, with a hard shutdown of November 30, 2026.

Google: research loops you rent by the task

The model. Google's current flagship is Gemini 3.1 Pro (April 2026), but the interesting part for this story is not the chat model. It is that Google turned a whole loop into a product.

The loop stack. The Deep Research agents, launched April 21, 2026 in two flavors (standard, for speed, and Max, for exhaustiveness), are goal-based research loops you call with one API request. The docs describe the cycle outright: plan, search, read, iterate, output, running for minutes to an hour in the background, with citations in the final report. The design details are a small masterclass in loop engineering:

• Background execution is mandatory.A research loop outlives an HTTP timeout, so you poll for the result. The loop, not the request, is the unit of work.
• Collaborative planning is a human gate at the front: the agent proposes its research plan, you edit or approve it, then it runs. Steering before the loop instead of babysitting during it.
• A hard stop condition is built in:maximum research time of 60 minutes, most tasks finishing in about 20.
• Tools are scoped per run: Google Search, URL reading, code execution by default, your own MCP servers and file stores optionally, and you can turn the open web off entirely to research only your private data.
• Cost is priced per loop, honestly.Google's own estimates: a typical standard task burns around 80 searches and roughly a quarter-million input tokens, landing at one to three dollars; a Max run can hit 160 searches and about $3 to $7. A loop is not a chat message, and Google bills like it.

Read it as: the clearest commercial proof that the loop, not the model call, is becoming the product. You do not buy tokens; you buy a finished investigation.

One honest caveat: as of this writing the Deep Research agents are in preview via the Interactions API, so expect the interface to shift.

Muse Spark 1.1: the newcomer trained to orchestrate

The model. Muse Spark 1.1 is Meta Superintelligence Labs' multimodal reasoning model, released July 9, 2026 as an upgrade to April's Muse Spark 1.0, and it is one of the most consequential newcomers in this roundup for three reasons.

First, the strategy: it is Meta's first ever paid model API, at $1.25 per million input tokens and $4.25 out, and it is closed-weight, a clean break from the open Llama era. The Llama line's champions are effectively ceded to the open-weight wave covered below; Meta has said only that it hopes to open future Muse versions.

Second, the training target. Where most models learn agentic behavior as a byproduct, Meta says this one was trained for the org chart directly: "As the main agent, it can gather context, make a plan, and delegate execution across parallel subagents. As a subagent, it adheres to its job, understands available tools, and knows when to escalate back to the main agent." It zero-shot picks up new tools, MCP servers, and custom skills, actively manages its one-million-token context (remembering, retrieving, and compacting as it works), and handles computer-use workflows across multiple applications.

Third, the price-performance position. On the independent index it jumped eight points from version 1.0 in three months, which puts it below the frontier trio but at a fraction of their cost per task, and it currently leads the MCP Atlas tool-use benchmark at 88.1 (vendor-adjacent numbers; treat with the usual salt).

The loop-builder's footnote that tells you where this is all going. Meta's own developer docs warn that if you build a multi-turn agent on the old Chat Completions style API, the model's reasoning is thrown away between turns, so loops drift and repeat work; they steer you to a Responses-style API that carries encrypted reasoning across turns. The industry's plumbing is being rebuilt around loops, one deprecated API at a time.

Read it as: the engine you rent for orchestration-heavy loops when the frontier trio is overkill on cost. Still young; the 1.0 to 1.1 slope is the reason to pay attention.

Grok 4.5: cheap, fast cycles, trained on the job

The model. Grok 4.5 shipped July 8, 2026 from Musk's xAI (now operating under the publicly listed SpaceXAI umbrella), pitched as its smartest model for coding, agentic tasks, and knowledge work. Musk's own positioning was unusually direct: an Opus-class model, roughly comparable to Claude Opus 4.7, but faster and cheaper. Independent scoring is consistent with the vibe: above the previous Opus generation, under the frontier trio.

Why it matters for loops specifically. Two claims, both from xAI and both loop-relevant even after discounting for marketing:

• It was trained in loops. xAI says reinforcement learning covered hundreds of thousands of multi-step engineering tasks with automated grading, on infrastructure where agentic rollouts run for hours while training continues. Whatever the benchmarks say, the training diet was the job itself.
• Loop economics are the pitch. At $2 in / $6 out per million tokens, roughly 80 tokens per second, and a claimed two-times token efficiency (solving tasks in under half the steps of comparable models), the argument is not "smartest cycle," it is "most cycles per dollar." For loops, where cost equals cost-per-cycle times cycles, that arithmetic is the whole game. The docs reinforce it with unglamorous loop plumbing: conversation-pinned prompt caching so long loops do not pay cold-cache prices, and context compaction guidance for tool-heavy runs.

The productized loop lives in Grok Build, its coding agent (trained alongside Cursor, where it is available on all plans), which extends into oddly practical territory: multi-sheet Excel models with web research, native PowerPoint diagrams, Word documents.

Read it as: the budget workhorse for high-volume loops, with the usual caveat that most of the efficiency numbers are the vendor's own.

Mira: loops for people who will never open a terminal

Here is the entry that looks like a mistake in a list of frontier models, and is actually one of the most instructive.

What Mira actually is. Mira is not a model. It is a consumer AI agent that lives entirely inside Telegram, built by a startup so small it rounds to two people, led by Daria Yakovleva and incubated out of The Open Platform, a Telegram-ecosystem software company. It launched quietly in February 2026 and reported crossing one million monthly users by early June (self-reported, roughly 1.17 million). Under the hood it is model-agnostic: it routes each task to third-party models (GPT, Claude, and others) rather than running its own.

Why it belongs in this article. Because Mira's product is loops, and nothing but loops, sold to people who will never hear the word. Its packaged automations, called Skills, each bundle the exact anatomy from Part 1: a trigger (a schedule, a voice note, a group-chat event), an action across connected apps (calendar, email, project trackers, content tools), and autonomous delivery back into the chat. Watch a flight price and alert me. Turn my voice memo into posts for three platforms. Summarize what this group decided today and file the action items. The positioning line in its own materials is the cleanest summary of the entire loop era: ChatGPT answers, Mira acts.

The honest caveats. The user counts and connector counts (which its materials variously put between 200 and 1,000-plus services) are self-reported and inconsistent across pages, the company publishes no engineering guidance on how its loops verify anything, and calling Skills "loops" is an outside interpretation, not Mira's own vocabulary. A tiny team wrapping other labs' models is also a fragile foundation compared to everything else in this list.

Read it as: the demand signal. When a two-person Telegram bot hits a million users by packaging triggers, actions, and autonomous delivery for regular people, the loop has stopped being a developer concept. Distribution and zero setup beat capability for an enormous slice of real work.

The open-weight wave: bring your own loop

The loudest story of mid-2026 is that the open-weight world stopped trailing by years and started trailing by months, and in the last two weeks, by points. For loop-builders that changes the calculus entirely, because an open model is the only loop engine nobody can deprecate out from under you.

The brief tour, dates and licenses verified:

• Kimi K3 from Moonshot is now the headline. Launched July 16, 2026 at 2.8 trillion parameters, it became the first open-track model to crack the independent index's frontier band: 57.1 on Artificial Analysis (v4.1), fourth overall, behind only Fable 5 and GPT-5.6 Sol Max among published scores. It also took first place on Arena.ai's blind-voted Frontend Code Arena, ahead of Fable 5. The full weights are scheduled to publish on HuggingFace on July 27, 2026 under a modified MIT license, which would make it the first downloadable model in its class; as of July 24 the weights had not yet shipped, so hold that claim as scheduled rather than done. Moonshot's flagship demo is pure loop theater: 48 hours of continuous autonomous operation designing a small functional chip, run as a single agent on a one-million-token context. One more number that matters, from the same independent evaluation: K3's measured hallucination rate rose to roughly 51 percent on fact-sensitive tasks, up from 39 for its predecessor, even as factual accuracy improved. Better at right answers, worse at knowing when it is wrong. Remember that for Part 3.
• Qwen3.8-Max from Alibaba, previewed July 19, 2026 during the World AI Conference: a claimed 2.4-trillion-parameter multimodal model, the Qwen team's first above a trillion parameters, with the self-description "second only to Fable 5" and a promise that open weights are coming soon. The preview is live; the benchmark table, model card, license, and weights are not, so file every claim as vendor-preview until they land.
• DeepSeek V4 (April 24, 2026, MIT license) was, in OpenRouter's phrase, the first open model teams dropped into real agentic pipelines as a plausible frontier substitute. The Pro variant tops open-weight coding-agent charts on SWE-bench Verified at 80.6 percent; the Flash variant keeps nearly all of that at prices that round to cents.
• GLM-5.2 from Z.ai (mid-June 2026, MIT, 753B mixture-of-experts) was the open-weight quality leader until K3 arrived, described by OpenRouter as the closest open drop-in for Opus-style planning and long-horizon coding. Known vice: it thinks expensively, burning output tokens.
• MiniMax M3 (June 1, 2026, modified MIT) is the open multimodal lane: native image and video understanding over a million-token context, which matters the moment your loop needs to read screenshots or inspect UI states.
• NVIDIA Nemotron 3 Ultra is the strongest US-built open-weight entrant, differentiated on deployment and the NVIDIA stack rather than peak score.
• Also on the board: Thinking Machines Lab, Mira Murati's outfit, shipped its first model, Inkling, on July 15, 2026: a 975B-parameter open-weight multimodal mixture-of-experts under Apache 2.0. One more first-tier lab betting that open weights are the wedge.

Read it as: if your loop is high-volume, privacy-sensitive, or needs to outlive vendor roadmaps, the open wave is no longer the compromise option. The gap to the closed frontier is now measured in single points, and it has not been widening.

Part 3: What actually works

Here is the striking thing after weeks in seven vendors' documentation: strip the branding and they are all giving the same advice. When bitter rivals converge on identical guidance, that is as close to ground truth as this field gets. Seven rules, each triangulated across labs.

1. Define done before you start.Anthropic's /goal exists so an evaluator can check an explicit condition; OpenAI's guide demands exit conditions on every run; Google caps research at 60 minutes flat. A loop without a crisp stop condition is not automation, it is a subscription to burning tokens. Deterministic beats vibes: tests pass, number matches, checklist cleared, N tries max.

2. The verifier is the product. The loop's quality ceiling is its check step, not its model. Anthropic tells you to encode verification as skills and to point a second, fresh-context agent at reviews. OpenAI went further and made the approver a structurally separate model from the doer, for the stated reason that the doer wants to finish. Google grounds reports in citations you can click. And this week handed the rule its best evidence yet: the most impressive open model on the board got measurably better at producing right answers while getting worse at knowing when it is wrong. In a chat that is a footnote. In an unverified loop it is a factory for confident errors. If you invest an hour anywhere, invest it in what "checked" means for your task.

3. Never let the doer grade itself on anything that matters. The same principle from the other side, because it is the one lesson the whole industry paid to learn: a task-completing model treats every gate as an obstacle. Separate verifier model, separate reviewer agent, or a human at the irreversible step.

4. Manage context like the scarce resource it is. Anthropic's context engineering guidance (smallest set of high-signal tokens, notes files, sub-agents that return summaries), Meta's active compaction, Grok's compaction guidance, Kimi's giant-context counterargument: everyone is answering the same question, which is how a long loop stays coherent. The consensus answer is memory outside the window plus retrieval on demand, not stuffing.

5. Escalate the loop type only when the previous rung fails. Anthropic says start with the simplest primitive. OpenAI says maximize a single agent before going multi-agent. Google makes you approve a plan before an hour-long run. The ladder from Part 1 is also a discipline: hand off the check, then the stop condition, then the trigger, then the prompt, in that order, one rung at a time.

6. Price the loop, not the message. A loop's cost is cost-per-cycle times cycles, which is why Google prices research per task ($1 to $7), why Grok leads with token efficiency, why Anthropic just cut the price of near-frontier cycles in half with Opus 5, and why every serious stack ships usage-inspection tools. Decide what a run is allowed to cost before you start it.

7. Keep a human at the gates that cannot be undone. Money leaving, emails sending, data deleting, code merging to production. Work mode's approval checkpoints, collaborative planning, permission modes, Auto-review's escalations: every vendor, without exception, kept a human gate at the irreversible step. The vendors with the most capable loops are also the ones most insistent about this. That should tell you something.

Part 4: What nobody tells you

The launch posts stop here. The operating experience does not.

Loops multiply everything, including mistakes. One wrong assumption in a chat is a bad answer. The same wrong assumption in a loop is fifty consistent, confident, wrong artifacts by morning. This is why verification is rule one, and why unattended loops should start read-only until they earn write access.

The bill compounds quietly. Every vendor's guidance has a token-management section for a reason. Thinking-heavy models can burn dollars in output tokens on a single hard step; a routine that runs hourly when the underlying thing changes daily is paying 24x for nothing. Match the interval to the rate of change, cap turns, and check the meter.

Prompt injection gets worse in a loop.The moment your loop reads the open web, inboxes, or user uploads, assume someone will eventually plant instructions in that content. A chat assistant that gets tricked embarrasses you once; a tricked loop with tool access acts on it, repeatedly, while you sleep. OpenAI's own safety docs say the quiet part: even with mitigations, agents will not be perfect and can still be tricked. Treat everything the loop ingests as data, never as orders, and scope its permissions like you mean it.

The demo-to-production gap is real. A 48-hour autonomous chip design is a magnificent demo and also a controlled one. Self-reported efficiency multiples, private benchmarks, vendor-preview parameter counts announced without model cards: useful signals, none of them a substitute for running the loop on your own tasks with your own verifier. Every lab quietly agrees, which is why they all tell you to build evals.

Platforms churn under your feet. In the twelve months before this article: OpenAI discontinued its standalone agent product, retired Pulse, and scheduled its visual Agent Builder for shutdown (November 30, 2026); a new Opus reshuffled Claude's plan lineup overnight; APIs got rebuilt around loop-friendly designs; and a June export-control directive even knocked frontier Claude models briefly offline for many users. Build your loops so the logic (the goal, the verifier, the notes) lives in your files, not in a vendor's UI, and the engine stays swappable.

The moat is not the model. The frontier is now a sub-three-point spread that reshuffles weekly, and an open model just joined it. What compounds is yours: the eval set built from your failures, the verifier that encodes your standards, the notes your loops have accumulated. Switching models is a config change. Rebuilding a year of verification logic is not.

Which loop stack is yours?

The honest matchmaking, given everything above:

• You live in a terminal and want maximum control: Claude Code, with Fable 5 for the hardest runs and Opus 5 as the new value default. The most legible primitives (/goal, /schedule, dynamic workflows) and the best-documented philosophy.
• You want loops inside a product everyone already uses: ChatGPT's Work mode plus Scheduled Tasks (monitoring tasks are criminally underused), or Codex with Auto-review for code.
• Your loop is "investigate X thoroughly and give me a cited report": rent Google's Deep Research or Deep Research Max per task and skip building anything.
• You are orchestrating many sub-agents and watching costs: Muse Spark 1.1 or Grok 4.5 as the engine; both are priced and built for exactly this, one turn below the frontier trio.
• You want automations in your pocket with zero setup: Mira-style consumer agents inside the chat app you already use.
• You need volume, privacy, or permanence: the open wave. DeepSeek V4 Flash for cost, GLM-5.2 for planning quality, MiniMax M3 for multimodal, and Kimi K3 if you want frontier-band capability you can (from July 27, if the weights ship on schedule) actually download. Just bring a real verifier; K3's own numbers argue for one.

Your first loop this week

One honest recipe, vendor-neutral:

1. Pick a task you already repeat by hand, where you are the bottleneck.
2. Write the stop condition first. If you cannot write "done means X," the task is not loop-ready yet.
3. Write the check. A script, a test, a rubric for a second model. This is the hour that matters.
4. Run it turn-based a few times, watching every cycle.
5. Hand off the stop condition (a goal loop with a turn cap). Watch where it stalls or overreaches; tighten the criteria.
6. Only then hand off the trigger (schedule it), with a budget cap and read-only permissions to start.
7. When it fails, and it will, turn the failure into a test case. That is the self-improving part, and it is you and the loop together.

Climb one rung at a time. The people getting outsized results from these systems did not find a secret model. They found a task worth looping, defined done, and built a check they trust.

One last thing

The prompt era trained everyone to ask better questions. The loop era asks something different of you: define outcomes precisely enough that a machine can pursue them while you are elsewhere, and design the checks that keep that pursuit honest.

That is a real skill, and it is not prompt-writing. It is closer to management. A goal, a standard of done, the right tools, a budget, a check you trust, and an escalation path for judgment calls. Every lab in this article, from a three-trillion-dollar company to a two-person Telegram startup, is converging on machinery that rewards exactly that skill.

The slow way still works, if typing, waiting, fixing, and re-asking is the relationship you want with this technology. But the hand crank is now optional, and the labs have collectively decided which direction this goes. The unit of work is the loop. The person who defines the loop is you.

Start with one. Define done. Trust, but verify. Then let go of the crank.

Sources

Everything above was checked against primary sources in the week ending July 25, 2026. Grouped by lab:

The loop concept

• Anthropic, Getting started with loops: claude.com/blog/getting-started-with-loops
• OpenAI, A practical guide to building agents: openai.com/business/guides-and-resources/a-practical-guide-to-building-ai-agents
• Anthropic, Building effective agents: anthropic.com/engineering/building-effective-agents and Effective context engineering: anthropic.com/engineering/effective-context-engineering-for-ai-agents

Anthropic

• Claude Fable 5: anthropic.com/claude/fable and launch post: anthropic.com/news/claude-fable-5-mythos-5
• Claude Opus 5 (July 24, 2026): anthropic.com/news/claude-opus-5
• Routines: code.claude.com/docs/en/routines · Dynamic workflows: code.claude.com/docs/en/workflows

OpenAI

• GPT-5.6: openai.com/index/gpt-5-6 · Work and Codex: help.openai.com/en/articles/20001275 · ChatGPT agent discontinued: help.openai.com/en/articles/11752874 · Agents guide: developers.openai.com/api/docs/guides/agents· Auto-review: alignment.openai.com/auto-review

Google

• Deep Research Max announcement: blog.google · Deep Research docs: ai.google.dev/gemini-api/docs/deep-research

Meta

• Muse Spark 1.1 announcement: ai.meta.com/blog/introducing-muse-spark-meta-model-api · Coding agents guide: dev.meta.ai/docs/guides/coding-agents

xAI

• Grok 4.5: x.ai/news/grok-4-5 · Docs: docs.x.ai/developers/grok-4-5

Mira

• Product site: mira.tg · Milestone post: mira.tg/blog/mira-1-million-monthly-users

Open-weight wave

• Kimi K3 independent evaluation and weights timeline: TechTimes, July 24, 2026 · launch: VentureBeat, July 16, 2026
• Qwen3.8-Max preview: MarkTechPost, July 19, 2026
• OpenRouter, The Open Weight Models that Matter, June 2026: openrouter.ai/blog
• Thinking Machines Inkling: TechCrunch, July 15, 2026
• Independent scores: Artificial Analysis Intelligence Index v4.1, as reported July 24, 2026