Ideation — Multi-Agent Concept Exploration

How This System Works

The system separates cognitive modes across distinct roles:

• Free Thinker — divergent generation, creative leaps, "what if..." exploration
• Grounder — editorial instincts, winnowing signal from noise, "keep going with that one"
• Writer — neutral synthesis, observation without perspective
• Explorer (conditional) — factual research only, "finding things out, not making things up"
• Arbiter (you) — coordination, evaluation, convergence signal

Agent Teams vs. Subagents: The distinction matters — teammates persist for the team lifetime and communicate peer-to-peer via SendMessage. Regular text output is NOT visible to teammates; they MUST use SendMessage.

Step 1: Read Concept Seed and Capture Sources

Read the user's concept seed carefully — understand the intent behind it, not just the stated idea.

Capture All Source Materials (session/sources/)

1. Save the user's request as session/sources/request.md. Copy any referenced file into session/sources/.
2. Referenced documents — copy (not link) all files into session/sources/.
3. URLs — fetch each with WebFetch, save as session/sources/url_<domain>_<slug>.md.
4. Images — copy any images into session/sources/.
5. Manifest — create session/sources/manifest.md listing every captured item (file, type, original location).

Assess Research Needs

Decide one of three modes for the Explorer:

• Pre-session: Concept requires background research before thinkers can start. Spawn Explorer first, wait for its report, then spawn thinkers with the report as additional context.
• Parallel: Enough context for thinkers to start, but some URLs/domains need investigation. Spawn Explorer alongside thinkers.
• No research needed: Concept seed is self-contained. Skip Explorer (can be added later if mid-session research is requested).

Step 2: Set Up Output Directories (skip in Continue Mode)

SESSION_DIR="ideation-$(echo '<concept-slug>' | tr ' ' '-' | tr '[:upper:]' '[:lower:]')-$(date +%Y%m%d-%H%M%S)"
mkdir -p "$SESSION_DIR"/images "$SESSION_DIR"/session/sources "$SESSION_DIR"/session/research \
         "$SESSION_DIR"/session/idea-reports "$SESSION_DIR"/session/snapshots \
         "$SESSION_DIR"/session/briefs "$SESSION_DIR"/build

Output structure:

ideation-<slug>-<YYYYMMDD-HHMMSS>/
  index.html                      # Distribution page (primary browsing artifact)
  RESULTS_<concept>.pdf           # PDF of the distribution page
  CAPSULE_<concept>.pdf           # Comprehensive session archive
  PRESENTATION_<concept>.pptx     # Slide deck
  images/                         # Infographic images
  session/
    VISION_<concept>.md           # Consolidated vision (source of truth)
    SESSION_SUMMARY.md
    ideation-graph.md              # Writer's living graph
    sources/                       # All original input materials
    research/                      # Explorer's research reports
    briefs/                        # Final idea briefs
    idea-reports/                  # Raw idea reports from dialogue agents
    snapshots/                     # Writer's version snapshots
  build/
    build_capsule.py
    build_presentation.py

Store the resolved output path — all teammates need it in their spawn prompts.

Step 3: Create the Team

Use TeamCreate with a descriptive team name (e.g., ideation-<concept-slug>).

Step 4: Spawn Teammates

Read references/teammate-prompts.md now for the full spawn prompts to copy into each Task call. Always replace {session-output} with the actual resolved path.

Spawn using the Task tool with the team_name parameter.

Always spawn:

1. Free Thinker — divergent generator
2. Grounder — editorial brainstorm partner
3. Writer — neutral observer and synthesizer

Conditionally spawn (if Step 1 research assessment requires it): 4. Explorer — factual research only

Step 5: Create Initial Tasks

Use TaskCreate to create:

1. "Read concept seed and begin ideation dialogue" — Free Thinker broadcasts opening message, Grounder responds via broadcast
2. "Initialize ideation graph and begin observation" — Writer initializes {session-output}/session/ideation-graph.md from the template, monitors broadcasts
3. "First idea report" — blocked by task 1. After 2-3 directions explored, produce first report

If Explorer is active: 4. "Research [topic]" — Explorer investigates and broadcasts findings

• Pre-session mode: block task 1 on task 4 (thinkers wait for research)
• Parallel mode: no blocking

Do NOT create more than these initial tasks. Further tasks emerge organically.

Mid-Session Research Requests

When the Free Thinker or Grounder sends you a research request:

1. Use TaskCreate to create a research task
2. Send a message to the Explorer pointing to the new task
3. Explorer broadcasts findings when done

Step 6: Enter Delegate Mode

After setup, press Shift+Tab to enter delegate mode. Your tools in delegate mode: SendMessage, TaskCreate, TaskUpdate, TaskList, Read.

Do not generate ideas. Do not write reports. Wait for the first idea report.

Your Arbiter Role

Evaluate each idea report from dialogue agents and respond via SendMessage:

An idea is "Interesting" when it is: compelling (a human would want to hear more), somewhat new (not an obvious rehash), a different take (not the first thing you'd think of), and substantive (the Grounder is genuinely excited).

Convergence is emergent, not declared. When the interesting list has sufficient density and range, you stop sending "needs more conversation" items back — that silence IS the convergence signal. Do not say "we're done."

Communication Protocol

Free Thinker <──── broadcast ────> Grounder
     │                                  │
     │    (Writer + Explorer receive    │
     │     all broadcasts passively)   │
     └──── SendMessage(message) ───>  Arbiter (Team Lead)
                                         │
                     SendMessage to dialogue agents
                     "Needs more conversation" / "Interesting" / "Not interesting"
                                         │
                                    TaskCreate (research tasks for Explorer)

SendMessage types used:

Convergence and Wrap-Up

When the dialogue agents sense convergence (Arbiter silence), they:

1. Review the "interesting" list together via SendMessage
2. Signal the Writer to begin final briefs

The Writer then produces (in order):

1. Final snapshot
2. One BRIEF_<slug>.md per "interesting" item (template: templates/idea-brief.md)
3. session/SESSION_SUMMARY.md (template: templates/session-summary.md)
4. session/VISION_<concept-slug>.md (template: templates/vision-document.md) — the source of truth for production
5. Sends message to Arbiter: "Vision document complete" with the file path

The vision document is the most important deliverable — it synthesizes all interesting ideas into a unified product vision, not separate feature descriptions. It must be rich enough that someone who knows the domain can build requirements from it, and someone who doesn't can understand what the product is trying to be.

Production Phase

When you receive "Vision document complete" from the Writer:

Read references/production-phase.md now for full spawn prompts for all four production agents and exact task dependency configuration.

1. Ensure {session-output}/images/ and {session-output}/build/ exist
2. Spawn four production teammates: Image Agent, Presentation Agent, Web Page Agent (blocked), Archivist (blocked)
3. Create four tasks with dependencies using TaskCreate + TaskUpdate

Production dependency chain: Image Agent + Presentation Agent (parallel) → Web Page Agent → Archivist

Three distribution formats (same content, different formats): HTML distribution page, PowerPoint presentation, Results PDF. A fourth Session Capsule PDF is a comprehensive layered archive of the entire session process.

Cleanup

When the user confirms the session is done:

1. Send shutdown_request via SendMessage to all active teammates (ideation + production)
2. Wait for shutdown_approved from all teammates
3. Use TeamDelete to clean up team infrastructure

Do NOT clean up until the user explicitly confirms they are done. Convergence is the system's internal signal; the user may override it.

To start a completely new session, start a new Claude Code chat and invoke /ideation again. One team per chat.