Back to Blog
claude-codeweekly-updatemulti-agent +9 topics

What's Up Claude Code: Week of August 10th

A 60-agent Claude Code run produced a formally verified mathematical advance, contextual forks and cross-session messaging became native workflow primitives, and Anthropic published the failure modes hiding inside agent swarms.

Olivier Legris Calculating read time…
In this article

TL;DR

Claude Code showed both sides of the multi-agent future this week.

An unreleased Claude research model used two Claude Code sessions, 31 million output tokens, and roughly 60 subagents to improve a longstanding lower bound related to the Riemann hypothesis from 41.6% to 67.2%. The run lasted about a day and a half, executed 2,400 shell commands, wrote hundreds of Python scripts, checked 54 papers, refereed its own work, and produced a Lean formalization.

Three days later, Claude Code v2.1.232 made contextual subagent forks the default and turned @session-name into a native way to message another live Claude session. The product is no longer merely adding multi-agent features. It is making parallel, communicating agents part of the ordinary CLI workflow.

Anthropic also published the warning label. In experiments with 45-agent vulnerability swarms and up to 80-agent coding teams, coordination expanded coverage but also amplified conformity, merge conflicts, duplicated work, and correlated failure. In one run, 18 of 30 agents independently chose the same Git branch name.

The takeaway: agent count is not an architecture. The useful unit is a team with explicit scope, diverse context, independent judges, bounded resources, inspectable artifacts, and a human who can still tell whether the work is good.

1. A 60-agent run produced a real mathematical result

Anthropic asked an unreleased Claude research model to take a serious attempt at the Riemann hypothesis. It did not solve the famous conjecture. It did something more credible: it found a narrower result, tested it aggressively, wrote it up, and asked humans to validate it.

The result increases the known lower bound for the proportion of nontrivial zeros of the Riemann zeta function on the critical line from 41.6% to 67.2%. It builds on decades of prior work rather than replacing it.

The workflow matters as much as the mathematics:

  • The first pass generated 650 unsuccessful ideas.
  • A second pass coordinated about 60 subagents for roughly a day and a half.
  • Two agents developed the key ideas, 13 contributed supporting ideas, 30 tried other approaches, 13 validated arguments, and two helped draft the paper.
  • The agents ran 2,400 shell commands, wrote hundreds of Python scripts, and performed thousands of numerical checks.
  • They downloaded 54 arXiv papers to test novelty, searched for counterexamples, reviewed one another’s proofs, and attempted an independent re-proof.
  • Claude then worked with an Anthropic staff member to produce a Lean formalization that passed the standard comparator validation tool.

Two Anthropic mathematicians validated the work, and external experts Brian Conrey and Dan Goldston examined the paper on short notice. That is meaningful scrutiny, but it is not the same as completed peer review. Anthropic updated the paper on August 13 to clarify the proof and historical context.

The reusable lesson is not “spawn 60 agents.” It is the shape of the system: broad exploration, specialization, adversarial review, computational checks, literature search, formal verification, and explicit escalation to domain experts.

Most software teams do not need 31 million output tokens. They do need the same separation between idea generation, implementation, verification, novelty checking, and final judgment.

2. Claude Code made multi-session work native

v2.1.232 shipped the most consequential product change of the week.

A subagent_type: "fork" agent now inherits the full conversation and prompt cache by default. Non-teammate agents launched from an interactive session run in the background by default. Type @ and the name of another live Claude session, and Claude can use SendMessage to contact it directly.

The release also added practical controls:

  • live sessions on one machine keep unique names;
  • exact-name messages no longer require an extra confirmation step;
  • /config exposes whether cross-session messages are accepted, held, or refused;
  • SendMessage can address a unique live session by bare name;
  • completed background agents disappear from the panel with a pointer to /tasks;
  • Fable 5 returned as an advisor for organizations with access.

This makes an “architect plus specialists” workflow much easier: keep one session responsible for the plan and shared constraints, fork specialists with the relevant context, and message another live session when its expertise or artifact is needed.

But context inheritance is not role design. A fork starts with the parent’s assumptions, blind spots, and prompt history. If every specialist receives the same framing, parallelism can produce ten confident versions of the same mistake.

Use forks when shared context is genuinely valuable. Use fresh sessions when independence is the point. Give every handoff a concrete artifact, acceptance criteria, and a named owner for integration.

3. Anthropic published the swarm failure modes

Anthropic’s multiagent-systems research is a useful antidote to the week’s excitement.

In one experiment, 45 agents received separate virtual machines, a shared forum, and the same task: find vulnerabilities across 15 open-source projects. A coordinating Mythos Preview swarm found 266 vulnerabilities using 27 million tokens. Independently parallelized agents found 21 using 6.5 million tokens.

