Core Summary
The recently released GraphWorkflow by the Swarms team has improved the scheduling efficiency of multi-Agent tasks. However, the true value of this paper lies not in the mere figure of a 62.5% acceleration. It reveals a crucial insight: multi-Agent systems (commonly referred to as “swarms”) have moved from a focus on the intelligence of individual models to an emphasis on the effectiveness of their organizational collaboration. The key is not just having as many Agents as possible, but rather finding ways to ensure that these intelligent agents do not waste time on each other, avoid collective mistakes, and can consistently deliver tasks.
1. Don’t Be Misled by the Term “Swarm”: It’s More Than Just a Group of Agents
Many products claim to use a “swarm” when multiple Agents are working together, but in a strict sense, a true swarm is one where there is no central control, and each agent acts based on local information, leading to collective behavior (similar to how ants find their way). The multi-Agent systems currently in use are more akin to “temporary project teams”:
- Single Agent: Like a skilled employee working alone, suitable for linear, short tasks (e.g., writing an email).
- Supervisor/Worker: A project manager leading several assistants (e.g., Anthropic’s system, where the main Agent assigns tasks and sub-Agents gather information).
- Graph Workflow: A fixed-process pipeline (e.g., compliance reviews, batch testing); both GraphWorkflow and LangGraph fall into this category.
- Dynamic Swarm: Agents can decide on their own whether to split tasks and which teammates to collaborate with during execution (e.g., Kimi Agent Swarm can dynamically coordinate 300 sub-Agents).
- Fully Decentralized Swarm: Still in the experimental phase (e.g., simulating bird flock behavior).
At heart, the issue with swarms is organizational: how to enable multiple agents to work together through division of labor, communication, and shared information to accomplish tasks that a single agent cannot handle on its own.
2. Why Use Multiple Agents? Tasks That Can’t Be Solved by a Single Agent
Models are becoming increasingly intelligent, but some tasks cannot be solved simply by giving them more time:
- Broad Scope of Work: For example, identifying corroborating facts from 100 reports; a single agent would have to review each one, which can be time-consuming. Multiple agents can search in different directions simultaneously.
- Limited Linear Thinking: A single agent might focus on one approach and ignore other possibilities; multiple agents can explore multiple paths simultaneously (e.g., some gather public information, others check original documents, and some provide counter-evidence).
Anthropic’s example illustrates this well: using a main Agent to coordinate tasks with sub-Agents yields 90% better results than using the strongest model alone, but the cost in tokens (i.e., resources) is 15 times higher. This approach is not suitable for all tasks; for example, in programming, there may be few parts that can be parallelized, and using multiple agents could increase communication overhead.
3. Behind the Speed Improvement: Organizational Factors Start to Impact Computing Power
The speed improvement in GraphWorkflow comes from optimizing task scheduling. By compiling the fixed task flowcharts in advance and executing them repeatedly, the time spent on coordinating who waits for whom and who delivers results is reduced. However, this study only measured the scheduling overhead of static tasks on a single machine and did not assess the speed of the models themselves (model calls take several milliseconds, so the optimization’s impact is minimal).
This indicates that when the number of agents exceeds dozens or hundreds, organizational costs become a significant factor. Just like in a company, more agents require time to coordinate their work, determine who does what, and handle errors. This is why discussions about swarms increasingly involve technical terms like “workflows, schedulers, and state merging.”
3. Three Major Challenges in Managing Swarms: Task Division, Task Tracking, and Error Detection
Dividing tasks among multiple agents is a technical challenge:
1. Task Assignment: Which tasks should be split? Who should handle them? When should they be done by the agent itself? For example, SearchSwarm teaches the main Agent to decide whether to delegate tasks, and sub-Agents only send compressed results to avoid wasting context.
2. Task Tracking: It’s not about remembering user preferences, but about maintaining a trail of evidence for each task (e.g., which agent is responsible for what, and from which sources the conclusions come; which assumptions were disproven). If each agent forwards long conversations, the system will be overwhelmed by noise.
3. Error Detection: Multiple agents are not necessarily more reliable; they can also make collective mistakes (e.g., if they all use the same information, they may reinforce biases). Experiments show that systems with central error checking reduce the error rate by 4.4 times, compared to 17.2% in systems without it. In the future, the most valuable role will not be the “worker” but the “verifier” (the quality controller).
4. The Future of Swarms: Temporary “Task Forces,” Not Small Companies
Many demonstrations present swarms as having a structure similar to departments like CEOs, marketing, and product teams, which is misleading. The future trend will be towards temporary, specialized teams:
- When a task arises, assess the risks, budget, and potential for parallelization.
- Create temporary agents for specific tasks and disband them once the task is completed.
- A central entity manages the goals and budget, while local units are allowed to explore dynamically, with verifiers ensuring everything stays on track.
For example, WebSwarm’s recursive swarm structure allows agents to decide on the best approach during execution, with the organizational structure evolving as the task progresses. However, this flexibility comes with risks (e.g., budget overruns and difficulty in tracing errors), so production systems will need to find a balance between freedom and control.
A Reminder for Entrepreneurs
Don’t be obsessed with the number of agents. First, ask whether there are 100 independent paths to explore for the user’s problem. If not, a single agent combined with good tools and a quality assurance mechanism is often more cost-effective and reliable. Swarms are only useful when tasks can be divided, each branch can generate new information, and results can be cross-verified.
Model competitions will continue, but the next round will not focus on which model is the most intelligent, but on who can organize agents into a team that is efficient, well-controlled, and capable of delivering results.
(Note: The research data from 2026 mentioned in the article are from preprints or vendor disclosures and may not represent industry standards; they should be considered with caution.)