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

Abstract: As artificial intelligence engineering paradigms shift from single-agent Prompt and Context Engineering toward multi-agent \textbf{Coordination Engineering}, the ability to codify and systematically improve how multiple agents collaborate has emerged as a critical bottleneck. While single-agent skills can now be distributed as portable assets, multi-agent coordination protocols remain locked within framework-internal code or static configurations, preventing them from being shared across systems or autonomously improved over time. We propose \textbf{Swarm Skills}, a portable specification that extends the Anthropic Skills standard with multi-agent semantics. Swarm Skills turns multi-agent workflows into first-class, distributable assets that consist of roles, workflows, execution bounds, and a built-in semantic structure for self-evolution. To operationalize the specification's evolving nature, we present a companion self-evolution algorithm that automatically distills successful execution trajectories into new Swarm Skills and continuously patches existing ones based on multi-dimensional scoring (Effectiveness, Utilization, and Freshness), eliminating the need for human-in-the-loop oversight during the refinement process. Through an architectural compatibility analysis and a comprehensive qualitative case study using the open-source JiuwenSwarm reference implementation, we demonstrate how Swarm Skills achieves zero-adapter cross-agent portability via progressive disclosure, enabling agent teams to self-evolve their coordination strategies without framework lock-in.

• The paper presents a novel standard that decouples coordination logic from execution, enabling portable and reusable multi-agent workflows.
• The paper details a three-stage self-evolution algorithm (CREATE, USE, PATCH) that autonomously adapts coordination protocols by analyzing execution friction and improvement metrics.
• The paper demonstrates the practical value of Swarm Skills through a travel planning case study, highlighting its potential for scalable and continuous coordination optimization.

Swarm Skills: Specification and Self-Evolving Semantics for Multi-Agent Coordination Engineering

Introduction and Motivation

The transition from single-agent Prompt, Context, and Harness Engineering toward Coordination Engineering in LLM ecosystems has exposed the need for robust, reusable, and self-improving multi-agent coordination mechanisms. Whereas single-agent operational knowledge is now portable and incrementally improvable via standards such as Anthropic Skills, multi-agent coordination expertise remains fragmented, embedded in framework-specific code or configuration artifacts. This impedes cross-framework portability, prevents systematic reuse, and precludes autonomous evolution of collaboration patterns. The "Swarm Skills" specification directly addresses this gap, proposing a universally portable, semantically rich asset standard for multi-agent workflows with natively embedded support for self-evolution. The companion self-evolution algorithm eliminates human-in-the-loop bottlenecks in coordination evolution and exposes a structured mechanism for friction-driven continuous improvement.

Empirical analysis confirms a pronounced user demand for multi-agent skill expressivity, with frequent community-level workarounds that simulate agent teams via single-agent skill files. This demand reinforces the criticality of codifying and distributing coordination logic in a reusable, upgradable format that transcends proprietary platform barriers.

Swarm Skills: Structured Specification

Swarm Skills extends the Anthropic Skills standard with explicit multi-agent semantics, codifying a multi-file asset with five obligatory authored components and an evolutions artifact:

• Frontmatter: A YAML metadata block (in SKILL.md) incorporating discriminators for "swarm-skill" type, agent roles, teammate mode, and compatibility fields.
• Roles Directory: Dedicated markdown files per agent persona with natural-language operational instructions.
• Workflow Definition: workflow.md encapsulates the natural language or Mermaid-specified task graph, including execution order, parallelism, and dependency constraints.
• Execution Bounds: bind.md delineates operational resource caps—such as turn count, token budget, or quality gates.
• Dependency Specification: dependencies.yaml (optional) for runtime toolchain integration.

Critically, the evolutions.json artifact rigorously logs the asset's coordination evolution through a sequence of discrete, context-rich Evolution Records. Each record embeds context, change directives, and structured scoring fields—Effectiveness (E), Utilization (U), and Freshness (F)—enabling downstream agents to filter and prioritize historical experience.

