Roundtable Forge

Use this skill to route a user's question into a structured multi-agent roundtable. Each character is an independent agent with its own profile and context. A Conductor coordinates the discussion, manages shared Memory in real time, and synthesizes the outcome. Characters respond to each other within topic segments, not fixed rounds; they may follow up, challenge, or briefly interrupt one another. When the host supports it, use real_subagent_runtime to spawn each character as a separate subagent via the Task tool.

Routing goal

• Map the user's question onto a small, diverse set of character-lanes (real, historical, or fictional) whose knowledge and perspectives cover the question's depth and breadth.
• Decide the initial seat count, the discussion protocol, the runtime tier, and the conditions for adding new seats.
• Produce a structured transcript, a traceable argument graph, and a shared Memory file that downstream steps can continue from.

Trigger cues

• Direct requests: "圆桌讨论", "召集专家", "让XX和YY辩论", "多角色研讨".
• Cross-disciplinary intent: "跨学科分析", "多角度审视", "不同领域怎么看".
• Depth or breadth expansion: "延伸一下", "再深入一点", "有没有其他视角".
• Character summoning: "召唤", "让谁来回答", "如果是XX会怎么说".
• Multi-agent intent: "每个角色一个 Agent", "multi-agent", "parallel agents", "独立 Agent".

Workflow

1. Capture the question: restate the user's core question, scope, and desired depth or breadth. If the question is practice-oriented (e.g., AI adoption, team workflows, personal productivity), briefly ask the user for optional context such as role, industry, team size, or existing tools. Record this context in topic_context or include it in the focus_question framing. Assess complexity tier (simple / medium / complex / open_exploration) and set metadata.round_budget ({min, max}) and metadata.complexity_tier per references/roundtable-protocol.md § Dynamic round budget. Read references/disclaimer-template.md and append the disclaimer to every output.
2. Select runtime tier: use references/multi-agent-runtime-protocol.md to choose single_backend_multi_session (default), real_subagent_runtime (when explicitly requested and host-supported), or soft_orchestration_only (fallback). Record the claim in Memory.
3. Select output format and discussion structure:
   • Output format decides the renderer: minutes (default, structured report), podcast (narrative transcript with a Host), or both. Resolve effective formats from metadata.output_formats first, then metadata.output_format, then ["minutes"]. New instances should write metadata.output_formats; keep the singular field only for backward compatibility. If the effective formats include podcast, follow references/podcast-output-protocol.md.
   • Output artifacts decide secondary projections. New full and continued roundtables default metadata.output_artifacts to ["argument_graph"]; an empty array opts out. The graph remains separate from the minutes / podcast format enum. Follow references/argument-graph-protocol.md.
   • Discussion structure decides the thinking methodology: standard (default, free-flowing), six_hats (parallel thinking across six dimensions), delphi (anonymous multi-round convergence), world_cafe (host-fixed, member-rotating multi-table rounds), or fishbone (independent subgroups proposing complete plans then cross-reviewing). Use references/discussion-structure-protocol.md to choose. If six_hats is selected, follow references/six-hats-protocol.md. If delphi is selected, follow references/delphi-protocol.md. If world_cafe is selected, follow references/world-cafe-protocol.md. If fishbone is selected, follow references/fishbone-protocol.md. Write metadata.discussion_structure to Memory. Richer structures produce deeper, longer content.
