// Multiple LLMs collaboratively brainstorm solutions, building on each other's ideas across rounds. Agent synthesizes the best ideas into a plan.
| name | collab |
| description | Multiple LLMs collaboratively brainstorm solutions, building on each other's ideas across rounds. Agent synthesizes the best ideas into a plan. |
Have multiple LLMs collaboratively brainstorm solutions, then synthesize the best ideas into a plan. The LLMs build on each other's ideas across rounds rather than critiquing positions.
Load the consult-llm skill before proceeding — it defines the invocation contract (stdin heredoc, flags, output format, multi-turn). Do not call the CLI without loading it first.
Selectors resolvable in this environment (depends on configured API keys):
!`consult-llm models`
Arguments: $ARGUMENTS
Model flags: any --<selector> from the Models block above selects a collaborator (e.g. --gemini, --openai, --deepseek). Repeat for multiple. Need at least two. Translate model flags and defaults according to the loaded consult-llm skill's model-selection rules.
Strip all flags from arguments to get the task description. Use the selector name as the label when presenting per-model output.
consult-llm SkillLoad it now. Follow its invocation contract for all CLI calls in this workflow.
Explore the codebase - use Glob, Grep, Read to understand:
Before planning or consulting, do enough research to understand how the requested behavior actually works. Before starting, think about what resources would be useful to obtain first: relevant source files, tests, logs, generated files, config, examples, command output, external docs, or authoritative upstream source. Gather the cheapest useful evidence before forming a plan.
Do not stop at the first plausible file, definition, setting, or example. Follow references, callers, related tests, and runtime usage until you can explain the current behavior and the likely impact of changing it.
Ground external semantics before planning - understand the requested behavior in the real system, not just this repo
Make evidence-backed assumptions - do NOT ask clarifying questions
Prepare context summary - create a brief summary of:
Have all selected LLMs independently brainstorm approaches (in parallel).
Seed prompt:
I need to implement the following task:
[Task description]
Here's what I found in the codebase:
[Context summary - relevant files, patterns, conventions]
Brainstorm implementation ideas:
1. **Ideas**: List 2-3 possible approaches with brief descriptions
2. **Favorite**: Which approach do you lean toward and why?
3. **Open questions**: What aspects are you unsure about or would benefit from another perspective?
4. **Risks**: What could go wrong or be tricky?
Think creatively. Share rough ideas — we're exploring, not committing.
Invoke consult-llm with one -m <selector> per collaborator and -f <path> for each relevant source file, sending the seed prompt per the consult-llm invocation contract. All models are queried in parallel in a single call.
Extract per-model thread IDs from the response — needed for Phase 3 since each model receives a different prompt.
Present each set of ideas to the user, labeled by selector.
Each round, share every other LLM's ideas with each model and ask them to build on them (in parallel). Pass each LLM's thread ID via -t <id> to continue its conversation. Continue until the ideas converge into a clear approach — typically 2-3 rounds, but use as many as needed.
Build-on prompt (same template for each model; embed every other model's previous-round response, labeled by selector):
Your collaborator(s) shared these ideas:
[Other LLMs' responses from the previous round, each labeled with the selector name]
Build on their thinking:
1. **What resonates**: Which ideas are strong? Why?
2. **Combinations**: Can any ideas be combined into something better?
3. **New ideas**: Did their thinking spark any new approaches?
4. **Refinements**: How would you improve the most promising ideas so far?
5. **Concerns resolved**: Did their ideas address any open questions?
Keep building — don't tear down. Refine toward the best solution.
Each model receives a different prompt (the other models' responses embedded). Invoke consult-llm once with one --run flag per collaborator, continuing each model's thread.
Present every response to the user after each round, labeled by selector.
When to stop: All collaborators are refining details rather than introducing new ideas, and a clear approach has emerged. Don't stop while there are still unresolved open questions or competing directions.
After all rounds, synthesize the brainstorm into a plan:
Identify the strongest ideas — which approaches gained momentum across rounds?
Note convergence — where did the LLMs naturally align?
Pick the best combination — merge the strongest elements into one coherent approach
Write the plan:
# [Feature Name] Implementation Plan
**Goal:** [One sentence describing what this builds]
## Brainstorm Summary
**Key ideas** (one block per collaborator, labeled with the selector):
- **<selector>:** [2-3 bullet points]
**Convergence:** [Where they naturally agreed]
**Synthesis:** [How the final approach combines the best ideas]
---
### Task 1: [Short description]
**Files:**
- Create: `exact/path/to/file.py`
- Modify: `exact/path/to/existing.py` (lines 123-145)
**Steps:**
1. [Specific action]
2. [Specific action]
**Code:**
```language
// Include actual code, not placeholders
```
---
Guidelines:
Save the plan to history/plan-<feature-name>.md.
How to invoke the consult-llm CLI. Canonical reference for the invocation contract, flags, stdin/stdout format, and multi-turn. Load this before calling consult-llm from any workflow skill (/consult, /collab, /debate, /collab-vs, /debate-vs).
Coordinator skill that runs a multi-phase implementation across workmux worktrees. Each phase invokes /implement in its own worktree; the coordinator handles dispatch ordering (sequential, parallel, DAG), merge sequencing, and failure isolation. Composes /implement, /merge, workmux, and consult-llm.
Autonomously plan and implement a task with external LLM review. Writes a behavioral spec, runs an evidence-gated plan review (premortem + independent alternative), applies feedback through a decision ledger, implements with a triggered debug loop, and finishes with an evidence-gated post-implementation verification review. No user interaction.
Standalone multi-model code review of an existing diff. Multiple LLMs review in parallel; agent deduplicates, prioritizes by severity/confidence, and optionally applies localized fixes.
The agent brainstorms with a partner LLM in alternating turns, building on each other's ideas. Synthesizes the best ideas into a plan.
Consult an external LLM with the user's query.