250 subagents vs. 4 threads: why orchestration architecture matters more than a loud model name

• The OSWorld 2.0 gap: 70.2% of checkpoints passed vs. 34.7% of tasks fully solved
• Orchestration parallelism: 250 simultaneous subagents and 5 levels of nesting in Claude Code vs. 4 threads in Codex
• Token spend on a single migration task in Codex: 4.7 billion tokens in a week (out of 12.7 billion over a year and a half)
• Duration of the live-fire test: more than 12 days of continuous runtime vs. 1 workday with a swarm of agents

Every wave of releases from major labs comes with the same visual hypnosis. With the launch of GPT-6 Astra, social feeds filled up with slick clips: the model spins 3D scenes in Blender, unwraps textures, assembles an engineering part with export to STEP, and clears level 44 of a joke CAPTCHA by beating a chess engine. The marketing hit its mark perfectly — people think in images, and a striking visual instantly gives birth to a legend about arrived superintelligence.

But open the source of the loudest engineering demo with blueprints, and a detail everyone reposting it forgets surfaces: it's a third-party open-source skill set called `text-to-cad`, written by an independent developer. In exactly the same way, my Claude Code with a specialized skill controls AutoCAD and Blender without any magic baked into the weights.

Why doesn't 72.6% in the OSWorld 2.0 marketing table mean 72% of the

work got done?

The second sleight of hand lies in how vendors present computer-use benchmark numbers. To be fair, visual interface recognition has genuinely advanced — ScreenSpot-Pro is now at 92.7%. But the 72.6% figure on OSWorld 2.0 that every tech blog repeated is flagged, in the fine print of the very same table, as a `partial score`.

If you open the official independent OSWorld 2.0 leaderboard, it always shows two columns: the share of intermediate checkpoints passed within a scenario, and the share of tasks carried through to a final result. Looking at verified runs of Claude Opus 5 shows exactly how this ratio works: the model passes 70.2% of checkpoints, but fully closes only 34.7% of tasks. The difference is exactly twofold. Between "pressed the two right buttons out of three" and "delivered a finished project to the client" lies a gap no polished preview can bridge.

What did a 12-day stress test of migrating 369 skills and 40 agents show?

To test models on something other than toy examples, I give them real infrastructure work. The task was stated with total precision: carry out a full, seamless migration of my working environment (369 skills, 40 agents, routing, scripts, and multi-layer memory) from the Claude Code format into an isolated Codex environment.

I started this experiment back on GPT-5.6 Sol, and after the release switched the job over to GPT-6 Astra. After twelve straight days of continuous execution and 4.7 billion tokens burned in a single week, the task still wasn't closed. For comparison: a refactor of comparable scope in my standard environment takes one workday.

When I dug into the documentation and the binary constraints of both tools, the reason surfaced:

• In Claude Code, the `CLAUDE_CODE_MAX_CONCURRENT_SUBAGENTS` variable accepts any integer — in my production setup it's set to 250 parallel subagents and up to 5 levels of hierarchy.
• In Codex, the `max_threads` parameter is capped at 4 open threads, and a finished worker keeps occupying a slot until the orchestrator explicitly calls `close_agent`.
• Instead of declarative multi-wave pipelines, you have to manually pull the `spawn_agent` and `wait_agent` primitives one at a time.

Why is a week of an agent working autonomously a symptom of a

bottleneck, not a reason for pride?

It's fashionable right now to be impressed that an agent can autonomously grind away at a task for a whole week. In practice, that just means one thing: the system has no proper orchestration bus to break the task into fifty independent hands and assemble the result in two hours with verification of every piece. Even the fastest model stuck in a queue of four threads will lose to a well-designed swarm.

I publish detailed breakdowns of multi-agent system architecture and honest model tests without the marketing fluff in the channel [@jemal_hamidun](https://t.me/jemal_hamidun). We're building a full orchestrator with no artificial thread limits in the product [Nomad AI](https://nomadnet.ai). You can learn to build subagent swarms hands-on at [Hamidun Academy](https://academy.hamidun.com) with a 72-hour trial, and grab ready-made swarm configurations and 370+ skills at [Vibe Club](https://hamidun.com/club).