Agent Swarm Kit

Multi-agent swarming for OpenClaw — two or more AI agents collaborating in real-time on shared Discord channels. Includes config patterns, loop prevention, c...

Security Scan

The instructions, templates, and config snippets are consistent with the stated goal (coordinating multiple OpenClaw agents in a Discord channel); nothing requested or prescribed is disproportionate to that purpose.

Purpose & Capability

The name and description match the content: setup patterns for multi-agent collaboration on Discord. The skill does not request unrelated binaries, cloud creds, or external services. The examples legitimately show needing separate Discord bot accounts/tokens and agent config changes, which are appropriate for the stated capability.

Instruction Scope

SKILL.md instructs editing agent configs (OpenClaw JSON, SOUL.md) and placing Discord bot tokens/account bindings into those configs — actions that change local agent configuration and require secret bot tokens. This is within scope for running multi-agent swarms, but it does mean you must provide and manage bot credentials and modify agent files. The guide also warns about loop prevention and provides rules; still, misconfiguration could cause agent message loops, so test in a private server first.

Install Mechanism

Instruction-only skill with no install spec and no code files. This minimizes disk-write and supply-chain risk.

Credentials

The registry metadata declares no required env vars, but the instructions require you to supply Discord bot tokens / account bindings in agent configs. That is proportionate to the functionality (agents need bot accounts to post), but users should be aware the skill presumes storing and using secrets (bot tokens) in agent configuration; the skill does not itself request or manage any unrelated credentials.

Persistence & Privilege

The skill is not always-enabled, does not request elevated platform privileges, and does not attempt to modify other skills or system-wide settings. It only prescribes edits to the installing user's agent configuration files, which is expected for this feature.

Assessment

This skill appears coherent and focused on coordinating multiple OpenClaw agents via Discord. Before installing: (1) note the skill's source is unknown — prefer installing community skills from trusted publishers; (2) provision separate Discord bot accounts/tokens as instructed and store those tokens securely (do not paste tokens into public places or repos); (3) restrict bot permissions to the minimum needed (View, Send, Read History) and test swarming in a private/test server to avoid accidental loops or spam; (4) follow the provided loop-prevention rules and consider adding rate limits or slow mode on the channel; (5) audit logs and revoke tokens if behavior is unexpected. If you want higher assurance, ask the publisher for a verified homepage or a git repo so you can review provenance and any updates.

Get multiple AI agents working together in the same Discord channel — solving problems faster than any single agent could alone.

What This Does

Sets up a "swarming" pattern where two or more OpenClaw agents collaborate in real-time on a shared channel. One agent finds the root cause, the other validates and patches. They hand off to each other naturally using @mentions.

This isn't theoretical — it emerged from running two Opus models on the same issue and watching them solve it in 5 minutes instead of 20+.

How It Works

The Pattern

1. A human posts a problem in the swarming channel, @mentioning both agents
2. Both agents see the message and respond with their analysis
3. When one agent has new information, they @mention the other to hand off
4. Back and forth until they converge on a solution
5. Final summary posted, conversation ends naturally

Why It's Fast

• Different contexts: Each agent brings a different perspective (different session history)
• Parallel analysis: Both start working simultaneously
• Cross-validation: One agent's finding gets immediately checked by the other
• No single-agent blind spots: If one misses something, the other catches it

Setup Guide

Step 1: Create the Swarming Channel

Create a dedicated Discord channel (e.g., #swarming) for multi-agent collaboration.

Step 2: Configure Both Agents

Both agents need:

• requireMention: true on the swarming channel
• Different mentionPatterns (each agent's own bot ID)
• Their own Discord bot accounts (separate bot tokens)

Agent A config (Mini 1 — openclaw.json):

{
  "channels": {
    "discord": {
      "accounts": {
        "default": {
          "guilds": {
            "YOUR_GUILD_ID": {
              "channels": {
                "SWARMING_CHANNEL_ID": {
                  "requireMention": true
                }
              }
            }
          }
        }
      }
    }
  }
}

Agent B config (same pattern, different gateway/Mini).

Step 3: Loop Prevention Rules

Add these to both agents' SOUL.md files:

## Swarming Rules
- Only @mention the other agent when you have NEW information or a counterpoint
- Don't respond to simple acknowledgments ("agreed", "good point", "makes sense")
- After 3 exchanges without new information, summarize findings and stop
- Always end with a clear action item or conclusion
- If you agree with the other agent, say so briefly and move to implementation — don't debate for the sake of debating

Step 4: Multi-Gateway Routing (Critical)

If both agents run on the same gateway (same Mini), you need:

• Separate Discord accounts (separate bot tokens) for each agent
• Each account bound to a specific agent ID via accountId in the agent config
• Without this, both agents receive every message and the wrong one may respond

If agents are on different gateways (different Minis), this is automatic — each gateway only has its own agents.

When to Swarm

Good for swarming:

• Complex debugging (config issues, multi-layer problems)
• Architecture decisions (two perspectives better than one)
• Research synthesis (different angles on same topic)
• Code review (one checks logic, other checks edge cases)

Not worth swarming:

• Simple tasks (one agent is enough)
• Routine maintenance (use a single cheaper model)
• Anything with a clear, known procedure

Cost Considerations

Two Opus calls per exchange instead of one. But:

• Problems solve 2-4x faster
• Fewer wrong turns (cross-validation catches mistakes early)
• Net token usage often lower because you avoid long single-agent spirals

For cost optimization, you can swarm Opus + Sonnet instead of Opus + Opus. The Sonnet agent handles validation while Opus does the heavy thinking.

Real Example

Two Opus agents were debugging an OpenClaw config routing issue. Agent A (Harrison) researched the channel whitelist config. Agent B (Prometheus) found the root cause — a missing account binding — and patched it. Total time: 5 minutes. Single agent estimate: 20+ minutes.

The key insight: they attacked the problem from different angles simultaneously. Harrison looked at the channel config layer while Prometheus looked at the account binding layer. Neither would have found both issues as fast alone.

Files Included

• SKILL.md — This file (setup guide + patterns)
• templates/SWARMING_RULES.md — Copy-paste rules for agent SOUL.md files
• templates/CHANNEL_CONFIG.md — Example OpenClaw config snippets