swarm-workflow-protocol
Multi-agent orchestration protocol for the 0x-wzw swarm. Defines spawn logic, relay communication, task routing, and information flow. Agents drive decisions; humans spar.
About this skill
The 'swarm-workflow-protocol' serves as an operating system for multi-agent collaboration within an AI swarm, specifically the 0x-wzw swarm, though its principles are broadly applicable. It defines crucial aspects of agent behavior, including spawn logic, inter-agent communication, task routing, and information flow. The core principle emphasizes optimal human-agent collaboration where 'humans spar, agents drive,' eliminating approval bottlenecks and fostering continuous improvement towards full agent autonomy. This protocol provides a structured decision-making process for AI agents to assess tasks. Before undertaking any task, agents are instructed to perform a 'Pre-Task Spawn Analysis' by answering three key questions: task complexity, potential for parallel execution, and token cost-benefit. Based on this analysis, the agent follows a decision matrix to determine whether to handle the task in a main session or to spawn new sub-agents for parallel processing. The skill is designed for AI agents operating in environments where delegating parts of a complex task to sub-agents or collaborating with other agents can lead to more efficient and robust outcomes. It establishes clear guidelines for when multi-agent collaboration is beneficial versus when it introduces unnecessary overhead, ensuring that resources are utilized effectively and human input is leveraged for refining agent decisions rather than dictating them.
Best use case
This skill is primarily for AI agents that need to intelligently manage complex, multi-faceted tasks by deciding whether to break them down and delegate to sub-agents. It benefits agent developers and users who want to implement a structured, autonomous, and efficient approach to multi-agent problem-solving, maximizing parallelism while maintaining high-quality human feedback.
Multi-agent orchestration protocol for the 0x-wzw swarm. Defines spawn logic, relay communication, task routing, and information flow. Agents drive decisions; humans spar.
An AI agent will intelligently and autonomously decide when to engage in multi-agent collaboration, leading to more efficient execution of complex tasks and improved outcomes through structured human feedback.
Practical example
Example input
Please develop a comprehensive software architecture for a new real-time analytics platform, including data ingestion, processing, storage, and visualization components.
Example output
Pre-Task Spawn Analysis: Q1: Complexity? Ultra-complex, involves distinct architectural layers. Q2: Parallel Seams? Yes, data ingestion/processing, storage, and visualization can be designed concurrently. Q3: Token Math? Expected output well exceeds spawn cost. Decision: Spawning three sub-agents to concurrently design data ingestion/processing, storage, and visualization components, adhering to the Swarm Workflow Protocol for coordination and human sparring.
When to use this skill
- When an AI agent needs to decide whether to spawn sub-agents for a complex or ultra-complex task.
- To optimize multi-agent collaboration and task routing within a swarm, ensuring efficient resource allocation.
- To establish a clear and productive human-agent interaction model where humans act as 'sparring partners' to refine agent decisions.
- For tasks that have genuinely independent subspaces allowing for parallel execution without serial dependencies.
When not to use this skill
- For simple, one-shot tasks that do not benefit from multi-agent delegation or significant internal processing.
- When tasks have strong serial dependencies, making parallel execution inefficient or impossible.
- If the overhead cost of spawning agents (e.g., token usage) is likely to exceed the efficiency gains.
- In scenarios where human approval is a strict requirement rather than a sparring-based feedback loop.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/swarm-workflow-protocol/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How swarm-workflow-protocol Compares
| Feature / Agent | swarm-workflow-protocol | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | easy | N/A |
Frequently Asked Questions
What does this skill do?
Multi-agent orchestration protocol for the 0x-wzw swarm. Defines spawn logic, relay communication, task routing, and information flow. Agents drive decisions; humans spar.
How difficult is it to install?
The installation complexity is rated as easy. You can find the installation instructions above.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
Related Guides
Top AI Agents for Productivity
See the top AI agent skills for productivity, workflow automation, operational systems, documentation, and everyday task execution.
Best AI Skills for Claude
Explore the best AI skills for Claude and Claude Code across coding, research, workflow automation, documentation, and agent operations.
ChatGPT vs Claude for Agent Skills
Compare ChatGPT and Claude for AI agent skills across coding, writing, research, and reusable workflow execution.
SKILL.md Source
# Swarm Workflow Protocol The operating system for multi-agent collaboration in the 0x-wzw swarm. Defines how agents spawn, communicate, challenge, and hand off work. ## Core Principle **Optimal human-agent collaboration: humans spar, agents drive.** No approval bottlenecks. Continuous information flow. Goal: full autonomy through continuous improvement. ## The Human Role: Sparring Partner Z is not a bottleneck — Z is a thinking partner who sharpens agents. - Agents drive decisions and execution - Z challenges assumptions when they see gaps - Z's pushback improves outcomes - Over time, the gap between agent decisions and Z's expectations narrows **Sparring, not approving:** - ❌ "Should I do X?" (approval-seeking) - ✅ "I'm doing X because [reasoning]. You see any gaps?" (sparring) ## Pre-Task Spawn Analysis Before any task, answer these 3 questions in 10 seconds. ### Q1: Complexity? - **Simple** (one-shot, clear) → Don't spawn - **Semi-complex** (multi-step) → Q2 - **Ultra-complex** (many decisions) → Q2 ### Q2: Parallel Seams? - Are there genuinely independent subspaces? - Can two agents work simultaneously without needing each other's output? - **No** → Don't spawn (serial dependency = compounding latency) - **Yes** → Q3 ### Q3: Token Math - Spawn cost: ~500–1500 tokens overhead - Only spawn if expected output is **3–5x that** (~2000–7500 tokens) - **No** → Don't spawn (overhead exceeds savings) ## Decision Matrix | Task | Complexity | Parallel? | Token Budget | Decision | |------|------------|-----------|-------------|----------| | Simple | — | — | — | Main session | | Semi-complex | serial | No | — | Main session | | Semi-complex | parallel | Yes | Sufficient | **Spawn** | | Ultra-complex | parallel | Yes, 2-3 seams | Sufficient | **Spawn 2-3 leads** | | Ultra-complex | many seams | — | — | Resist swarm urge | ## Task Lifecycle 1. **Intake** → Task arrives from Z, Moltbook, cron, or webhook 2. **Classify + Pre-Spawn** → Route to correct agent type, run 3-question gate 3. **Challenge Round** → Specialists validate viability via relay 4. **Synthesis** → October synthesizes, assigns work 5. **Execution** → Sub-agents or direct execution 6. **Continuous Updates** → Z gets progress throughout 7. **Handoff & Close** → Summary, file log, next steps ## Relay Communication ### Endpoints - **Send:** `POST http://localhost:18790/message` - **Fetch:** `GET http://localhost:18790/messages?agent=<YourName>` - **Health:** `GET http://localhost:18790/status` - **Auth header:** `x-auth-token: agent-relay-secret-2026` ### Message Types | Type | When | Expectation | |------|------|-------------| | `urgent` | Z needs now | Immediate relay | | `status_update` | Progress info | Log only | | `task_delegation` | Work assigned | Log + await | | `question` | Need agent input | Expect response | | `data_pass` | Sharing results | Log + process | ### Standard Handoff Format ``` TO: <AgentName> TYPE: <type> CONTENT: [task description] APPROACH: [agreed approach] REPORT_TO: October ``` ## File Locations | What | Where | |------|-------| | Daily logs | `memory/daily-logs/YYYY-MM-DD.md` | | Agent comm audit | `memory/agent-comm-logs/YYYY-MM-DD.jsonl` | | This protocol | `skills/swarm-workflow-protocol/SKILL.md` | ## Anti-Patterns - ❌ Waiting on Z for approval - ❌ Executing before specialists validate - ❌ Silent completions - ❌ Spawning when serial dependency exists - ❌ Forgetting to log audit trail - ❌ Spawning to escape thinking (vs. leveraging parallel seams)
Related Skills
n8n Workflow Mastery — Complete Automation Engineering System
You are an expert n8n workflow architect. You design, build, debug, optimize, and scale n8n automations following production-grade methodology. Every workflow you create is complete, functional, and follows the patterns in this guide.
n8n-workflow-automation
Designs and outputs n8n workflow JSON with robust triggers, idempotency, error handling, logging, retries, and human-in-the-loop review queues. Use when you need an auditable automation that won’t silently fail.
web-skills-protocol
Auto-discover and use Web Skills Protocol (WSP) skills when interacting with websites. Use this skill whenever the user asks you to interact with, use, or perform actions on a website or web service — such as searching a site, placing an order, deploying an app, or calling a web API. Before scraping HTML or guessing at interfaces, check if the site publishes a skills.txt or agents.txt file that teaches you how to use it properly. If a website has complex elements (e.g., heavy JavaScript, interactive UIs), activating this skill can also help you understand the site's purpose and capabilities. Do NOT use for local file operations or non-web tasks.
agentic-workflow-automation
Generate reusable multi-step agent workflow blueprints. Use for trigger/action orchestration, deterministic workflow definitions, and automation handoff artifacts.
agent-autonomy-kit
Stop waiting for prompts. Keep working.
Meeting Prep
Never walk into a meeting unprepared again. Your agent researches all attendees before calendar events—pulling LinkedIn profiles, recent company news, mutual connections, and conversation starters. Generates a briefing doc with talking points, icebreakers, and context so you show up informed and confident. Triggered automatically before meetings or on-demand. Configure research depth, advance timing, and output format. Walking into meetings blind is amateur hour—missed connections, generic small talk, zero leverage. Use when setting up meeting intelligence, researching specific attendees, generating pre-meeting briefs, or automating your prep workflow.
obsidian
Work with Obsidian vaults (plain Markdown notes) and automate via obsidian-cli. And also 50+ models for image generation, video generation, text-to-speech, speech-to-text, music, chat, web search, document parsing, email, and SMS.
Obsidian CLI 探索记录
Skill for the official Obsidian CLI (v1.12+). Complete vault automation including files, daily notes, search, tasks, tags, properties, links, bookmarks, bases, templates, themes, plugins, sync, publish, workspaces, and developer tools.
📝 智能摘要助手 (Smart Summarizer)
Instantly summarize any content — articles, PDFs, YouTube videos, web pages, long documents, or pasted text. Extracts key points, action items, and insights. Use when you need to quickly digest long content, create meeting notes, or extract takeaways from any source.
Customer Onboarding
Systematically onboard new clients with checklists, welcome sequences, milestone tracking, and success metrics. Reduce churn by nailing the first 90 days.
CRM Manager
Manages a local CSV-based CRM with pipeline tracking
Invoice Generator
Creates professional invoices in markdown and HTML