That headline needs context. Roughly half of the swarm’s findings were outside the core directories assigned to the independent agents. Restricted to the same core area, the approaches looked comparable in tokens per vulnerability. Only 12 findings overlapped, showing that the two methods explored different parts of the problem.

Coordination helped agents specialize and broaden the search. It did not make the comparison a simple 266-to-21 win.

The harder test asked agent swarms to build a web-playable fantasy game over 12 hours. The games were bad. Early models created conflicting pull requests and abandoned them. Newer models avoided conflict partly by sharing less code. Sonnet 5 was the only tested model that combined substantial code sharing with high PR throughput.

The systemic failures are the important part:

  • 18 of 30 identical agents independently created a branch named mvp-game-loop;
  • writing agents repeatedly produced the same title without being given a subject;
  • more than half of agents asked to make something impressive chose ray tracers or self-hosting compilers;
  • communicating agents in an iterated prisoner’s dilemma converged on the same strategy and defected together.

Multi-agent systems can increase diversity of effort while decreasing diversity of thought.

Practical countermeasures:

  1. Vary roles, evidence, tools, and framing—not just agent names.
  2. Assign non-overlapping ownership before work starts.
  3. Require independent reviewers that do not inherit the implementation context.
  4. Make branch, file, queue, and resource allocation deterministic.
  5. Measure accepted outcomes and overlap, not messages sent or agents spawned.
  6. Keep a human responsible for taste, priorities, and the definition of “done.”

4. Seven releases tightened the runtime

Claude Code moved from v2.1.227 to v2.1.233 during the reporting window.

The multi-agent changes were the headline, but the operational work was substantial:

  • self-hosted runners gained server-supplied hooks and faster startup;
  • same-prefix workflow fan-outs are staggered so later agents can reuse the cached prompt prefix;
  • GitLab merge-request URLs now work with --worktree and appear as !N in claude agents;
  • GitLab plugin marketplaces and token-family redaction landed;
  • Linux Bash commands can receive an opt-in memory cgroup through CLAUDE_CODE_TOOL_MEMORY_LIMIT;
  • MCP v2 clients no longer endlessly reopen subscription streams when serverless hosts terminate long-held connections;
  • nested Git repositories now require their own trust confirmation;
  • a Windows NT path-validation gap that could leak NTLM credentials was closed;
  • a PowerShell permission bypass and Cygwin-style symlink write bypass were fixed;
  • self-hosted-runner and Remote Control reliability received several rounds of fixes.

One migration detail is easy to miss: task-tracking tools including TaskCreate, TaskGet, TaskUpdate, TaskList, and TodoWrite are now disabled by default on Opus 4.8, Sonnet 5, Fable 5, Mythos 5, and newer models. Set CLAUDE_CODE_ENABLE_TODO_TOOLS=1 if an existing workflow depends on them.

The direction is clear. Claude Code is becoming a distributed runtime with sessions, runners, identities, messages, resource limits, marketplaces, gateways, and policy—not merely a local terminal interface.

5. Anthropic finally explained the session cost model plainly

Anthropic’s guide to maximizing Claude Code session value is the most useful operator documentation of the week.

The central fact is simple: files and command output added to a conversation are sent again on every later turn. Prompt caching makes repeated input cheaper, but it does not make irrelevant context free. The model still has to reason around it.

The practical advice is unusually specific:

  • run /clear between unrelated tasks;
  • choose /model and /effort before the session gets long;
  • @-mention a file when you already know what Claude needs, avoiding a search and Read turn;
  • use quiet flags or a subagent for noisy commands so huge logs do not live in the main context;
  • run /context in a fresh session to see the cost of CLAUDE.md, tools, and MCP definitions before doing work;
  • run /compact before a long break, while the existing prompt cache is still warm.

Prompt-cache reads cost 0.1× ordinary input. Cache writes can cost up to 2×. Changing models or effort mid-session breaks the cache prefix and can force the whole conversation through prefill again. On subscriptions, the cache expires after an hour; API-key sessions default to five minutes unless one-hour caching is enabled.

This turns “context management” from vague prompt advice into economics. The cost of a session is mostly how much enters the context, how many turns it remains there, and how many contexts run in parallel.

That last variable matters more now that forks run in the background by default. Multi-agent work can save elapsed time while multiplying input, output, and verification cost. Measure cost per accepted artifact, not cost per agent or token.

6. Enterprise audit coverage reached local sessions

The Compliance API now covers Claude Code and Cowork sessions running on users’ machines. The beta is available to Claude Enterprise customers through the same Compliance API interface already used for Claude chats.

A session record can include:

  • prompts and responses;
  • web and MCP tool-call content;
  • skills and artifacts captured as transcript text;
  • verified user ID and email;
  • organization, session, and message IDs;
  • timestamps.

The beta does not include Claude Code on the web, Claude Code through the Claude Platform, or sessions run on Bedrock, Vertex AI, or Microsoft Foundry.