4. Select initial seats: use references/character-selection-guide.md to pick 3–5 characters from distinct domains. If the effective formats include podcast, add a Host archetype as an additional seat per references/podcast-output-protocol.md. For topics rooted in contemporary practice (AI, biotech, climate, markets, public policy, etc.), prioritize modern or living practitioners and researchers; use historical figures for foundational contrast, not as the default majority. For each character, build an agent_profile per references/multi-agent-runtime-protocol.md.
5. Initialize Memory: load assets/memory-template.json, fill topic, user_question (the user's original full text), owner, created_at, characters (with agent_profile), runtime_claim, disclaimer, metadata.output_formats, the backward-compatible metadata.output_format, metadata.output_artifacts, and metadata.discussion_structure. Use references/glossary.md as the single source of truth for all enum values and field names — every term written to Memory must match the glossary. Initialize the state machine: write state = "init" and seed state_log with the first entry {from: "", to: "init", trigger: "memory_initialized", at: <now>}; follow references/state-machine.md for all subsequent transitions. Set the temporal anchor: write metadata.current_date (ISO 8601) and, for fast-moving domains such as AI, instruct all agents to ground claims in the current timeframe per references/temporal-grounding-protocol.md. Agents must use web search when claiming specific tool capabilities, market adoption, or recent events, and must label historical examples with their date and relevance to the present. Save it as the shared discussion memory.
6. Run topic segments: the Conductor poses a focused sub-question for the current segment and dispatches character agents dynamically. In real_subagent_runtime, each character is invoked as an independent subagent via the Task tool; in single_backend_multi_session, each agent gets its own isolated prompt. After every speech, agents submit a speaking_intent (extend / rebut / question / pivot / pass). The Conductor selects the next speaker from these intents, allowing natural back-and-forth, follow-ups, and brief interruptions. Segments end when the sub-question is exhausted, not after a fixed number of turns. The Conductor writes every speech to Memory immediately before dispatching the next agent. If metadata.discussion_structure is six_hats, the Conductor follows the hat sequence and constraints in references/six-hats-protocol.md: all characters think from the same hat, then switch together; record structure_context.current_hat per speech. If metadata.discussion_structure is delphi, the Conductor runs three phases (independent → feedback → convergence) per references/delphi-protocol.md: collect anonymous answers, circulate an anonymized summary, and converge; record structure_context.delphi_phase per round and structure_context.anonymous_label per speech. If metadata.discussion_structure is world_cafe, the Conductor runs five phases (setup → rotation_1 → rotation_2 → rotation_3 → harvest) per references/world-cafe-protocol.md: table hosts stay fixed while members rotate across tables, hosts summarize at the end of each rotation, and the harvest phase collects cross-table insights; record structure_context.world_cafe_phase and structure_context.table_count per round, and structure_context.table_id / structure_context.is_host / structure_context.host_summary per speech. If metadata.discussion_structure is fishbone, the Conductor runs four phases (grouping → independent_proposal → cross_review → synthesis) per references/fishbone-protocol.md: each group produces a complete proposal independently, then groups cross-review one another's proposals, and the synthesis phase merges the strongest branches; record structure_context.fishbone_phase and structure_context.group_count per round, and structure_context.group_id / structure_context.reviewing_group_id per speech. If the effective formats include podcast, each character speaks in a conversational, show-ready tone with a Host bridging segments; see references/podcast-output-protocol.md. See references/roundtable-protocol.md, references/multi-agent-runtime-protocol.md, and references/intra-round-speaking-protocol.md. At the end of each non-final round, transition state to handoff_pending and write rounds[].handoff_card per references/handoff-card-protocol.md; the next round's first speech must consume it (state → handoff_consumed → round_open). State transitions and triggers are recorded in state_log per references/state-machine.md.
7. Invite the user when needed: inside a segment, if the discussion hits a value fork, an experience gap, an abstraction escalation, or a key decision point, the Conductor pauses and asks the user a bounded question per references/conductor-invitation-protocol.md. Record the invitation and the user's reply in Memory before continuing.
8. Handle user interjections: if the user interrupts mid-discussion to ask, add a character, pivot topic, pause, or end, follow references/user-interjection-protocol.md and record the interjection in Memory before continuing.
9. Assess seat expansion and depth: per the round_budget in metadata, check references/roundtable-protocol.md for expansion triggers and depth assessment signals. At each handoff_pending state, run the continue/stop decision tree: if depth signals are present and current_round < round_budget.max, continue; otherwise enter synthesis. If a new domain is needed, add a character with an agent_profile and continue.
10. Synthesize: identify consensus, divergence, and open questions; populate synthesis.next_steps with continuation candidates. If metadata.output_artifacts contains argument_graph, build synthesis.argument_graph after the ordinary synthesis per references/argument-graph-protocol.md: use atomic viewpoint nodes, controlled relations, and source speech_id citations; never infer opposition from topic similarity. Enumerated Memory fields must use the exact tokens defined in references/memory-schema.md — in particular next_steps[].scope ∈ micro / meso / macro and next_steps[].effort ∈ low / medium / high; conductor_invitation triggers must come from the standard set in references/conductor-invitation-protocol.md. scripts/lint_memory.py warns about other values, so run it before finalizing. Update Memory.
11. Propose continuation: after synthesis, if synthesis.next_steps is non-empty and the user has not asked to stop, the Conductor presents the next_steps and asks whether to continue with one of them per references/continuation-protocol.md. If the user agrees, the Conductor rewrites the chosen step into a new focus_question, adds seats if needed, appends a new round, and repeats steps 6–10. If the user declines, mark metadata.completed and finalize. Set state = "completed" and append a final state_log entry with trigger: "output_contract_lint_passed" (or synthesis_started if lint is bypassed) per references/state-machine.md.
12. Validate Memory: run scripts/lint_memory.py against the Memory JSON before rendering. The lint enforces the output contract defined in references/output-template-contract.md: the four mandatory top-level fields (topic, user_question, runtime_claim, disclaimer), the version / protocol_version alignment, the state machine and handoff cards from references/state-machine.md and references/handoff-card-protocol.md, the argument graph's node/edge/speech references, and the structure-specific vocabulary in references/glossary.md. Any error (dangling character references, version mismatch, invalid graph relation, illegal state transition, missing mandatory handoff card, missing mandatory output field, etc.) must be fixed before proceeding; warnings should be reviewed and fixed when cheap. This is the quality gate that keeps every rendered projection and the JSON source aligned.
13. Render outputs: resolve the effective list of output formats by reading metadata.output_formats first, then falling back to metadata.output_format, then defaulting to ["minutes"] if neither is set. For each format in the resolved list, in order, run the matching renderer: minutes → scripts/render_memory_to_markdown.py, podcast → scripts/render_memory_to_podcast_script.py. Then resolve metadata.output_artifacts; argument_graph → scripts/render_memory_to_argument_graph.py. scripts/render_all.py renders both format outputs and declared artifacts in one pass. Every substantive claim in a rendered file must trace back to Memory; the JSON remains the internal single source of truth for continuation.
14. Return output: present the rendered Markdown transcript(s), declared artifact path(s), and Memory file path for downstream continuation. Include Selected route, Why, Runtime claim, Output format, Output artifacts, Fallback, and Next step.

Output template

1. Selected route: the final character roster, runtime claim, discussion structure, output format, and discussion shape (number of rounds, seat expansion decisions)
2. Why: the signals from the question that determined the roster, runtime, structure, and protocol
3. Runtime claim: which tier was used (single_backend_multi_session, real_subagent_runtime, or soft_orchestration_only)
4. Discussion structure: which structure was used (standard, six_hats, etc.) and why
5. Output format: minutes or podcast
6. Output artifacts: argument_graph by default for full and continued roundtables, or the explicit opt-out
7. Fallback: the alternative shape if the user wants fewer characters, a single perspective, a different runtime tier, a different discussion structure, or a written essay instead of dialogue
8. Next step: whether to continue the same roundtable, start a follow-up roundtable from the Memory file, or export the Memory for another skill