| name | PeerReviewSwarmOptions |
| description | Catalog of every available peer-review / multi-AI consultation mechanism in this repo. Use when picking the right tool for swarm-reviewing PRs, validating findings, or fan-out brainstorming. Pros/cons + cost/latency/auth for each. |
| aliases | ["peer-review-swarms","swarm-options","which-swarm","swarmpicker"] |
/PeerReviewSwarmOptions — Pick the right swarm for the job
When to use this skill
Trigger when you need to pick BETWEEN swarm tools — not when you've already decided on one. If you already know "I want a 3-engine consensus", just call /swarm-second-opinion. If you don't know what to use, read this first.
The 10 swarm/peer-review options ranked
1. /swarm-second-opinion (RECOMMENDED DEFAULT)
What: 3-engine consensus via tools/swarm/swarm_run.py --preset consensus-3 (deepseek + xai + kilo).
Pros: Fast (~30-45s), well-tested, JSON-locked output, ~$0.001 cost. Catches most blindspots.
Cons: Only 3 engines; can miss niche failure modes.
Best for: PR reviews, decision tiebreakers, single-question second opinions.
2. /consult-swarm (Kilo Code's catalog-and-router)
What: Meta-skill that picks between swarm_v2, ruflo, consult-multi, combine-team.
Pros: Decision wrapper — handles "I don't know which tool".
Cons: Adds a layer; if you already know which tool, faster to call directly.
Best for: Open-ended "I want multi-AI input but I'm not sure what shape".
3. tools/swarm/swarm_run.py (raw multi-engine fan-out)
What: Direct CLI to fan a prompt across 2-N engines (deepseek, xai, kilo, gemini, ofox, nvidia_deepseek, etc).
Pros: Maximum control — pick exact engines, set --cost-cap-usd, --json-strict, --persona.
Cons: You write the prompt + parse the output. No built-in consensus extraction.
Best for: Production scripts, repeated fan-outs, when you know exactly what you want.
Invocation:
python3 tools/swarm/swarm_run.py --prompt-file /tmp/q.md --engines deepseek,xai --out-dir swarm_runs/topic-$(date -u +%Y%m%dT%H%M%SZ)
4. /swarm-pr-review (PR-specific 3-engine review)
What: Multi-model PR review with role-specialization (impact, code, risk).
Pros: Tailored for PR review (vs generic Q&A). Returns merge/needs-changes/major-rework verdict.
Cons: Slower than /swarm-second-opinion (~60-90s). Costs ~$0.005 per PR.
Best for: Open-PR sweeps — exactly what's needed for the "review all open PRs" task.
Invocation:
python tools/swarm/swarm_dispatch.ps1 -pr <number>
python tools/swarm/swarm_run.py --pr <number> --preset consensus-3 --json-strict
5. /swarmv2-pr-review (enhanced PR review with risk model)
What: 6-engine self-improving swarm with quality scoring + A/B + skill export.
Pros: Most thorough — impact analysis + code review + risk assessment. Self-improving.
Cons: Slow (2-5 min/PR), expensive ($0.02). Overkill for trivial PRs.
Best for: High-stakes PRs (production secrets, financial logic, safety-critical).
6. /swarm-ruflo (ruflo orchestrator)
What: Hermes-based ruflo swarm with subcommands (audit/github/strategy/bugs/wizard/keys/continuous).
Pros: Domain-specialized agents (github-actions auditor, bug hunter, strategy reviewer).
Cons: Requires the Hermes agent to be running locally; key management complexity.
Best for: When you want a specific agent type (e.g., "github-actions auditor on PR #N").
7. /consult-multi (11-provider router)
What: Unified CLI fronting 11 LLM providers (NVIDIA, Groq, Cerebras, Together, Fireworks, GitHub Models, HuggingFace, Gemini, Cloudflare, DeepInfra, Nous).
Pros: Free-tier rotation across many providers; reads keys from ~/dbpasses.txt. Single-provider OR fan-out (--fanout diverse5/fast4/reasoning4/all9).
Cons: Provider quality varies; some free-tier providers rate-limit aggressively.
Best for: Multi-provider triangulation when you want providers, not specific models.
8. /consult-cloudflare-models (Cloudflare Workers AI fan-out)
What: 37+ models on Cloudflare (Llama, GPT-OSS, Nemotron, Qwen, GLM, Mistral, Phi, Gemma).
Pros: Free-tier friendly; very wide model coverage.
Cons: Cloudflare model versions lag a bit behind upstream releases.
Best for: Wide-net brainstorming or "show me what 5 random models think".
9. /consult-nvidia-models (NVIDIA NIM fan-out)
What: 10+ models on NVIDIA Integrate API (DeepSeek v4 Pro, MiniMax, Kimi-K2.6, Nemotron, Qwen, Llama-4, Mistral).
Pros: High-quality models (DeepSeek v4 Pro is excellent); free tier.
Cons: Single provider — if NVIDIA NIM goes down or quota hits, everything fails.
Best for: When DeepSeek v4 Pro specifically is what you want.
10. FreeLLM CombineTeam / DebateTeam (external)
What: User's FREELLM repo runs CombineTeam (consensus aggregator) or DebateTeam (adversarial debate between AIs).
Pros: DebateTeam catches things consensus misses — adversarial framing surfaces hidden assumptions.
Cons: Lives in a separate repo (E:\FREELLM\ per user); higher setup cost; output format different.
Best for: Truly high-stakes decisions where you want adversarial pressure-testing, not consensus.
11. LiteLLM rotating proxy (http://localhost:4000/v1)
What: Local LiteLLM proxy (the FREELLM/REELLM setup) fronting 25+ upstreams behind one OpenAI-compatible endpoint with auto rate-limit rotation. Virtual model groups: free-mode, free-mode-fast, free-mode-large, paid-mode, paid-mode-fast, hybrid-model.
Pros: One stable base URL, no per-provider key juggling (keys live in ~/dbpasses.txt), transparent failover when an upstream 429s/cools down. Works with any openai SDK client. Great when the swarm CLIs hit env/CLI friction (WSL-only grok, missing modules) — the proxy is always reachable if running.
Cons: Need the proxy running (bash tools/start_litellm_proxy.sh -b); you don't control which specific upstream answers (rotation picks); not a consensus tool by itself (single response per call — fan out yourself by calling N times or N groups).
Best for: A quick free second opinion with zero key setup, or as the transport behind a hand-rolled fan-out when the dedicated swarm CLIs are jammed. Manage with /litellm-proxy (start/stop/status/test), /statusvllmp, /modevllmp.
Invocation:
curl -s http://localhost:4000/health/readiness
curl -s http://localhost:4000/v1/chat/completions \
-H "Authorization: Bearer anything" -H "Content-Type: application/json" \
-d '{"model":"free-mode-fast","messages":[{"role":"user","content":"Review: <claim>"}],"max_tokens":600}'
for g in free-mode-fast paid-mode-fast free-mode-large; do
curl -s http://localhost:4000/v1/chat/completions -H "Authorization: Bearer x" \
-H "Content-Type: application/json" \
-d "{\"model\":\"$g\",\"messages\":[{\"role\":\"user\",\"content\":\"<prompt>\"}],\"max_tokens\":600}" \
| python3 -c "import json,sys;d=json.load(sys.stdin);print('==',d.get('model'),'==');print(d['choices'][0]['message']['content'])"
done
When to prefer over the others: the dedicated swarm CLIs (swarm_run.py, ruflo, swarm_v2) failed on env/CLI issues (observed 2026-05-28: WSL-only grok, No module named 'swarms', 300s timeouts). The proxy sidesteps all of that — if /v1/models returns, you have a working second opinion in one curl.
Single-provider variants (lighter weight)
When 1 AI is enough but you want a different perspective from Claude:
| Skill | Provider | When to use |
|---|
/consult-grok | xAI Grok CLI | Real-time / current-event awareness |
/consult-gemini | Google Gemini CLI | Long-context (>200K tokens) |
/consult-codex | OpenAI Codex CLI | Code-heavy questions |
/consult-cursor-agent | Cursor Agent CLI | Codebase-aware (it has its own context) |
/consult-opencode | opencode CLI | Open-source CLI equivalent |
/consult-kilo | kilo CLI (opencode fork) | Quick second opinion |
/consult-ofox | Z.AI GLM-4.7-Flash (free) | Cheap structured-JSON |
/consult-ring261T | inclusionai/ring-2.6-1t on OpenRouter | 1T-parameter extended-thinking; deep reasoning |
/consult-nvidia-deepseek | DeepSeek v4 Pro on NVIDIA NIM | Default high-quality JSON-locked answer |
/consult-cloudflare | Any of 37+ CF models | Specific model selection |
Decision tree
Need peer review on a PR?
├── 1 PR, low-stakes → /swarm-second-opinion (3 engines)
├── Many PRs, batch sweep → /swarm-pr-review per PR
├── High-stakes (real money, secrets, prod-critical) → /swarmv2-pr-review
└── Need adversarial framing → FreeLLM DebateTeam
Need brainstorming / fan-out?
├── 3-engine consensus → /swarm-second-opinion
├── 5-9 provider diversity → /consult-multi --fanout
├── 37+ model breadth → /consult-cloudflare-models
└── Codebase-aware → /consult-cursor-agent or /consult-kilo
Need a second opinion on a single answer?
├── JSON-locked output, cheap → /consult-ofox or /consult-nvidia-deepseek
├── Long context → /consult-gemini
├── Real-time awareness → /consult-grok
├── Deep reasoning → /consult-ring261T
└── Cross-provider robustness → /consult-multi --provider <name>
Cost summary (per call, approximate)
| Tier | Examples | Cost |
|---|
| Free | ofox, gemini, kilo, cloudflare, nvidia (free tier), groq, cerebras, together, LiteLLM proxy free-mode* | $0 |
| Near-free | deepseek, xai | $0.001–0.005 |
| Paid | swarmv2 (multiple engines × tokens) | $0.005–0.05 |
| Expensive | ring261T (extended thinking) | $0.01–0.10 |
Output format conventions
All swarm tools that follow our convention produce swarm_runs/<topic>-<UTC-timestamp>/:
swarm_runs/topic-ts/
├── <engine>.json # parsed JSON response (preferred)
├── <engine>.json.raw.txt # unparsed text (debugging)
├── _summary.json # cost + tokens + transport metadata
Always inspect both <engine>.json (structured) AND .raw.txt (for engines that failed schema validation).
Lessons learned
-
TICK 15 retraction lesson (2026-05-26 session): always run a swarm round on high-stakes findings BEFORE writing the pressure-test report. I called CT=F a Tier-1 candidate at n=230 raw and got falsified by the dedup view 4 ticks later. Two-engine swarm would have caught it.
-
JSON-locked prompts beat open-ended: When prompts request structured JSON output with named fields + a confidence enum, engines commit to concrete answers instead of hedging.
-
2 engines is usually enough: deepseek + xai catches ~90% of what 3-5 engines catch. Add more only when stakes are high (financial logic, secrets, safety-critical).
-
Background mode for long-running: run_in_background=true on tools/swarm/swarm_run.py lets you kick off and continue other work.
Quick reference one-liners
python3 tools/swarm/swarm_run.py --prompt-file /tmp/q.md \
--engines deepseek,xai --out-dir swarm_runs/qq-$(date -u +%Y%m%dT%H%M%SZ)
python3 tools/swarm/swarm_run.py --prompt-file /tmp/q.md \
--preset consensus-3 --out-dir swarm_runs/big-$(date -u +%Y%m%dT%H%M%SZ)
python3 tools/swarm/swarm_run.py --pr 8 --preset consensus-3 \
--json-strict --out-dir swarm_runs/pr8-review-$(date -u +%Y%m%dT%H%M%SZ)
echo "Your question" | python3 tools/swarm/api_consult.py --provider ofox -
echo "Your question" | python3 tools/swarm/api_consult.py --provider nvidia_deepseek -
curl -s http://localhost:4000/v1/chat/completions -H "Authorization: Bearer x" \
-H "Content-Type: application/json" \
-d '{"model":"free-mode-fast","messages":[{"role":"user","content":"Your question"}],"max_tokens":600}' \
| python3 -c "import json,sys;print(json.load(sys.stdin)['choices'][0]['message']['content'])"
Related skills
/swarm-second-opinion — 3-engine consensus wrapper/swarm-pr-review — PR-specific review/swarmv2-pr-review — enhanced 6-engine PR review/consult-swarm — Kilo's meta-router (consolidates many of the above)/swarm-actions-audit — multi-agent GH Actions audit/swarm-followup — multi-turn chain (priming → analysis → critique → final)/swarm-transcript-scan — audit a session transcript for missed action items/consult-multi — 11-provider router
