Claude's own team searched Bug! 116,000 lines of code and found 66 of them.

  It's the first time in the history of the world.

One of the best single agents ever, he found 27 bugs.

In exchange for his own team, Claude ran three times, scoring 66 points each time.

This is the result of a set of tests recently released by Anthropic: 70 bugs were pre-buried in 116,000 lines of code, allowing a single agent and a dynamic workflow to run three times each.

As a result, fighting alone, it is best not to score 40 percent; and teamwork, three times more than 90 percent.

The result was that Claude started organizing his own division of labor, organizing multiple agent collaborations.

On October 10, Claude Managed Agents dynamic workflow opened for publicity.

With this functionality, the master agent can write a sub-process on its own after receiving the task, arrange the other agents to complete the task in phases, and finally summarize the results.

On the same day, Claude Code Projects expanded its disclosure scope: all Pro and Max users who were previously on the waiting list are now eligible.

In Projects, you can constantly make demands around a project, and Claude is responsible for dismantling tasks, coordinating multiple threads to move forward in parallel.

One allows developers to integrate multi-agent collaboration into their applications, and one allows users to interact directly in project conversations and keep up with progress.

Two updates point to the same change: In addition to performing tasks, splitting, moving forward, and communicating results, which would have required people to manipulate, Claude began to take over.

It's easy to open multiple AI windows at the same time.

The problem is to tell the background to each window, send the findings to the other, and then ask: where did it come from, where is the card, what's missing?

There are more and more windows, and people are more and more busy as preachers.

Projects wants to take this next step.

You keep making demands in the same project conversation, and Claude decides whether to start a new task thread or give it to a thread that is already working on the relevant work.

Each thread can be understood as a separate work-to-task dialogue.

Projects coordinate dialogue and mission overview

Anthropic gives an example: let's shut down old interfaces with APIs, web and mobile devices.

The case involves multiple code repositories, and all modifications must be coordinated.

Claude can undo tasks by code warehouse, modify, run tests, submit a code merger request, and then tell you which changes need to be merged first.

Each cloud thread has its own context and code copy, works on its own branch, and reports the results back to the project conversation.

You can still access a thread to see the details, correct directions. The project overview lists the tasks that are being worked on, waiting for you to answer, and can be reviewed.

If you leave for a while and come back, you don't have to go to a window to ask for progress, you can call directly from where you need to deal.

In order to save time for repeated communication, it is necessary to remember what has been exchanged before.

Projects accumulate project memories.

What needs have changed, what decisions have been made, where the crater has been stepped, can be recorded for subsequent cloud threads to be read.

Officials cited a day-to-day work scenario: the release date has been changed to Friday, why a feature has been cut, who needs to be confirmed before modifying a service, and this information can be stored in the project's memory.

The database also preserves uploaded material and documents generated by Claude, so that subsequent tasks can be carried out after the results have been achieved.

The needs are allocated to the right-hand thread, and the relevant decisions and work results are gradually accumulated and used for subsequent tasks.

The new version of Projects was launched on 17 September.

The expansion is accessible, and the functionality itself is still in the disclosure phase, with unregistered users still eligible to join the waiting list.

Cloud threads can continue to work after connecting to a computer. Tasks that require native tools or local databases can also run on the computer via Remote Control, but the computer must remain awake.

After coordinating a project, how do we divide the work within a complex task?

Managed Agents is a dynamic workflow that deals with these kinds of issues.

Officials give an example of a specific task:

Examine 300 contracts to find out which contain the terms of the change of control, i.e. the agreement on how to deal with the change of control of the company.

It's a lot of work to read each and every one of them, and to make sure that every one of them is checked, that the conclusions are verifiable, and that the missing ones can be checked in time.

Claude writes a workflow procedure for the task, arranging which agents read the material, which steps process the results, and how to proceed.

Contract reading tasks run in parallel and then into verification and consolidation

Both distribution and communication are written into the program and can be run directly.

An agent reads the material and delivers the result to the program. The program then passes the result to the next agent, or decides which branch to go to next.

The work that needs to be repeatedly modified can also be put into a circular arrangement.

An example of an official document is a manuscript review: continuous revision until the audit is passed, or the predefined number of rounds is reached.

