Claude Code’s 98-Agent Research Blowup Is the Cost-Control Story in One Absurd Repro

“Deep research” sounds responsible until it sends 98 agents to answer a keyboard LED question. Then it sounds like a scheduler without a governor.

A new Claude Code enhancement request filed on June 23 reports that the deep-research workflow fanned out into 98 parallel agents for a simple Linux configuration question: “How do I set static white RGB on a Razer BlackWidow Chroma V2 at Linux startup without Razer Synapse?” According to the report, the workflow performed web searches, fetched sources, ran adversarial verification, and consumed 700k+ tokens before the user manually stopped it. The final useful answer was roughly ten lines of shell commands the model could already produce without building a research department.

That example is funny because it is absurd. It is also useful because it makes the agent-cost problem legible. Cost is not only model pricing. Cost is orchestration behavior: when the runtime chooses to search, delegate, verify, retry, summarize, compact, and spawn more workers. A model that costs pennies per million tokens can still become expensive if the product casually multiplies work by two orders of magnitude.

The expensive decision happened before the answer

Most AI cost dashboards look backward. They tell you what happened after the tokens are gone. That is necessary accounting, but it is not control. In this report, the critical decision was not the final answer. It was the moment Claude Code classified a narrow hardware setup question as worthy of a full research pipeline.

The distinction matters. A single-agent mistake wastes one path. A multi-agent orchestration mistake creates a small distributed system: workers search independently, fetch overlapping sources, debate relevance, synthesize, verify, and send summaries back to a coordinator. That can be exactly right for a broad, contested, multi-source research task. It is wildly disproportionate for “set this keyboard color on Linux at startup.”

Anthropic’s own Claude Code agent-team documentation warns that agent teams add coordination overhead and use significantly more tokens than single sessions. It also distinguishes lower-cost subagents, which summarize results back to the main context, from higher-cost agent teams, where each teammate is a separate Claude instance. Those are not implementation details. They are budget semantics. A runtime that can create many independent workers is making a spend decision, not merely a reasoning decision.

The reported user was on Claude Max at around €110/month. That plan detail is important because subscription pricing tends to blur marginal cost perception until limits appear. Users do not necessarily see “700k tokens” as a line item in the moment. They see a task that ran too long, did too much, and had to be interrupted manually. Trust erodes before the invoice explains itself.

Delegation needs a preflight, not a postmortem

The fix class is not “never use deep research.” The fix is proportionality. Before spawning a research workflow, an agent runtime should ask a few plain questions: is this stable knowledge or fresh news? Is the answer likely in the model already? Is the uncertainty narrow enough for one or two searches? Does the user need citations, adversarial verification, or just a working command? What is the maximum token budget? How many workers are allowed? What condition stops the run?

For a keyboard RGB question, a reasonable path is: answer from known Linux tooling if confident, maybe run one web search for the device-specific package or command name, and ask before escalating. The enhancement request itself suggests a lightweight route such as one or two WebSearch calls for quick fact checks, reserving the full pipeline for genuinely complex research. That is the right instinct. “Research” is not a binary mode. It is a ladder.

Practitioners building their own agent systems should treat delegation as a privileged operation. Give it a budget object, not a vibe. Set hard caps for max agents, max searches, max fetched pages, max wall-clock time, max tokens, and max retry depth. Require a short plan before fan-out: “I will spawn up to N workers because these subquestions are independent.” If the model cannot articulate why parallelism helps, it probably should not get parallelism.

There is also a UX requirement. Before a workflow launches 98 workers, the user should see a preflight estimate: “This may spawn up to 20 agents and spend roughly X tokens. Continue?” Better yet, the default cap should be low and expandable. Cloud providers learned this years ago with infrastructure provisioning. You do not spin up a fleet because a user asked a question that could be answered by one VM. Agent products need the same cost hygiene.

Observability has to be live, not forensic. A user watching a deep-research run should see the worker count, token burn, sources fetched, duplicate searches, and current stop condition. If the run is mostly verifying the same fact through redundant paths, the coordinator should collapse the work. If the answer stabilizes early, stop. The best cost control is not a cheaper retry; it is recognizing that enough work has already been done.

The safety angle is larger than billing. A runtime that cannot bound fan-out also cannot reliably bound blast radius. Today the failure mode is 700k tokens for a Razer keyboard. Tomorrow it is 98 agents touching a repository, querying MCP servers, running tests, posting comments, or exhausting CI minutes. Cost, reliability, and safety converge at the scheduler. The component deciding “how much work should exist?” is part of the control plane.

This is where agent products will differentiate. Everyone can demo an agent that finds an answer eventually. Mature tools will know when not to mobilize the army. They will make small tasks cheap, large tasks explicit, and runaway tasks interruptible with useful partial results.

My take: the 98-agent repro is not a weird edge case to laugh off. It is the whole cost-control story in miniature. Agent spend belongs in the scheduler, not the billing page, because the expensive mistake happens before the first beautiful synthesis paragraph is written.

Sources: Anthropic Claude Code issue #70269, Claude Code costs documentation, Claude Code workflows documentation, Claude Code agent-teams documentation