Swarm Skills enforces strict decoupling of coordination logic from execution runtime, eschewing specification of transport, queue, or messaging mechanics. This, combined with progressive disclosure principles, guarantees the asset is natively portable to any Anthropic-compatible Host Agent and accommodates graceful degradation in single-agent runtime contexts.

Autonomous Self-Evolution Algorithm

To operationalize self-evolving semantics, a three-stage lifecycle algorithm (CREATE, USE, PATCH) is proposed:

• CREATE: Monitors agent execution trajectories, distills emergent collaboration patterns into candidate Swarm Skills, and synthesizes initial asset files.
• USE: Executes progressive disclosure, dynamically routing workflow and roles to Leader/Teammate agents, and incrementally applies relevant evolution records.
• PATCH: Analyzes execution traces for implicit friction (e.g., redundant communication, role overlap) or explicit improvement proposals, autonomously generating and appending new Evolution Records.

The algorithm curates the evolution experience with a composite scoring function:

$S = w_E E + w_U U + w_F F$

where scores drive automated culling and context prioritization. Governance routines (SIMPLIFY, REBUILD, ROLLBACK) ensure asset integrity, collapse prompt bloat, enable lock-in remediation, and provide structured rollback pathways.

Notably, all operations comply strictly with the Swarm Skills schema, requiring no in-framework code branching, and thus preserve maximal deployment portability across existing and future multi-agent runtimes.

Case Study: Travel Planning Swarm

A qualitative deployment using a 6-role travel-planning Swarm Skill in the open-source JiuwenSwarm reference agent concretely demonstrates the specification's semantics and the autonomous evolution cycle.

The workflow operationalizes concurrent, role-specialized experts (transport, accommodation, attraction, planning, budget, copywriting) under a Leader. Role friction emerges in runtime—a coupled budget/copywriting responsibility causing context switching latency—triggering the self-evolution algorithm to propose, score, and (upon user review) execute a structural split and workflow update. The algorithm further distills nuanced behavioral patterns (e.g., tradeoff negotiation reflecting infant travel constraints) as role-specific patches.

This process illustrates three fundamental properties:

• Swarm Skills assets are self-toning, with team structure and protocol improving through repeated deployment.
• Evolutionary history of coordination is natively portable between host agents.
• Role and workflow specializations are selectively elaborated—never locked into initial design artifacts.

Architectural Implications and Limitations

Swarm Skills delivers zero-adapter deployment via exclusive reliance on natural language and universally accepted metadata conventions (YAML, Markdown, Mermaid). Non-supporting host runtimes degrade gracefully, preserving backward compatibility for all LLM agent platforms adhering to Anthropic Skills standards.

The absence of large-scale, quantitative conformance testing and benchmarking on multiple commercial frameworks remains a limitation. Quality metrics for evolved coordination, and optimal governance in "first-run lock-in" scenarios, require further formalization and empirical study. The specification strategically abstains from overspecification (e.g., message-passing details) to maximize forward compatibility but leaves aspects like routing, error recovery, and agent isolation to future community consensus.

Implications and Future Directions

Swarm Skills sets a new technical precedent for experience sedimentation in multi-agent LLM ecosystems by abstracting coordination into a distributable, framework-agnostic, continuously improving knowledge asset. This directly fosters cross-ecosystem transfer and cumulative advancement in coordination engineering. Practically, Swarm Skills enables agent teams to adapt their protocols autonomously, reducing the need for continuous human operator intervention in coordination optimization.

Future evolution will likely explore automated detection of foundational workflow flaws, standardized benchmarks for coordination efficacy, and integration with more sophisticated governance or meta-learning architectures. Broader Coordination Engineering remains ripe for study, including protocol fault tolerance, agent isolation, and optimal message routing.

Conclusion

The Swarm Skills specification and its self-evolution algorithm fundamentally decouple and uplift multi-agent coordination from monolithic, ephemeral runtime constructs to durable, portable, and self-improving assets. This work provides a portable, systematically evolvable substrate for Coordination Engineering, with broad implications for the scalability and continual refinement of multi-agent LLM systems. As agent ecosystems grow in complexity and diversity, such standards will be indispensable for maintaining and auditing the dynamic collective intelligence of autonomous agent teams (2605.10052).