In a normal sub-agent assignment, the master agent reads the report and then decides the next step. The dynamic workflow then writes a large number of intermediate interfaces into the program and advances them in the background.

During the waiting period, the master agent can still communicate with the user, see the progress. After the run, read the results, reply to the user or start the next round of work.

However, after a thread in the workflow returns the result, the master agent cannot continue to query the same thread as a common subagent. Therefore, it is best to check and return to the process in advance.

A sample of the official contract review directive states:

In the first round, each contract is assigned to one agent; in the second round, all contracts are re-examined by another agent, even the first round without finding the target terms cannot be skipped; the review is not passed, and after returning to work, it is re-examined again.

This gives the first round missed clause a chance to be discovered.

Of course, contract cases show how the work is done.

Anthropic did not disclose any specific assignments in the group's bug test posts, which cannot be confirmed, and the 66 bugs were also discovered through the same process.

A maximum of 1,000 Agents at a time is one of the most striking figures to date.

It refers to a single workflow during the entire run, cumulatively starting up to 1000 Agents.

The current document lists the maximum number of simultaneous working threads of 64, and the official indicates that this concurrent number may be adjusted.

The workflow can be carried out in batches, or it can wait for the first stage to return the results, and then arrange for the next stage.

Each Agent has an independent conversation history, while sharing the documents and sandboxes of the session, i.e. the working environment for running the code and processing the materials.

Developers can configure dedicated Agents in advance or have workflows provisionally defined according to tasks.

When logged in, type is set to multiagent_20261001 in the multiagent configuration, then configure the model, tool, and task requirements.

Once the dynamic workflow is enabled, the task is shifted to Claude, who can then write a work breakdown plan. The example in the diagram is to filter the control change clauses in 300 contracts.

However, it is not enough to divide the work, and it is still necessary to replace the unfinished work.

An official instruction sample requested that an agent who could not read the contract list the contract as "uncovered" and continue the rest of the task.

"Not finding the problem" and "not finding it at all" must be separated. Otherwise, a well-rounded summary can easily hide the gaps in the task.

Developers can view the recording of the running stages and threads, along with the recording of the positioning issues.

As an example of contract scrutiny, developers can track the reading, checking, etc. phases and view the execution records of each task thread.

In addition, the Agency has to arrange the order of execution to see which tasks have been completed and which are still missing.

A distinction is made: when you start up to 1,000 Agents, you see 66 Bugs three times, and it's managed Agents dynamic workflow, not Projects.

Back to the beginning of the test: A single agent detected 14, 15, 27 bugs three times, and a dynamic workflow of 66 bugs three times.

More bugs were detected, but it is not clear how much time and expense it took to do so.

Officials did not disclose the model used, the actual number of Agents, the amount of time consumed, Token usage and misreporting, and it is not yet possible to determine whether the workflow is faster or more economical.

The cost of the two functions should also be considered separately when used in practice.

Projects use existing set limits, working threads, and coordinated conversations to consume the amount. The more parallel tasks, the faster the amount will be used.

Users can adjust the model and reasoning intensity, or allow Claude to minimize some of the threads. Typically, the working thread will be suspended after the package volume limit is reached, so the quantity reset will continue.

Managed Agents are charged $0.08 per hour for each session, which only counts when the session is running.

The $0.08 is just a running fee, and the tokens used by multiple agents to read the material and generate answers are also calculated.

Developers can set a session budget, which includes the consumption of workflow models. Running is suspended after reaching the budget, but model requests that have been issued will still be completed, and the final cost may exceed the budget.

The meeting budget covers the consumption of models in dynamic workflows, making it easy to control spending on multi-agent collaborations.

Therefore, the official recommendation is to start with a clear-cut task to clean up the consumption and gradually increase the complexity.

If you have more agents, it's not automatically cheaper.

How many real problems to find, how many models to call for, and how much time it takes to review and correct, all have to be counted on the same bill.

Less time is spent working, and if more completion work is done in return, the project will not end sooner.

These two updates allowed Claude to take on more organizational responsibilities: user exchange goals, budgets, and acceptance standards, with Claude in charge of division, promotion, and communication.

The next test was: after the live partition, Claude couldn't be less disturbing, returning the results of the checks he had made.