Blog • AI / Agent

Anthropic’s Latest Disclosure: Claude Now Leads 26% of AI R&D. How Do Agents Collaborate on Model Development? JSON Data Flow and Agent Workflows Explained

On 17 September 2026, Anthropic published a set of internal measurements in an Institute post. The headline is easy to read as: Claude already handles a quarter of model R&D.

The source is narrower. As of August 2026, Claude “leads” 26% of Anthropic’s AI R&D; the share at “collaborates” or above is over 90%; and on no measured subset is the work fully autonomous.

This article covers:

• Which Epoch AI automation level the 26% actually names
• How the task tree grows out of Slack and work records
• How agents collaborate on model development instead of chatting in isolation
• The JSON data flow of identity, messages, Tool Calling, and monitor decisions
• How to split one auditable workflow record locally in JSONNote

What the 26% actually measures

The source is Anthropic Institute’s Measurements for understanding the pace of AI development inside frontier labs. They published three numbers at once: how much AI R&D is done by AI, how tightly agent actions are overseen, and how compute is split.

The first is the Anthropic R&D Automation Index. Catalogue every kind of AI R&D work, rate how automated each kind is, then roll the ratings up with person-time weights.

As of August 2026, the public figures are:

Reuters wrote the same figures as Claude leading a quarter of the work building the next models. The headline is hotter. The definition is not: leading is still a high-level prompt plus human supervision. On the chart, this band rose from under 1% in February 2026. The climb is fast. No step was skipped.

Automation levels: assist, collaborate, lead, autonomous

The ratings use Epoch AI’s Automation Level. Anthropic writes six bands: no AI, minimal, assists, collaborates, leads, autonomous. A footnote pins the middle three with a broken nightly data pipeline:

The 26% stops at AL4. Claude can take a “fix the pipeline” job from alert to write-up, but deploy still sits with a human. That matches everyday coding agents: the model emits Tool Calling, the harness executes, the human keeps a veto on the gate and on high-risk actions. For how the loop turns, see How Do AI Coding Agents Work?. For who owns the hop from JSON to side effects, see Agent Harness architecture through JSON Tool Calling.

The task tree: how 15,000 pieces of work become one index

Nobody can hand-write every R&D action at a frontier lab. Anthropic collected bottom-up: each week in July 2026 they sampled 20% of staff in model-R&D departments, and a Claude research agent read Slack and internal docs to list what those people did that week. Four weeks produced about 15,000 granular tasks.

Claude then folded the list into a tree: all model R&D at the root, then training, product, pretraining, reinforcement learning, down to leaves. The frozen tree has 542 nodes, 378 of them leaves such as eval-platform defect diagnosis, RL sandbox egress and network policy, and serving-incident postmortems.

For each node a Claude agent digs in: who does it, with which tools, how much AI performs. An independent Claude judge, allowed to see only that month’s evidence or earlier, assigns AL0–AL5. Weights are not a leadership guess. They are person-time: one vote per person per week, split evenly across the tasks they touched that week.

They also wrote the limits. Exact agreement between the judge model and humans was 59%; humans agreed with each other only 35% of the time. In 97% of cases the model and a human were within one level. The border between “collaborates” and “leads” will still be argued. Once the basket is frozen, a rising index only says the July 2026 work is being automated. It does not, by itself, prove humans have not moved onto brand-new jobs. They compared a January basket and saw no rise in novel tasks, and still plan to rebuild periodically.

{
  "index": "anthropic-rd-automation",
  "as_of": "2026-08",
  "node": {
    "id": "rl-sandbox-egress-policy",
    "leaf": "RL sandbox egress and network policy",
    "automation_level": 4,
    "label": "leads",
    "weight_person_weeks": 12.4,
    "human_gate": ["deploy", "policy_change"]
  },
  "aggregate": {
    "leads_share": 0.26,
    "collaborates_or_above": 0.90,
    "autonomous_share": 0.0
  }
}

Fields that parse, an enum for the level, and a numeric weight are what let the index be recomputed monthly. A prose weekly report cannot do that.

How agents collaborate on model development

The 26% is not one super-Claude sitting in the middle writing the whole training stack. The public description looks more like an orchestration map: a human sets a goal, several agents run semi-autonomously for long stretches, and they delegate work to other agents.

1. 1
   Sample and catalogue

   A research agent reads work records and writes the week’s tasks as items you can roll up. Without this step the later levels have no denominator.

2. 2
   Branch and delegate

   Training, eval, infrastructure, and incident write-ups are split. One agent can keep digging, or hand a subtask to another agent with its own identity.

3. 3
   Execute and write back

   Read logs, edit code, run tests, compare against a last-good run. Results return to the session—not just a line that says “fixed.”

4. 4
   Correct each other

   Messages travel an open channel and link back to original material. Another agent treats a peer’s words as a claim to verify, not as a thought of its own.

5. 5
   Human gate

   AL4 stops before deploy. AL3 stops earlier: a surprise hands the work back. If the gate fails, irreversible actions should not happen on disk or in the cluster.

This is not the same product layer as “one assistant in a chat box.” It is closer to an in-lab agent runtime: durable identity, traceable messages, monitored tools. For how the stack is layered, see the 2026 AI Agent stack.

JSON data flow: identity, messages, tools, gates

The appendix is specific about two designs in the internal scaffold. They are why 30,000 agents can still be audited.

Identity. Users are used to talking to one object called Claude. When many agents collaborate, each needs its own identity, and the data it creates stays tied to that identity. The identity is not welded to one model version, so the record survives upgrades. For oversight: every action can be traced per agent over time, and every record can point back to a specific actor.

