L’interface est localisée ; les présentations et documents des Skills sont traduits automatiquement par IA dans votre langue. Le code, les commandes, chemins et termes techniques restent en version originale, et le document de l’auteur fait foi.
Explorer les Skills
Données et recherche · SKILL.md

unleash-the-agents

unleash-the-agents

Launch all available agents in parallel waves for open-ended hypothesis generation on problems where the correct domain is unknown. Use when facing a cross-domain problem with no clear starting point, when single-agent approaches have stalled, or when diverse perspectives are more valuable than deep expertise. Produces a ranked hypothesis set with convergen…

Independent GitHub snapshot · Automated classification · Original documentation governs

Documentation de la Skill

GitHub

name: unleash-the-agents locale: caveman-ultra source_locale: en source_commit: be74aff5 fence_basis_commit: be74aff5 translator: "Julius Brussee homage — caveman" translation_date: "2026-05-03" description: > Launch all available agents in parallel waves for open-ended hypothesis generation on problems where the correct domain is unknown. Use when facing a cross-domain problem with no clear starting point, when single-agent approaches have stalled, or when diverse perspectives are more valuable than deep expertise. Produces a ranked hypothesis set with convergence analysis and adversarial refinement. license: MIT allowed-tools: Read Write Edit Bash Grep Glob Agent ToolSearch TeamCreate TaskCreate TaskUpdate TaskList SendMessage metadata: author: Philipp Thoss version: "1.2" domain: swarm complexity: advanced language: multi tags: swarm, parallel, hypothesis-generation, multi-agent, brainstorming, convergence

Unleash the Agents

Consult all agents in parallel waves → diverse hypotheses for open-ended problems. Each agent reasons through unique domain lens — kabalist via gematria, martial-artist via conditional branching, contemplative by sitting w/ data. Convergence across independent perspectives = primary signal of merit.

Use When

  • Cross-domain problem → correct approach unknown
  • Single-agent|single-domain stalled or no signal
  • Problem benefits from genuinely diverse perspectives (not more compute)
  • Need hypothesis generation, not exec (use teams for exec)
  • High-stakes → missing non-obvious angle costs

In

  • Required: Problem brief — clear description, 5+ concrete examples, what counts as solution
  • Required: Verify method — how to test hypothesis (programmatic, expert review, null model)
  • Optional: Agent subset — include|exclude (default: all registered)
  • Optional: Wave size — agents per wave (default: 10)
  • Optional: Out format — structured template (default: hypothesis + reasoning + confidence + testable prediction)

Do

Step 1: Brief

Write brief any agent can understand regardless of domain. Include:

  1. Problem: Discover|decide (1-2 sent)
  2. Examples: 5+ concrete in/out|data points (more better — 3 too few)
  3. Constraints: Known + tried
  4. Success: Recognize correct hypothesis
  5. Out template: Exact format
  6. Sources per claim: Each fact → from issue|plan|own reading|prior session notes; end state you intend to create → mark as intended
## Brief: [Problem Title]

**Problem**: [1-2 sentence statement]

