🤖 AI

Swarm Skills: A Portable, Self-Evolving Multi-Agent System Specification for Coordination Engineering

This paper introduces Swarm Skills, a portable specification and self-evolution algorithm that transforms multi-agent coordination protocols into distributable, first-class assets, enabling agent teams to autonomously refine their collaborative strategies across different frameworks without human oversight.

Original authors: Xinyu Zhang, Zhicheng Dou, Deyang Li, Jianjun Tao, Shuo Cheng, Ruifeng Shi, Fangchao Liu, Enrui Hu, Yangkai Ding, Hongbo Wang, Qi Ye, Xuefeng Jin, Zhangchun Zhao

Published 2026-05-12

📖 4 min read☕ Coffee break read

CC BY 4.0

Original authors: Xinyu Zhang, Zhicheng Dou, Deyang Li, Jianjun Tao, Shuo Cheng, Ruifeng Shi, Fangchao Liu, Enrui Hu, Yangkai Ding, Hongbo Wang, Qi Ye, Xuefeng Jin, Zhangchun Zhao

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you have a team of expert robots. In the past, if you wanted them to work together, you had to write a specific set of instructions for that exact moment. Once the job was done, those instructions were thrown away. If you wanted to do a similar job next time, you had to start from scratch, forgetting everything you learned about how they argued, who made mistakes, or how they solved problems.

This paper introduces a new way to build robot teams called Swarm Skills. Think of it as turning a one-time team meeting into a living, breathing playbook that gets smarter every time it's used.

Here is a breakdown of the idea using simple analogies:

1. The Problem: The "Disposable Team"

Currently, most AI teams are like pop-up bands. They form for one concert, play a song, and then break up. The way they coordinated—who sang lead, who played guitar, how they fixed a broken string—is locked inside the specific computer program that ran them. You can't take that "band dynamic" and give it to a different computer, and the band doesn't remember how to play better next time.

2. The Solution: The "Portable Playbook" (Swarm Skills)

The authors propose Swarm Skills, which is like turning that pop-up band into a traveling theater troupe with a permanent script.

It's Portable: The "script" (the rules for how the team works) is saved in a simple folder (like a digital file). You can copy this folder to any computer that speaks "AI," and the team can work there immediately. No need to rewrite the code for every new machine.
It's a Playbook: Instead of just saying "Do this," the playbook defines:
- The Roles: Who is the Chef? Who is the Waiter? Who is the Manager?
- The Workflow: How do they pass the plate? Who checks the bill?
- The Boundaries: What happens if they run out of time or money?

3. The Magic: The "Self-Improving Coach" (Self-Evolution)

This is the most exciting part. Usually, if a team makes a mistake, a human has to step in and fix the instructions. Swarm Skills has a built-in Coach that watches the team work and automatically updates the playbook.

The "Friction" Detector: If the Chef and the Waiter keep bumping into each other in the kitchen, the Coach notices this "friction."
The "Patch": The Coach writes a new note in the playbook: "Next time, the Waiter should wait for the Chef to finish plating before entering the kitchen."
The Scorecard: The system keeps track of these notes using a scorecard with three stats:
- Effectiveness: Did this fix actually help?
- Utilization: Do the robots actually use this new rule?
- Freshness: Is this rule still relevant, or is it old news?
The Cleanup: If a rule stops working or gets too complicated, the system automatically deletes it or simplifies it. It doesn't need a human to say, "Okay, delete that." It just does it.

4. A Real-World Example: The Family Vacation Planner

The paper tested this with a team planning a family trip to Northeast China.

The Team: They had a Travel Agent, a Hotel Booker, an Activity Planner, a Budget Manager, and a Social Media Writer.
The Conflict: The Travel Agent booked a cheap flight that arrived late at night. The Activity Planner had already scheduled a morning tour. They realized this was impossible.
The Resolution: Instead of waiting for a human to fix it, the two robots talked to each other, realized the conflict, and agreed to change the flight to a morning one.
The Evolution: After the trip, the "Coach" noticed that the Budget Manager was doing two very different jobs: crunching numbers and writing fun social media posts. The Coach decided this was confusing. It automatically split the team, adding a new "Copywriter" role and updating the playbook so the next time they plan a trip, they have a dedicated writer.

5. Why This Matters

No "Lock-In": You aren't stuck with one specific software brand. Because the playbook is written in plain language (like a recipe), any AI system that can read can use it.
It Gets Better Alone: The more you use the team, the better it gets at working together, without you needing to constantly rewrite the rules.
Shared Wisdom: If you teach a team in New York how to solve a problem, you can copy that playbook to a team in Tokyo, and they start with that same wisdom.

In short: Swarm Skills turns AI teamwork from a "one-time event" into a "growing asset" that learns from its own mistakes and shares those lessons with anyone else who uses it.

Technical Summary: Swarm Skills – A Portable, Self-Evolving Multi-Agent System

1. Problem Statement

The paper identifies a critical bottleneck in the evolution of AI engineering paradigms: the shift from Single-Agent Engineering (Prompt, Context, and Harness Engineering) to Multi-Agent Coordination Engineering. While single-agent capabilities can be codified into portable, distributable assets (e.g., Anthropic Skills), multi-agent coordination protocols remain "locked" within framework-internal code (e.g., hardcoded scripts in AutoGen) or static configurations (e.g., CrewAI templates).

This lack of portability leads to two primary issues:

Ephemeral Coordination Experience: Nuanced decisions regarding task decomposition, role instantiation, and conflict resolution are discarded after a session ends. Systems cannot "remember" or reuse successful collaboration patterns.
Framework Lock-in: Protocols are tightly coupled to specific execution environments, preventing sharing across different multi-agent systems and inhibiting autonomous self-improvement.