Open communication. Agents do not chat in private. Every message carries the sender’s identity and can link to an original reference, which cuts telephone-game drift. Other agents can see the traffic, so they can correct and coordinate. Messages are cross-referenced with transcripts, so behavioral monitoring can walk the conversation between agents.

Stack those two on everyday Tool Calling and an auditable record looks roughly like this:

{
  "agent_id": "agt_4c91",
  "model_ref": "claude-internal",
  "identity_persists_across_models": true,
  "action": {
    "type": "tool_call",
    "name": "apply_patch",
    "arguments": "{\"path\":\"pipelines/nightly_etl.py\",\"intent\":\"fix_schema_drift\"}"
  },
  "message": {
    "channel": "open",
    "from": "agt_4c91",
    "links": ["transcript://run-8821#step-17"],
    "treat_as": "claim_to_verify"
  },
  "monitor": {
    "online": { "coverage": 1.0, "decision": "allow", "latency_s": 1.8 },
    "offline": { "ingested": true, "flagged": false }
  },
  "human_gate": { "required_for": ["deploy"], "status": "pending" }
}

arguments is still often a string. The business layer parses first, validates against a schema, then hands the object to monitors and permissions. For how to write the contract, see Why Does AI Need JSON Schema?. For who owns safety after the tool surface grows, see MCP Security Vulnerabilities Explained.

Without this JSON layer, monitors can only read prose. 30,000 concurrent agents and a billion decisions cannot be aggregated by identity in prose, and you cannot answer “who is leading which leaf task.”

30,000 agents: who is watching

In August 2026, about 30,000 agents were doing research and engineering at once on Anthropic’s most-used internal platform. The measurements cover that platform only. Actions sit behind two kinds of monitor:

A low block rate does not make the gate optional. Coverage is 100%. Blocks are the exception. Without the pre-execution hop, AL4 “leads” slides into unattended deploy. For how JSON becomes a security boundary, see When AI Agents Start Attacking the Internet.

The compute ledger: what a 6% safety share means

The third set is a compute snapshot from 13–20 July 2026. About 6% of compute that went to AI R&D was counted as safety; about 12% of compute that went to AI-driven AI R&D was. The sort is deliberately conservative: a token that advances capability as much as safety is not counted as safety.

Anthropic warns that safety research is usually more person-time-heavy and less chip-heavy than frontier training, so a compute share is not a sufficient statistic for “how much the company cares about safety.” Its value is comparability—across labs and over time, in the same buckets.

The classification is itself an agent workflow: a classifier reads job metadata, code, and session transcripts, and returns a bucket, a justification, and a confidence. They sampled about 14% of that week’s nearly 10,000 runs, weighted by compute. Boundaries live in the prompt; human review and the machine differed by one or two percentage points. To reproduce it, write “what counts as safety work” as a validatable JSON definition, not a slogan.

Split a workflow record in JSONNote

You will not get Anthropic’s internal tree. You will get the same kind of material in your own repo: tool calls, monitor logs, agent messages, task ratings. All of that can be split locally in the browser.

1. 1
   First check whether arguments can parse

   Unescape the string and drop it into JSON Format. Missing commas and trailing commas are already broken before a monitor ever runs.

2. 2
   Validate the action against the declared schema

   Put the tool’s parameters and the parsed object into JSON Schema. The level must be an enum, the identity a stable ID, and deploy must stay explicit on human_gate.

3. 3
   Diff “what you approved” against “what it is now”

   Drop last week’s task tree or tool list into JSON Diff and look specifically for silent edits to leaf tasks, monitor decisions, and schemas.

4. 4
   Need a colleague to see it? Use hash share

   The data stays in the URL fragment and never hits the server. See Share JSON with a URL Hash.

FAQ

If Claude leads 26% of AI R&D, is it already building the next model unattended?

No. 26% is Epoch AI’s AL4: Claude can finish most of a task from a high-level prompt, while a human supervises and decides whether it ships. Anthropic states that Claude is not fully autonomous on any measured subset of AI R&D.

How do “over 90% collaborates” and “26% leads” fit together?

90% is AL3 or above: Claude can do large chunks under close human direction. 26% is the share of that work that has already moved to AL4. Leading sits inside “collaborates or above.” They are not two exclusive piles.

How do 30,000 agents collaborate, and who watches them?

They run research and engineering semi-autonomously on an internal platform and can delegate to one another. Each agent has its own identity; messages go over an open channel. 100% of actions pass an online monitor before execution and an offline monitor afterward. In August 2026, about 1 in 47,000 of more than a billion decisions was blocked.

Where does JSON show up in this workflow?

Task-tree nodes, automation ratings, agent identities, open messages, Tool Calling arguments, and monitor allow/block decisions are almost all structured records. Without a parseable contract you cannot audit 30,000 agents, or replay who led which slice of work.

What should a developer take from this disclosure?

Separate assist, collaborate, lead, and autonomous. Leave identity, time, and validatable JSON on every tool call and every agent message. Put the gate before execution; keep the replay material after. The percentages will move. The contract layer will not go stale.

Conclusion

Anthropic put 26%, 90%, 30,000, 0.002%, and 6% on the table because those numbers can be measured, checked, and recomputed monthly. They do not measure “how well the model chats.” They measure where humans and agents stand on the production line that builds the next model.

26% is leading, not autonomy. Collaboration is already widespread. The gate is still human. Agents can build models together because identity, open messages, Tool Calling, and monitor decisions share one parseable data flow.

Headlines will keep reading 26% large. Anyone who reads the source should look at the level definitions first, then check whether that JSON is still there.

← Back to the blog