**Examples**:
1. [Input] → [Output]  (explain what's known)
2. [Input] → [Output]
3. [Input] → [Output]
4. [Input] → [Output]
5. [Input] → [Output]

**Already tried**: [List failed approaches to avoid rediscovery]

**Success looks like**: [Testable criterion]

**Respond with**:
- Hypothesis: [Your proposed mechanism in one sentence]
- Reasoning: [Why your domain expertise suggests this]
- Confidence: [low/medium/high]
- Testable prediction: [If my hypothesis is correct, then X should be true]

Got: Self-contained brief — agent receiving only this has all to reason.

If err: Can't articulate 5 examples|verify method → problem not ready for multi-agent. Narrow scope first.

Step 2: Plan Waves

List all agents, divide into waves of ~10. Order doesn't matter waves 1-2; subsequent waves → inter-wave knowledge injection improves results.

# List all agents from registry
grep '  - id: ' agents/_registry.yml | sed 's/.*- id: //' | shuf

Assign agents to waves. Plan 4 waves initially → may not need all (early stop Step 4).

WaveAgentsBrief variant
1-220 agentsStandard brief
310 agents + advocatus-diaboliBrief + emerging consensus + adversarial challenge
4+10 agents eachBrief + "X is confirmed. Focus on edge cases and failures."

Got: Wave assignment table all agents allocated. advocatus-diaboli in Wave 3 (not later) → adversarial informs subsequent waves.

If err: < 20 agents → reduce 2-3 waves. Pattern works w/ as few as 10, weaker convergence signals.

Step 3: Launch Waves

Launch each wave parallel. sonnet model → cost efficiency (value from perspective diversity, not depth).

Option A: Agent tool spawning (recommended)

Path for ordinary interactive sessions. Per agent in wave → spawn as subagent via Agent tool (subagent_type = agent's type, e.g. kabalist, geometrist) w/ brief + domain framing:

Use the [agent-name] agent to analyze this problem through your domain expertise.
[Paste the brief]
Think about this from your specific perspective as a [agent-description].
[For non-technical agents: add a domain-specific framing, e.g., "What patterns
does your tradition recognize in systems that exhibit this kind of threshold behavior?"]
Respond exactly in the requested format.

Launch all in wave simultaneous via Agent tool w/ run_in_background: true, coord via SendMessage under session's single implicit team. Wait for wave complete before next (inter-wave knowledge injection Step 4).

Option B: TeamCreate (FleetView / cloud only)

TeamCreate deprecated + gated out of ordinary interactive sessions — ToolSearch("select:TeamCreate") returns nothing there, team_name ignored (session has single implicit team). Where it does surface (FleetView / cloud) → adds named team object w/ per-teammate task ownership + shutdown lifecycle (Task* tools themselves also work interactive — only team scoping doesn't):

  1. Create team: TeamCreate({ description: "Wave 1: open-ended hypothesis generation" })
  2. TaskCreate per agent (brief + domain framing)
  3. Spawn each agent as teammate via Agent w/ subagent_type = agent's type
  4. Assign via TaskUpdate w/ owner; monitor via TaskList
  5. Between waves → shut down via SendMessage({ type: "shutdown_request" }) + start next w/ updated brief (Step 4)

Built-in team coord — per-teammate ownership + lifecycle, status carried across waves — but team scoping only where TeamCreate surfaces. Interactive → Option A.

Choosing options

Agent tool (Option A)TeamCreate (Option B)
AvailabilityEvery session (primary)FleetView / cloud only (gated)
Best forAll interactive unleashesCloud runs wanting shared task list
CoordinationSendMessage, manual collectionTask list, messaging, ownership
Inter-wave handoffTrack via brief updateTask status carries over

Got: Each wave returns ~10 structured responses in 2-5 min. Failed|off-format noted but no block.

If err: > 50% wave fails → check brief clarity. Common: out template ambiguous|examples insufficient for non-domain agents.

Step 4: Inject Inter-Wave Knowledge (+ Eval Early Stop)

After waves 1-2, extract emerging signal before next.

  1. Scan responses → recurring themes
  2. ID most common hypothesis family (convergence signal)
  3. Early stop check: top family > 3x null model expectation after 20 agents → strong signal. Plan Wave 3 as adversarial + refinement, consider stop after.
  4. Update brief for next wave:
**Update from prior waves**: [N] agents independently proposed [hypothesis family].
Build on this — what explains the remaining cases where this hypothesis fails?
Do NOT simply restate this finding. Extend, challenge, or refine it.

Early stop guidance: Not every unleash needs all agents. Well-defined domains (codebase analysis) → convergence stabilizes 30-40 agents. Abstract|open-ended (unknown math transformations) → full roster adds value because correct domain genuinely unpredictable. Check convergence after each wave → top family count + null-model ratio plateaued → diminishing returns.

Prevents rediscovery (later waves re-deriving earlier finds) + directs later agents to edges.

Got: Later waves → more nuanced, targeted hypotheses addressing gaps in emerging consensus.

If err: No convergence after 2 waves → too unconstrained. Narrow scope or more examples.

Step 5: Collect + Dedupe

After waves complete, gather responses → single doc. Dedupe by grouping into families:

  1. Extract all hypothesis statements
  2. Cluster by mechanism (not wording — "modular arithmetic mod 94" + "cyclic group over Z_94" same family)
  3. Count independent discoveries per family
  4. Rank by convergence: families w/ more independent discoveries higher

Got: Ranked list of families w/ convergence counts, contributing agents, representative testable predictions.

If err: Every hypothesis unique (no convergence) → S/N too low. Need more examples or tighter out format.

Step 6: Verify vs Null Model

Test top hypothesis vs null model → ensure convergence meaningful, not training data artifact.

  • Programmatic verify: Hypothesis produces testable formula|algo → run vs held-out examples
  • Null model: Estimate prob N agents converge by chance (K reasonable families → random ~N/K)
  • Threshold: Signal meaningful if convergence > 3x null model

Got: Top family significantly exceeds chance-level convergence and/or passes programmatic verify.

If err: Top fails verify → check 2nd-ranked. None passes → different approach (deeper single-expert, more data, reformulated examples).

Step 7: Adversarial Refinement

Preferred timing: Wave 3, not post-synthesis. advocatus-diaboli in Wave 3 (alongside inter-wave injection) > standalone after all waves. Early challenge → Waves 4+ refine vs critique not pile on unchallenged consensus.

If adversarial part of Wave 3, this = final check. If not (ran all waves w/o it) → spawn advocatus-diaboli (or senior-researcher) now. Structured pass → spawn both as parallel subagents via Agent tool, coord via SendMessage vs consensus:

Here is the consensus hypothesis from [N] independent agents:
[Hypothesis]
[Supporting evidence and convergence stats]

Your job: find the strongest counterarguments. Where does this fail?
What alternative explanations are equally consistent with the evidence?
What experiment would definitively falsify this hypothesis?

Got: Counterarguments, edge cases, falsification experiment. Survives adversarial → ready for integration. Good adversarial sometimes partially defends consensus → design better than alts even if imperfect.

If err: Adversarial finds fatal flaw → feed critique → targeted follow-up wave (Tier 3+ iterative — 5-10 agents best for critique).

Step 8: Hand Off → Teams

Unleash finds problems; teams solve. Convert verified families → actionable issues, assemble focused teams.

  1. GitHub issue per verified family (use create-github-issues)
  2. Prioritize by convergence strength + impact
  3. Per issue, assemble small team → read matching def + spawn members as subagents via Agent tool (subagent_type), coord via SendMessage:
    • Predefined team in teams/ matches → use it
    • No fit → default opaque-team (N shapeshifters, adaptive role) → handles unknown shapes w/o custom comp
    • Include 1+ non-tech agent (advocatus-diaboli, contemplative) → catches implementation risks tech misses
    • REST checkpoints between phases → prevent rushing
  4. Pipeline: unleash → triage → team-per-issue → resolve

Got: Each family maps → tracked issue w/ team. Unleash diagnosed; teams fix.

If err: Team comp doesn't match → reassign. Shapeshifters can research+design but lack write tools → lead applies code suggestions.

Check

  • All available agents consulted (or deliberate subset w/ justification)
  • Responses collected in structured, parseable format
  • Hypotheses deduped + ranked by independent convergence
  • Top verified vs null model or programmatic test
  • Adversarial pass challenged consensus
  • Final hypothesis includes testable predictions + known limits

Traps

  • Too few examples: Agents need 5+. W/ 3 → surface pattern matching|template echo (brief back in different words).
  • Merge sources into one voice: Brief blending issue, plan, own reading, prior session notes → loses seams. Intended end state reaches agents as "issue says…" → effort spent hunting nonexistent fact. Attribute every claim (Step 1, element 6). Recorded for peer session, not unleash wave, in docs/investigations/lead-support-coordination-2026-09-15.md.
  • No verify path: W/o test, can't distinguish signal from noise. Convergence necessary but not sufficient.
  • Metaphorical responses: Domain specialists (mystic, shaman, kabalist) → rich metaphor hard to parse programmatically. Include "Express as testable formula or algorithm" in template.
  • Rediscovery across waves: W/o inter-wave injection → waves 3-7 rediscover what 1-2 found. Update brief between.
  • Over-interpret convergence: 43% on family sounds impressive → check base rate. 3 plausible families → random ~33%.
  • Single-family dominance expectation: Abstract problems (pattern recog, crypto) → one dominant family. Multi-dim (codebase, sys design) → broader convergence across multiple valid → expected, healthy, not failure.
  • Generic framing for non-tech: Quality depends on framing in domain language. "What does your tradition say about systems at threshold?" → structural insight; generic → nothing. Invest in domain-specific framing.
  • Use for exec: Pattern generates hypotheses, not implementations. Verified → convert to issues + teams (Step 8). Pipeline: unleash → triage → team-per-issue.

→

  • forage-solutions — ant colony opt for solution spaces (complementary: narrower, deeper)
  • build-coherence — bee democracy → select among competing approaches (after this skill to choose between top hypotheses)
  • coordinate-reasoning — stigmergic coord for managing info flow
  • coordinate-swarm — broader swarm coord for distributed systems
  • expand-awareness — open perception before narrow (complementary: individual agent prep)
  • meditate — clear ctx noise before launch (recommended before Step 1)
Skills enregistrées