- AI
- News
- Automation
What Comes After Loops? Agent Teams That Explore Wide and Push Together
Loops keep one agent working. The next step is teams of agents that try different paths, share every dead end and regroup on the one that works. What OpenAI, Anthropic and xAI showed this autumn, where swarms break, and a checklist for your first agent team.

Picture this: you start four agent threads on the same nasty bug. Two hours later you read the logs. Three of them spent the afternoon on the same dead end, two created a branch with the same name, and the one that found the real cause never told the others. You paid for four agents and got one, plus three bills.
That is the problem the next step after loops is trying to solve. A loop keeps one agent going until the job is done. An agent team spreads several agents over different approaches, lets them tell each other what they found, and moves everyone onto the path that works. Think of a search party in a forest: everyone takes a different trail, radios in when they hit a cliff, and when one person finds the track, the whole party walks over.
💬 Explore wide. Share every dead end. Then push together.
In this post you get the ladder from one agent to swarms as OpenAI presented it at DevDay, the two experiments that show what teams of agents can do (OpenAI's Navier–Stokes run and Anthropic's 45-agent vulnerability hunt), where swarms break, what xAI ships as a product, and a checklist for your first agent team. Here is the whole story in 56 seconds, no sound needed:
🔁 Step One: One Agent, One Loop
Loops were a workaround. Older models often stopped after one turn even though the task was not finished, so people wrapped them in a loop that said "continue" again and again. Geoffrey Huntley's Ralph loop made that a pattern: a bash loop runs the agent on the same prompt file, each run starts with a fresh context and picks up the files and plan the last run left behind.
At OpenAI DevDay Exchange Tokyo on 20 October, Bonnie Chatterjee (OpenAI) walked through what happened next in her talk "What Comes After Loops?", according to a detailed attendee report built from a recording of the session. Codex got /goal: a goal that survives individual turns. The harness stores it outside the conversation, and when a turn ends while the goal is still open, it starts the next turn with the goal and a reminder to continue. Compaction squeezes the history into a small working state when the context window fills up, so the agent keeps what it learned and still has room. And GPT-6 was trained to keep going without the outer "continue" at all.
Her advice was surprisingly modest: start with one agent, a clear task and a way to check the result. Add agents only when you can name a clear reason in the work itself.
🧠 Myth check. "More agents means better results." Every extra agent adds coordination cost. OpenAI's own recommendation is one agent with a way to verify, and more agents only for work that is wide by nature: big refactors, games with separate parts, research with many possible paths.
🪜 The Ladder: From One Agent to Swarms
The talk then climbed a ladder. Each rung is a different way to split work, and each one costs more coordination than the one before:
| Rung | What it looks like | Use it when |
|---|---|---|
| One agent + loop | One agent, a /goal, compaction | Default. Most tasks end here |
| Parallel threads | One chat per task, and Codex (or a Dot) manages the threads, e.g. one review chat per open PR | Many independent tasks |
| Model mix (effort scaling) | An internal "coordinate" skill: a mid-size model does the work, asks a bigger one when stuck, hands simple steps to a smaller one | Cost matters, a few steps are hard |
| Pairs | Two agents with complementary jobs and a shared goal, e.g. one extracts game scenes, one rebuilds them in Blender | Two skills that check each other |
| Manager | You talk to a manager agent, it runs feature, bug and playtest agents | You want one point of contact |
| Long-running leads | One agent per workstream (art, code, design, playtest) for weeks, plus one compact work log | Projects that run for months |
| Agent teams | Groups on different variants of the problem, talking across groups, regrouping on what works | Wide search: research, vulnerability hunting |
Two tips from the talk apply to every rung above "one agent": give each agent clear ownership of its piece and avoid layers of approval, and keep one compact work log (goal, current instructions, who owns what, open work, decisions) that every agent reads after a compaction or handoff.
🔭 The Top Rung: Explore Wide, Share Findings, Push Together
The best-documented example of the top rung is OpenAI's own. On 8 September 2026 OpenAI published a solution to the Navier–Stokes Millennium Prize problem, produced by a system of coordinating agents on an internal model that OpenAI calls significantly more capable than GPT-6 Astra. The write-up describes the team pattern step by step:
- Explore wide. Separate groups got different variants of the problem: versions A and B (which would lead to a proof) and C and D (which would lead to a disproof). Groups could talk internally, and OpenAI encouraged a diversity of approaches.
- Share findings. After a while OpenAI "cross-pollinated" the groups, using Codex to consolidate the most useful insights from each group into follow-up prompts.
- Push together. Nearly 100 agents resolved an easier side problem, the unforced Euler blow-up, in about 50 hours. OpenAI then moved agents away from the other Millennium problems onto Navier–Stokes and prompted them with the Euler result.
The group that produced the result ran on the order of 10,000 concurrent agents, finished about 88 hours after the first launch, and sent 2.7 million messages using about 130 billion output tokens for Navier–Stokes alone. GPT-6 Astra needed another 17 hours for the Lean formalization.
Where the evidence stops: OpenAI published a paper and a Lean proof, but it does not claim the prize. The Clay Mathematics Institute wrote on 11 September that the problem "has apparently been settled", but it has not accepted the proof or decided on any prize: its evaluation is "deliberately unhurried". There is also a public priority dispute: mathematicians Tristan Buckmaster and Levent Alpöge say their work on the forced Euler problem reached OpenAI before the run, which OpenAI denies. For this post the maths is secondary. What matters is that the method, wide variants, cross-team sharing and a regroup on the winner, is written down by the people who ran it.
🐝 45 Agents, One Forum: What Anthropic Measured
The cleaner measurement comes from Anthropic's Frontier Red Team. In "Patterns and problems in emerging multiagent systems" (13 August 2026) they gave 45 agents their own virtual machine each, one shared forum, and the same prompt: find vulnerabilities in 15 open-source projects. Agents peer-reviewed each other, and a separate arbiter agent decided whether a finding was new and valid. The baseline was the classic setup: independent agents, each pointed at a fixed part of the code.
| Setup (Claude Mythos Preview) | Vulnerabilities | Tokens | Tokens per finding |
|---|---|---|---|
| Independent parallel agents, fixed areas | 21 | 6.5 M | ≈ 310 k |
| Coordinating swarm, shared forum | 266 | 27 M | ≈ 102 k |
The last column is our arithmetic, and Anthropic explicitly warns against reading it as "the swarm is three times cheaper". Roughly half of the 266 findings were outside the core directories the independent agents were told to search. Limited to the core directories, both methods were comparable in tokens per vulnerability. Only 12 vulnerabilities appeared in both sets, so the methods are mostly complementary. The swarm went wherever bugs were easiest to find, built itself tools and specialised in vulnerability types.
🧠 Myth check. "A swarm finds bugs more cheaply." On the same ground it costs about the same per bug. What it buys you is reach: it finds different bugs in places nobody assigned. Budget for more tokens in total, not fewer.
🪤 Where Swarms Break
The same Anthropic paper is mostly a list of failures, and two of them matter for anyone running agents in parallel today.
Agents think alike. All that separates one agent from another is its context, scaffolding and model. In an early game-building run, 18 of 30 agents created a git branch with the exact same name, mvp-game-loop. In a job-queue test without coordination, agents flooded a system with polling daemons running 30 times a second: one run produced 2.4 million job requests and 117 accepted jobs. One agent's bad idea becomes everyone's bad idea.
Tangled work is hard. Vulnerability hunting is wide: if one agent misses a bug, nobody else's work breaks. When Anthropic had swarms build a web game together for 12 hours, the dependencies hurt. Older models (Sonnet 4.6, Opus 4.6) opened hundreds of PRs that conflicted and were abandoned. Newer ones (Opus 4.8, Mythos Preview) "solved" that by barely sharing code at all. Only Sonnet 5 shared files and still merged most of its PRs. The games were bad either way.
The rule we take from it: teams pay off on independent pieces with many possible paths, and they need a shared place to coordinate. Without one, they collide.
💬 Agent Teams as a Product: Grok Bot 1.0 and Grok 4.8
Teams of agents are not only a lab setup any more. On 2 November xAI launched Grok Bot 1.0: you can share Bots and bring them into Slack, Microsoft Teams and video calls, Bots "can recognize work that needs to be done and offer to take it on", and they can "coordinate with other Bots", for example a Research Bot handing ad-concept work to a Copy Bot. Team Bots need a Team or Enterprise plan. To be precise: this is a team of bots working in your team's channels, not the explore-wide pattern from the Navier–Stokes run. xAI does not say its Bots explore in parallel.
The model behind it is next. On 10 November Elon Musk wrote on X that pre-training of Grok 4.8 is done, that it is now in reinforcement learning, and that xAI would do a soft rollout to Bot users "later this week". In the same thread he said 4.8 will not match Claude Opus 5.5. As of 17 November, xAI has published no model page, model ID, price or benchmark, so treat 4.8 as announced, not shipped.
✅ Checklist: Before You Go From One Agent to a Team
- Can one agent do it? Try one agent with
/goal(or your harness's equivalent) and a clear check first. - Is the work wide? Many independent pieces or many possible paths: yes. One tangled codebase change: probably not.
- Different briefs. Each agent or team gets its own variant, area or approach. Same prompt, same answer.
- One shared forum. Agents post findings and dead ends there and read it before every new approach, so nobody walks into the same dead end twice.
- One compact work log. Goal, owners, open work, decisions. Read after every compaction.
- A verifier. Anthropic used an arbiter agent to accept findings. Without one, a swarm floods you with duplicates and false positives.
- A token budget. Expect a higher total bill. Measure findings per token inside the same scope, not across scopes.
🧭 The TechChase Take: Teams Beat Loops Only When the Work Is Wide
Our personal comment: "We think agent teams are the right next step for search problems, and the wrong first step for almost everything else." Most of our client work is still one well-briefed agent with a good check, and that is exactly what OpenAI recommends too.
Why we see it that way:
- The evidence is about search. Both strong data points, Navier–Stokes and the vulnerability hunt, are problems where you don't know which path works and failed paths don't break anything. That is where exploring wide pays.
- The gain is reach, not efficiency. Anthropic's swarm found 12 times more vulnerabilities, but within the same scope the cost per bug was comparable. You buy a wider search, and you pay for it in tokens.
- Coordination is the hard part. The failure that bites first is agents doing the same thing: 18 of 30 picking one branch name, polling daemons jamming a queue. Anthropic's own suggested fix is a central forum where agents agree on what they do, and even that only works if the prompts and the model lean towards collaborating.
- Diversity has to be designed. Agents from the same model are low-variance. The team only explores wide if the briefs are different.
Where the other side still wins: on tightly coupled code, a single strong agent (or a pair with clear ownership) beats a crowd, and Anthropic's game experiment shows even the newest models avoid sharing files rather than coordinate on them. And product teams like Grok Bot's may matter more day to day than research swarms: a bot that picks up work in Slack saves time on Monday, a 10,000-agent run doesn't.
Our recommendation: keep one agent as your default, and run your next wide task, a security sweep, a dependency audit, a research question, as a small team of three to five agents with different briefs, one shared forum and one verifier. Compare it with your single-agent baseline on findings per token in the same scope. If the team doesn't win there, go back to one agent.
⚡ Knowledge Bytes
- 🔁 Loops started as a workaround for models that stopped too early; Codex's
/goaland GPT-6's persistence now keep one agent going on its own.- 🪜 OpenAI's ladder runs from one agent through parallel threads, model mixes, pairs, managers and long-running leads up to agent teams.
- 🔭 OpenAI's Navier–Stokes run gave agent groups different problem variants, cross-pollinated their insights with Codex, and moved everyone onto the path that worked.
- 🐝 In Anthropic's test, 45 agents with one shared forum found 266 vulnerabilities versus 21 for independent agents, using 27 M instead of 6.5 M tokens.
- ⚖️ Within the same code directories, the swarm cost about as many tokens per vulnerability as independent agents; its gain is reach, not efficiency.
- 🪤 Agents from the same model think alike: 18 of 30 picked the same branch name, so every team needs different briefs and a shared forum.
- ✅ Start with one agent and a clear check; add a team only for work that is wide, with different briefs, one forum and one verifier.
- 💬 Grok Bot 1.0 puts shared bots into Slack, Teams and video calls, and Grok 4.8 is announced for Bot users but not yet published.
📚 Sources
- OpenAI: On the Navier–Stokes Millennium Prize Problem (8 Sep 2026): https://openai.com/index/navier-stokes-solution/
- Anthropic: Patterns and problems in emerging multiagent systems (13 Aug 2026): https://www.anthropic.com/research/multiagent-systems
- xAI: Introducing Grok Bot 1.0 (2 Nov 2026): https://x.ai/news/grok-bot-1-0
- Elon Musk on X about Grok 4.8 (10 Nov 2026): https://x.com/elonmusk/status/2120088070443655190
- OpenAI DevDay 2026, session "What Comes After Loops? A Deep Dive Into Agentic Architecture": https://openai.com/devday/2026/
- Elith (Zenn): OpenAI DevDay Exchange Tokyo 2026 report, transcript-based (in Japanese): https://zenn.dev/elith/articles/devday-exchange-tokyo-2026
- PlanitAI (note): DevDay Exchange Tokyo participation report: https://note.com/planitai_inc/n/n22ac36b98c21?hl=en
- Wikipedia: Navier–Stokes priority controversy: https://en.wikipedia.org/wiki/Navier%E2%80%93Stokes_priority_controversy
- Forklog: Musk calls Claude Opus 5.5 a masterpiece, admits Grok 4.8 lagging behind: https://forklog.com/en/musk-calls-claude-opus-5-5-a-masterpiece-admits-grok-4-8-lagging-behind/
- OrcaRouter: Grok 4.8 is in RL, what the promised Bot rollout means: https://www.orcarouter.ai/blog/grok-4-8-limited-rollout-what-we-know
- Clay Mathematics Institute: Navier-Stokes announcement (11 Sep 2026): https://www.claymath.org/news/navier-stokes-announcement/
- Tristan Buckmaster: statement on the Euler and Navier–Stokes results (Sep 2026): https://cims.nyu.edu/~tristanb/statement.pdf
Keep reading
More articles on AI, automation and software engineering from the TechChase team.