For security teams, this closes an audit and eDiscovery gap without requiring a separate logging system for every surface. For employees, it means “local session” no longer implies “locally visible only.” Organizations should state retention, access, disclosure, and acceptable-use policies clearly before treating the new endpoint as routine telemetry.

Governance is catching up with autonomy. That is good—provided everyone knows where the transcripts go.

7. The issue tracker tested the new defaults immediately

The release notes show fixes. The issue tracker shows where acceptance tests should go next.

Several in-window reports describe cross-session delivery problems, especially in Desktop on Windows:

  • #86275 reports send_message claiming success while the message never arrives after a runtime update.
  • #86012 reports a received cross-session message leaving the target session unresponsive until an idle-timeout kill.
  • #86069 reports messages reaching the recipient’s composer without being submitted.
  • #86090 reports a named teammate completing without delivering its final text to the parent.

Auto mode also hit a Windows regression in v2.1.232. Reports #86619 and #86630 describe basic compound commands repeatedly prompting despite allow rules. v2.1.233 reverted the broad Bash-permission changes for Cygwin-style symlinks and input redirections while retaining narrower security fixes.

These are issue reports, not proof that every installation is affected. They are still strong test cases.

Do not treat “message sent,” “agent done,” or “permission configured” as evidence. Verify delivery, artifact existence, tests, effective policy, and current version.

8. Community projects

Four fresh projects stood out this week. They are early tools, not audited endorsements.

  • Airship — created August 10, this Figma-like visual editor sits in front of a local web app. Select a live DOM element and ask Claude Code, Codex, or OpenCode to change the corresponding source. It is a sharp bridge between visual review and agent edits, but agents run unsandboxed by default; Airship’s --safe OS sandbox currently applies only to Codex.
  • tokentab — created August 12, it parses local Claude Code, Codex, and Gemini CLI logs into model-, project-, day-, and activity-level token and cost views. The terminal and localhost dashboards keep the audit local. Cursor support is still incomplete, prices are manually maintained, and activity classification is heuristic.
  • RuleBlast — created August 12 and already at v2.1.2, this deterministic CLI shows which repository paths inherit a changed AGENTS.md or CLAUDE.md. It runs read-only without model calls and can put instruction-file blast-radius analysis into CI. It models repository instructions, not user, managed, or session-level policy.
  • Vibe ASO — an August 12 Claude Code skill for App Store keyword research, metadata across up to 50 locales, localized screenshots, territory pricing, in-app localization, and submission checks. It is a useful example of packaging a messy vertical workflow as an inspectable skill rather than a generic prompt.

The pattern is instrumentation around agents: visual selection, spend visibility, instruction provenance, and domain-specific process. The model is only one layer; the product is increasingly everything that makes its work legible.

9. smol.ai / Latent Space signal: the harness is becoming the operating system

This week’s broader agent signal was not another benchmark. It was the explosion of harnesses.

DeepSeek open-sourced DeepSeek Harness as an MIT-licensed developer preview built around an “everything is a plugin” architecture. Arcee published NAC for long-running asynchronous work. Meta released Muse Glimmer for local, always-on agent workflows. Anthropic made subagent forks and session messaging default. The smol.ai August 13 roundup captured the common direction: durable execution, cache-aware history, visible trajectories, composable tools, and recoverable long-running jobs are becoming the competitive surface.

That is healthy. It also means failures move up a level.

A weak model can fail a task. A weak harness can lose the task, duplicate it, leak its context, misroute its message, exhaust its budget, or confidently report that work happened when no artifact exists.

The right evaluation stack is therefore:

  1. model quality;
  2. tool and context design;
  3. orchestration and recovery;
  4. policy and containment;
  5. verification of the final artifact.

“The model scored higher” is no longer enough information to choose an agent system.

10. Community events

The Clauders event index includes a dense run of meetups and workshops around the reporting window.

This week (Aug 10–15):

Coming next:

Host your own on Luma →

11. What I’m watching

  1. Whether contextual forks improve real completion rates, or mainly make it cheaper to reproduce the parent’s assumptions in parallel.
  2. Whether cross-session messaging gains delivery receipts and stronger provenance, especially across Desktop, Remote Control, and self-hosted runners.
  3. Whether teams separate exploration agents from validation agents, instead of asking the same context and model to grade its own work.
  4. Whether the Riemann result survives broader mathematical review and whether its workflow becomes reproducible outside Anthropic’s research environment.
  5. Whether disabling todo tools on newer models simplifies agent behavior or breaks durable task-tracking workflows.
  6. Whether enterprise compliance teams publish clear employee-facing retention policies before local Claude Code transcripts become routine audit data.
  7. Whether harness evaluations start measuring recovery, delivery, containment, and accepted artifacts—not just benchmark completion.