Adversarial Team Brainstorm

Adversarial Team Brainstorm

Multi-team tournament primitive. Spawns N parallel teams with distinct lenses, runs them through a structured four-round process, and returns ranked outputs with attached kill criteria, first experiments, and cross-fire attack histories. Reusable by any caller — not tied to a specific domain.

Scope: Pure prompt-orchestration primitive. Does NOT own the question, the data feeds, or the output storage. The caller owns those.

Callers:

• forge — design exploration tournaments (alternative to the current single-team exploration)
• agent-teams — "tournament" mode exposing this primitive for generic orchestration
• founder-ideation — generates business ideas with adversarial team quad
• alf — adversarial review of skills/code/products
• Any caller that passes a question + team angles + optional context

Invocation Contract

Input

question: string                # "Generate 20 SaaS ideas for accountants"
team_angles: list[string]       # lens names, see references/team-angles.md
rounds: int                     # default 4 (diverge, cross-fire, refine, arbiter)
n_per_team: int                 # outputs each team should produce in Round 1
context: map                    # optional data feeds keyed by name
                                # e.g. { reddit_pain_data: ..., gdelt_inflection_data: ..., user_assets: ... }
kill_criteria_required: bool    # default true; false rejected (see HARD-RULE)
team_model_override: map        # optional: { contrarian: "codex", trend_first: "agy" }
                                # default all teams run on Claude
max_total_outputs: int          # optional cap after arbiter synthesis (default = n_per_team * len(team_angles))
output_class: string            # "ideas" (default) | "signals" | "proposals" | "designs"
                                # affects which hard rules apply downstream — ideas require kill_criteria
                                # and first_experiment; signals require only data citation

Output

ranked_outputs:
  - content: string              # the idea / proposal / design
    rank: int                    # 1..N
    source_team: string          # which lens produced it, or "hybrid(A+B)" if merged
    kill_criteria: list[string]  # what would invalidate this (min 2)
    first_experiment: string     # smallest test of viability (1-2 sentences)
    attack_history:
      - from_team: string
        severity: enum           # critical | moderate | minor
        issue: string
        fix_proposed: string
    revisions:
      before: string             # the Round 1 version
      after: string               # the Round 3 refined version
      critique_absorbed: list[string]  # which attacks led to which edits
    confidence: enum             # high | medium | low | speculative
    grounding_sources: list[string]  # keys from input.context that supported this
arbiter_notes: string            # synthesis rationale, patterns observed, surviving minority reports
meta:
  rounds_run: int
  teams_used: list[string]
  total_raw_outputs: int         # n_per_team * len(team_angles) before trim
  total_final_outputs: int
  duration_seconds: int
  model_mix: map                 # which model ran which team

The Four Rounds

Round 1: Diverge

Each team generates n_per_team outputs in parallel and without seeing the others' work.

Per-team spawn prompt template:

You are Team {NAME}, running the {LENS} lens.
Your lens definition: {READ references/team-angles.md for {LENS}}

Question: {QUESTION}

{IF context[team_data_key] exists for this lens:}
Data grounding (you MUST cite at least one source from this feed in each output):
{INLINE THE DATA FEED, e.g. Reddit pain posts, GDELT events, user assets}
{END IF}

Produce exactly {N} outputs. For each output:
1. content: the idea/proposal/design
2. initial_kill_criteria: 2 things that would invalidate it (draft — arbiter will refine)
3. first_experiment: smallest test of viability
4. data_sources: list of grounding cites (reddit:sub/id, gdelt:event_id, user_asset:key, or "unfounded")

CRITICAL:
- Do NOT hedge. Commit to specific proposals, not option lists.
- Do NOT copy the question into the output.
- Do NOT use the other teams' work — you haven't seen it and that's intentional.
- If data grounding is required and you cannot find a cite for an output, mark it "unfounded"
  and the arbiter will filter it.

Spawn all teams simultaneously in one message (Claude via Agent, Codex via codex exec, Antigravity via timeout 600 agy --sandbox -p "..." < /dev/null as a background Bash task — --sandbox is mandatory for these advise-only calls, per the antigravity-cli SANDBOX RULE).

Round 2: Cross-fire

Each team receives the other teams' Round 1 outputs and must attack them. See references/cross-fire-protocol.md for the full protocol. Summary:

• Each team attacks every other team's outputs (N-1 targets)
• Minimum ≥1 attack per output (no "all good" verdicts — HARD-RULE)
• Attacks must include: severity (critical / moderate / minor), issue, fix_proposed
• Codex-powered teams are preferred for the contrarian / devil's-advocate role

Attacks MUST be structured — free-form commentary is rejected.

Round 3: Refine

Each team receives the attacks on its own outputs and revises. See references/cross-fire-protocol.md#refine-rules for rules.

• Every revised output must include before + after + critique_absorbed list
• A team may mark an attack as "rejected" with reasoning — not every critique is absorbed, but ignoring it silently is a failure mode
• Kill criteria are sharpened during refine (Round 1 drafts → Round 3 hardened versions)

Round 4: Arbiter Synthesis

A single arbiter agent (Claude by default; caller may override) reads all Round 3 outputs + attack histories and produces the final ranked list. See references/arbiter-synthesis.md for the full protocol. Summary:

• Identify surviving outputs (did not receive critical attacks, or absorbed them in refine)
• Hybridize where cross-team ideas complement (mark source_team: "hybrid(A+B)")
• Attach final kill criteria (minimum 2 per output — HARD-RULE)
• Assign confidence: high / medium / low / speculative
  • speculative is the max if there is no external data grounding
• Preserve minority reports: if one team strongly disagrees with the ranking, the arbiter notes it in arbiter_notes rather than hiding it
• Filter any outputs marked unfounded that cannot be hybridized with a grounded output

Team Angles

See references/team-angles.md for the full library. Common angles:

Callers pass the list they want; the primitive does NOT prescribe which angles to use — that is domain knowledge owned by the caller.

Fast path — adversarial-tournament workflow (S055, optional, main-loop only)

When the orchestrator is the main loop with the orchestration surface available (probe.sh get capabilities.workflow_tool true AND probe.sh context == main-loop — the ONLY capability API; capabilities.* alone never authorizes, session files are shared with subagents), the four rounds MAY run as the adversarial-tournament saved workflow: parallel diverge (one isolated agent per team angle, team-output.v1 with initial_kill_criteria minItems:2 — role collapse mechanically prevented) → parallel crossfire (each attacker sees ONLY other teams' outputs, attack-set.v1 minItems:1 per target makes "all good" schema-invalid; the script validates target coverage with a deterministic single retry on a sycophantic miss) → refine → single arbiter (tournament-result.v1; the script forces confidence to speculative when grounding_sources is empty — DOWNGRADE only, never upgrade). Below the budget floor before refine ⇒ skip refine, cap confidence low, meta.degraded_to: "quick_tournament" (documented mode, not silent loss). The script REFUSES configs that would drop kill criteria.

Stays inline: question scoping, angle selection, grounding-feed acquisition (reddit/gdelt run BEFORE and passed as context_paths), final selection, all user decisions. External team overrides ride W-EXT wrappers with args-supplied commands. The schemas live in schemas/; design-tournament does NOT wrap this workflow (B's ruling — standalone callers are this skill's own inline invocations). On any fast-path failure, fall back to the inline four rounds below.

Implementation Notes

Spawning Teams

Claude teams — use Agent tool with subagent_type: "general-purpose" and a spawn prompt that includes:

1. The team lens definition (read from references/team-angles.md)
2. The question
3. Any data feeds from context
4. The Round 1 output format

Codex teams — use codex exec (preferred for contrarian, first-principles, arbitrage angles):

timeout 600 codex exec --ephemeral --skip-git-repo-check -s read-only \
  -o "$WORK/team-contrarian-round1.md" \
  "You are the contrarian team. Question: $QUESTION. Data: see $CONTEXT_FILE.
   Produce $N outputs per the format in $OUTPUT_SPEC." < /dev/null

Antigravity (agy) teams — use the agy CLI for large-context angles (blue-ocean, trend-first with deep event history). Output is plain text on stdout — the orchestrator parses it (STDIN RULE: stdin MUST be closed or agy hangs in background shells, #135; SANDBOX RULE: --sandbox on every advise-only call or agy may write files/commit instead of answering, #157):

timeout 600 agy --sandbox -p "You are the blue-ocean team. Question: ... Data: see $CONTEXT_FILE. Produce $N outputs per the format in $OUTPUT_SPEC. Advisory only — do not modify any files; answer on stdout." < /dev/null > "$WORK/team-blue-ocean-round1.md"

Bridge Mode

session mode. Codex is unaffected (it always runs locally).

Batching the Spawns

All Round 1 team spawns MUST go in a single message with parallel tool calls. This is enforced by the "parallel diverge is mandatory" hard rule. The primitive is incompatible with sequential spawning.

Failure Modes

Mode: quick_tournament (optional shortcut)

For callers who need fast outputs and accept reduced rigor, a quick_tournament mode runs:

• 2 teams instead of 4
• 2 rounds (diverge + arbiter, no cross-fire or refine)
• max confidence low (enforced)
• useful for low-stakes brainstorms where the full 4-round cost is excessive

Callers opt in via rounds: 2. The primitive warns that cross-fire was skipped.

Do NOT use quick_tournament for founder-ideation, alf review, or any high-stakes decision. It exists only for exploration / discovery modes.

Anti-Patterns

Reference Files

Read these as needed during orchestration:

• references/team-angles.md — the founding-lens library (problem-first, asset-first, trend-first, contrarian, first-principles, arbitrage, blue-ocean, constraint-inverted) with spawn-prompt guidance per angle
• references/cross-fire-protocol.md — Round 2 attack protocol: target selection, severity rubric, fix-proposal format, rejected-attack fallback
• references/arbiter-synthesis.md — Round 4 synthesis protocol: survivor selection, hybridization rules, kill-criteria attachment, confidence scoring, minority-report preservation

When NOT to Use This Skill

• Single-agent question — if one specialist can answer, use that specialist directly. The tournament overhead is wasted on simple lookups.
• No cross-fire value — if the caller's question has one correct answer (e.g., "what's the syntax for X"), adversarial brainstorm is noise.
• No grounding and no exploratory intent — if you have no data feeds AND you're not trying to explore, you're just asking LLMs to argue with each other. Use a single agent and save the cost.
• Live production paths — this primitive is slow (4 rounds × N teams). Don't put it on a user-facing latency budget.