The authors argue that Coordination Evolution—the continuous improvement of collaboration patterns—is the next frontier, but it is currently hindered by the absence of a standardized, portable format for multi-agent skills.

2. Methodology

2.1 The Swarm Skills Specification

The core contribution is Swarm Skills, a portable specification that extends the Anthropic Skills standard with multi-agent semantics. It treats multi-agent workflows as first-class, distributable assets decoupled from the runtime environment.

Key Architectural Features:

Five-Component Structure: A Swarm Skill is a directory containing:
1. Frontmatter (SKILL.md): YAML metadata for mechanical consumption (e.g., kind: swarm-skill, teammate mode, roles[]).
2. Natural Language Body: High-level workflow descriptions for agentic consumption.
3. Roles Directory: Detailed persona definitions for each team member.
4. Workflow Definition: Task dependency graphs (sequential, parallel, fan-out/in) described in natural language or Mermaid syntax.
5. Execution Bounds (bind.md): Constraints on tokens, message turns, and quality gates.
Progressive Disclosure: Host Agents load only necessary metadata initially, fetching detailed instructions (roles, workflows) on demand via native file-reading capabilities.
Graceful Degradation: Because the specification extends an existing standard (Anthropic Skills) and uses additionalProperties: true, single-agent frameworks that do not support multi-agent execution can ignore the multi-agent fields and treat the asset as a standard single-agent skill, ensuring backward compatibility.

2.2 Embedded Self-Evolving Semantics

The specification mandates an evolutions.json file to capture "Evolution Experience." This file stores discrete Evolution Records containing:

Context: Description of friction encountered (e.g., role conflicts, redundant loops).
Change Directive: Targeted modifications to the asset (e.g., inserting a new phase, splitting a role).
Scoring Metrics: Effectiveness ( $E$ ), Utilization ( $U$ ), and Freshness ( $F$ ).

2.3 Companion Self-Evolution Algorithm

To operationalize the specification, the authors propose an automated algorithm (implemented in the open-source JiuwenSwarm reference agent) that manages the skill lifecycle through three stages:

CREATE (Trajectory Distillation): Monitors complex multi-agent interactions, identifies collaboration signals (e.g., $\ge$ 2 sub-agents), and synthesizes raw execution trajectories into candidate Swarm Skills.
USE (Progressive Disclosure): Host Agents retrieve skill descriptions, inject them into the Leader agent's prompt, and incrementally load detailed instructions and historical Evolution Records.
PATCH (Friction-Driven Optimization): Post-execution, an analyzer scans for implicit friction (circular dependencies) or explicit feedback. It generates new Evolution Records and appends them to evolutions.json.

Governance & Scoring:
To prevent prompt bloat and low-quality accumulation, the algorithm employs a multi-dimensional scoring system:
$S_i = w_E \cdot E + w_U \cdot U + w_F \cdot F$

Effectiveness ( $E$ ): Qualitative impact (Bayesian smoothed).
Utilization ( $U$ ): Adoption rate (decays if ignored).
Freshness ( $F$ ): Time-decay factor.

Based on scores, the system triggers governance actions: SIMPLIFY (pruning/merging), REBUILD (rewriting core files to integrate successful patches), or ROLLBACK (reverting to archived states).

3. Key Contributions

The Swarm Skills Specification: The first multi-agent extension to the Anthropic Skills standard, defining a five-component asset structure with built-in semantics for self-evolution.
A Companion Self-Evolution Algorithm: An automated mechanism that distills execution trajectories into new skills and continuously optimizes existing ones via multi-dimensional scoring, eliminating the need for human-in-the-loop oversight during refinement.
Architectural Compatibility & Qualitative Validation: A demonstration of zero-adapter cross-agent portability via progressive disclosure and a qualitative case study using a 6-role travel planning team.

4. Results and Case Study

The paper validates the specification through a qualitative case study involving a travel-planning-swarm skill (involving Transportation, Accommodation, Attraction, Synthesizer, and Budget Reviewer roles).

Autonomous Conflict Resolution: During execution, the Transportation and Attraction experts identified a temporal conflict (evening flight vs. afternoon itinerary). They autonomously negotiated a solution (switching to a morning flight) without human intervention, adhering to budget and infant-travel constraints.
Self-Evolution in Action: Post-execution analysis revealed a "role friction" where the Budget Reviewer was overloaded with both financial auditing and creative copywriting. The algorithm generated an Evolution Record suggesting a structural split. Upon user confirmation, the system executed a REBUILD, creating a new "Copywriting Expert" role and updating the workflow to run in parallel.
Outcome: The case study demonstrates that Swarm Skills enable agent teams to self-evolve their coordination strategies, accumulating experience across sessions and improving efficiency without framework lock-in.

5. Significance and Claims

The paper positions Swarm Skills as a foundational step toward Coordination Engineering. Its significance lies in:

Sedimentation of Coordination Experience: Transforming ephemeral runtime states into persistent, distributable assets that allow multi-agent systems to learn from past interactions.
Decoupling Specification from Runtime: By separating the "what" (coordination logic) from the "how" (execution mechanics), the specification enables true portability across heterogeneous frameworks (e.g., AutoGen, LangGraph, CrewAI) without translation layers.
Autonomous Improvement: The system moves beyond static configurations to dynamic, self-correcting protocols that evolve based on real-world friction and performance metrics.

Limitations and Future Work:
The authors modestly acknowledge that the work currently lacks large-scale, quantitative conformance testing across diverse Host Agents. The effectiveness of the "progressive disclosure" mechanism on frameworks lacking native recursive file reading or dynamic sub-agent spawning remains to be empirically evaluated. Additionally, the paper notes the challenge of "first-run lock-in" (where a suboptimal initial workflow becomes heavily patched rather than restructured) as a target for future governance mechanisms.