round-table
Skill11 starsChanged 10 days agoMITView on GitHub
Orchestrates group discussions between Vespyr agents, enabling natural multi-agent conversations where each agent is a real subagent with independent thinking. Use when the user requests a roundtable, wants multiple agent perspectives, group discussion, or stage-based alignment.
2 other projects use a version of this.
Adopted by
Most recently taken up by
- draekien/skillstheir own version, first seen Nov 15, 2026
- Soul-Brews-Studio/arra-oracle-skills-clitheir own version, first seen Apr 13, 2026
Other versions2 projects use a version of this.
Word for word · 0
None found.
Edited · 0
None found.
Wrote their own version · 2
- Soul-Brews-Studio/arra-oracle-skills-cli★ 121same name
- draekien/skills★ 1same name
How matches are found. Word for word: the exact same text. Edited: shares passages with this file (“99% same” means 99% of its five-word phrases also appear here; 10% or more counts). Their own version: similar meaning, or, weakest, the same name. We can’t tell which project had it first. Projects are counted among the 200 most-starred candidates, and mentions are links to the repository we found, up to 50 per site, so both counts are a floor.
In this repository44 other files it gives its agents.
- AGENTS.mdAGENTS.md
- CLAUDE.mdCLAUDE.md
- analyze-dataSkill
- brainstormingSkill
- craft-lessonSkill
- create-agentSkill
- create-skillSkill
- customize-agentSkill
- customize-skillSkill
- designSkill
- deslopSkill
- developSkill
- discovery-reportSkill
- elicitationSkill
- empathy-mapSkill
- explore-ideaSkill
- grill-meSkill
- help-meSkill
- humanizeSkill
- incidentSkill
- iterateSkill
- journey-mapSkill
- jtbdSkill
- kanbanSkill
- launchSkill
- legal-safety-auditSkill
- maintenance-executeSkill
- maintenance-planSkill
- memorySkill
- motionSkill
- phaseSkill
- planSkill
- research-planSkill
- retroSkill
- reviewSkill
- root-causeSkill
- shape-upSkill
- shut-upSkill
- statusSkill
- teach-meSkill
- testSkill
- unpack-problemSkill
- validate-ideaSkill
- validation-patternsSkill
The file
Show its rules and text
We split this skill into the rules it gives an agent
13 rules. About 0 are common, 6 are distinctive, and 7 are very specific to this project.
≈0
Common · estimate
Many files like this have a rule of this kind.
≈6
Distinctive · estimate
This author's own choices. Worth a look.
7
Very specific
Tied to their project's names, files or tools. Probably skip.
- Common
- Distinctive
- Very specific
- Very specific: line 70
Ask for confirmation or edits in one line (no ceremony).
- Very specific: line 81
Read roster-router.json; match the user's topic against tag descriptions (multiple tags may match).
- Very specific: line 108
Documentation (Phase 8): no standing panel — on-demand @technical-writer + @developer duo, async otherwise.
- Distinctive: line 113
If the user names specific agents, always include them, plus 1-2 complementary voices.
- Very specific: line 170
No false consensus: if trade-offs are mutually exclusive, log them as an explicit ADR decision record in …
- Distinctive: line 178
Sycophantic Premature Convergence (SPC) Gate: If all panelists agree in Round 1 with zero friction, the orchestrator must assign a …
- Distinctive: line 231
When the user replies, questions, or steers the conversation in subsequent turns:
- Very specific: line 235
Do not answer as a lone assistant.
- Distinctive: line 239
Treat the user's message as an input into the ongoing multi-agent debate.
- Very specific: line 247
If an agent agrees with the user, they must provide hard technical justification.
- Distinctive: line 250
Every turn in an active roundtable session must follow this structure:
- Distinctive: line 257
After the discussion ends, verify any claim that a file or artifact changed against the disk before recording it as fact — concrete command …
- Very specific: line 288
When the user explicitly exits (/exit) or confirms a close ("done — close it"), run this checklist in order — skipping any step is a …
≈ “Common” is an estimate: at least 1 in 5 of the 364,980 skill files we read have a rule of the same kind, not the same words. “Very specific” is our guess from the words: it names a file, a command, a setting or the project itself.
Files
Roundtable Discussion
What this skill does
Facilitate roundtable discussions where Vespyr agents participate as real subagents — each spawned independently through the active harness's subagent capability so they think for themselves. You are the host and orchestrator: you determine the stage of development, pick the relevant voices, build context, spawn agents in parallel, and present their responses.
In default subagent mode, never generate agent responses yourself — that's the whole point. In --solo mode, you still never generate responses yourself: each persona is dispatched as its own context-firewalled LLM call (see Arguments). If the harness cannot make isolated calls, refuse the roundtable — never simulate a debate in one shared context.
When to invoke
- The user says "hold a round table", "get multiple agent perspectives", "convene a panel on X", or invokes
/round-table - A decision has real stakeholder tension and one perspective would dominate the answer — architecture vs. delivery, speed vs. correctness, scope vs. quality
- Stage-based alignment is needed before a commitment gate (budget, headcount, architecture freeze)
brainstormingStep 4b routes a multi-tension idea here
When NOT to invoke
- One deep interrogation of a single claim is what's needed — use
/grill-me; a panel costs 2–5 isolated seats plus cross-examination for a question one interviewer can ask well - The decision is already locked and execution is the ask — use
/shut-upor the relevant workflow - The harness cannot make isolated calls and degraded solo mode is not acceptable to the user — refuse rather than simulate
- Technical debugging of a live failure — use
/incident; a debate is not a diagnosis
Why This Matters
Roundtable discussions yield genuinely independent perspectives. When one LLM roleplays multiple characters, their opinions tend to merge and feel performative. By spawning each agent as its own subagent process — or, on harnesses without subagents, as context-firewalled sequential LLM calls — you get real diversity of thought: agents that actually disagree, catch things others miss, and bring their authentic expertise to bear. The independence primitive is context isolation, not the process mechanism (see Harness-Neutral Delegation).
Arguments
The roundtable skill accepts optional arguments:
--model <model>— Force all spawned participants to use a specific model when the active harness supports model selection (e.g.--model flash,--model premium). When omitted, use the active harness's default model; do not infer a model tier from agent frontmatter unless the loaded configuration defines one.--solo— Run without spawning subagents, for harnesses that cannot spawn them but can issue multiple isolated LLM calls. Dispatch each persona as its own LLM call that receives only the user's topic, the loaded memory context, and that persona's file — never another agent's output. Phase 2+ cross-examination passes a targeted stance into the next agent's call, mirroring how subagent mode passes context between subagents. Announce solo mode on activation and disclose that its output is degraded relative to native mode. Speed alone is not a valid reason to collapse the panel into one shared context. Solo panels cap at 5 seats, same as native — the matcher enforces the cap and errors on overflow. Every solo transcript MUST open with a machine-readable marker line[MODE: solo — isolated calls, {n} seats]— marker-less solo transcripts fail verification (roundtable_eval.js scorelists them under solo disclosure failures).
Harness-Neutral Delegation
Delegation path: reasoning → selected persona roles | direct-fallback
Degraded-mode policy lives in the shared contract .agents/references/degraded-mode-tiers.md (tiers, --simulated exception rule, telemetry) — this skill does not restate it. Roundtable-specific additions: Phase 2+ cross-examination passes a targeted stance into the next agent's call, mirroring how subagent mode passes context between subagents; every solo transcript MUST open with [MODE: solo — isolated calls, {n} seats] (marker-less solo transcripts fail verification).
On Activation
- Parse arguments — check for
--modeland--soloflags. - Resolve the agent roster — read from
.agents/agents/using the resolver. The resolver enumerates the available personas and marks@memory-controllerwithreasoningParticipant: false— never seat it as a reasoning participant. Then apply the Topic-Tag Router below against the user's topic — filter by table match, not by improvisation:node .agents/scripts/resolve_agents.js - Determine current phase/stage — read the pipeline state file as the source of truth (
pipeline-state.json). Use the project context file only as a context mirror when the pipeline state is unavailable; if the two disagree, report the pipeline value and the drift. - Load shared memory context — before the discussion starts, load context so agents have project awareness:
Store the returned context to inject into each subagent prompt. Brainstorm intake: if the topic arrives with anode .agents/scripts/memory_filter.js --agent founder --task "round table discussion: {user's topic}"brainstorming-session.mdpath (Step 4b routing), validate-then-adopt: run a 5-minute falsification check on the sharpened topic + tension map (wrong question? stale premises? missing tension?) before consuming it — the panel may RESHAPE-topic or bounce back to brainstorming with reasons. If it passes, use the sharpened topic as the debate subject plus its "What this surfaced" bullets as the initial tension map — do not re-sharpen from scratch, but still validate phase fit per Activation step 3 and flag drift. - Log the session mode — once native/solo/refused is resolved (see fallback tiers), run:
A refused roundtable logsnode .agents/scripts/roundtable_eval.js log --mode <native|solo|refused> --topic "{topic}" --agents "@a,@b"--mode refusedand stops — no welcome, no debate. - Welcome the user — briefly introduce the roundtable mode (and if solo mode is active, disclose that solo output is degraded: isolated calls replace subagent independence). Show the router-matched roster as a
ROSTER:line and ask what topic or issue they would like to discuss. - Enumerate the discussion points (Point Coverage Ledger — anti-tunnel; canon:
.agents/references/point-coverage.md). Once the topic is set — before any dispatch — parse the topic plus any attached artifact (user message,brainstorming-session.md, prior transcript) into the confirmed point set:- Emit one compact block:
POINTS: P1 [agenda] — <ask or tension>,P2 [facet] — <angle the panel must sweep>, … —[agenda]for distinct user asks,[facet]for angles the subject warrants (security, cost, failure modes, irreversibility, …). A genuinely single-point topic declares one point; never manufacture points for ceremony. - Ask for confirmation or edits in one line (no ceremony). The confirmed ledger is the session's coverage contract; later turns append points as
P<n+1>, never renumber. - Carry the ledger into the panel session cursor:
session begin --topic "{topic}" --agents "@a,@b" [--mode native|solo] [--points "P1 [agenda], P2 [facet]"].
- Emit one compact block:
Stage-Aware Agent Selection
Select 2-5 agents whose expertise matches the user's topic or the current stage of development.
Topic-Tag Router (mandatory — replaces host improvisation)
The closed, versioned tag table lives in .agents/references/roster-router.json (single source of truth; rationale: artifacts/docs/review/07-roundtable.md §6/§8/§9). Router procedure:
- Read
roster-router.json; match the user's topic against tag descriptions (multiple tags may match). Executable matching (no improvisation):
Validate the proposed seats before dispatch — untagged seats beyond 2, missing mandatory seats, and over-cap rosters fail here, not mid-debate:node .agents/scripts/resolve_agents.js --topic "eval harness judging agent prompts"
Record the validatednode .agents/scripts/resolve_agents.js roster check --topic "..." --seats "@a,@b" [--mode native|solo]ROSTER:line at the top of the transcript for auditability (future observer-voice checks join on it). List seats in seating order: the 2 core seats first, summoned specialists after — positions beyond 2 are audited as challengers. - Auto-seat every
mandatoryagent of matching tags — no substitution, no host discretion. - On tagged topics, seat 2 is the highest-ranked consulted agent (
policy.reserved_seat_2), acting as an active dialectic counterweight. If mandatory seats are fewer thanrules.default_seats(2), auto-seat fills from consulted with telemetry marker[ROUTER-AUTOSEAT: <tag> → @<agent>]. Untagged topics fall back torules.untagged_fallback(@tech-lead,@architect). consultedagents beyond the floor join Phase 2 as challengers or are cited — never silent full seats by default. Auto-seated Seat 2 is an active dialectic participant across Round 1 and Round 2 with an explicit mandate to evaluate boundaries and cross-examine assumptions.- Emit a machine-checkable roster line before dispatch:
ROSTER: @a,@b[+@c: tag-name]— every seat beyond 2 must name a router-table tag. Free-text tensions are rejected. - User override (
<agent> instead/add) is honored and logged as[ROUTING-OVERRIDE: default → chosen — reason]. Host-initiated deviation requires[ROUTER-DEVIATION: rule → action — evidence]and counts toward the revisit SLA (max_override_rate: 0.20,min_sessions: 10). - Owner of this table:
@tech-lead(mechanics).@foundersettles ALL roster disputes; ties auto-resolve to the more-reversible roster with logged dissent.
Recommended Rosters by Phase (2+summon defaults)
- Validation (Phase -1):
@founder+@researcher, summon@product-manageron GO,@user-researcherwhen humans must falsify. - Discovery (Phase 0):
@researcher+@user-researcher, summon@founder/@ux-researcher. - Research (Phase 1): merged into Discovery — no standing roster (was a duplicate default).
- Strategy (Phase 2):
@product-manager+@founder+@product-designer+@user-researcher(reference design; PM+designer duo acceptable cheap mode). - Architecture (Phase 3):
@architect+@security-engineer, summon@tech-lead/@performance-engineer; AI/security-tagged topics auto-seat the reserved non-builder seat. - Planning (Phase 4):
@tech-lead+@product-manager, summon@architect/@devops-engineer(duo acceptable cheap mode). - Execution (Phase 5):
@developer+@code-reviewer+@qa-engineertrio default;@security-engineeron injection/auth tags;@tech-leadsummons on deadlock. - Launch (Phase 6):
@devops-engineer+@qa-engineer, summon@product-manager/@technical-writer;@ml-ai-engineer+@ml-ai-opsmandatory for AI releases with eval gate. - Iteration (Phase 7):
@product-manager+@data-analyst+@ux-researcher+@performance-engineer; rotate@ml-ai-engineerin for AI products. - Documentation (Phase 8): no standing panel — on-demand
@technical-writer+@developerduo, async otherwise. - Retro (Phase 9):
@product-manager+@tech-lead, summon@qa-engineer/@shifu/data on evidence;@founderkills sacred cows on L3 retros.
Custom & Domain-Specific Cross-cutting Roles
- If the user names specific agents, always include them, plus 1-2 complementary voices.
- Select domain experts based on the specific topic:
- Security, PII & Compliance: Summon
@security-engineer - Performance, Latency & Scalability: Summon
@performance-engineer - AI/ML Logic, RAG & Prompts: Summon
@ml-ai-engineer - ML Infrastructure, Model Serving, Vector DBs & Drift: Summon
@ml-ai-ops - CI/CD, Cloud Infrastructure & Release Automation: Summon
@devops-engineer - Data Analytics, Telemetry & Funnel Tracking: Summon
@data-analyst - API References, User Guides & System Docs: Summon
@technical-writer - Pedagogy, Curriculum & Mentorship: Summon
@shifu - Market, Competitor & Industry Trends: Summon
@researcher - User Feedback, Persona Mapping & Interviews: Summon
@user-researcher - Usability, Interaction & Journey Mapping: Summon
@ux-researcher
- Security, PII & Compliance: Summon
Note: @memory-controller executes memory actions behind the scenes and is not included as a reasoning participant in roundtable discussions.
The 4-Phase Dialectic State Machine
Roundtable discussions enforce true perspective collision where agents are mandated to defend their positions under pushback or justify concessions with technical proof.
Dispatch Ledger (attribution — every subagent call leaves a row)
Token spend on the subagent path is harness-side invisible; attribution is not. The host (writer) records one row per dispatch at completion via .agents/scripts/dispatch_ledger.js — never batched from memory at close:
node .agents/scripts/dispatch_ledger.js record --writer "@round-table" --agent "@<persona>" --task "<what they were asked>" --outcome <success|error|timeout|rejected_by_gate|cancelled> [--attempt N] [--parent-trace <id>] [--context-bytes N]Rules: one row per dispatch (retries counted via --attempt, never re-rowed); outcome from the closed enum only; token/cost columns do not exist here (rows carry tokens_unknown:true, cost_unknown:true by design — spend aggregation over the ledger is refused). When a later agent consumes an artifact, link it: dispatch_ledger.js consume --dispatch <id> --consumer <label>. At close, dispatch_ledger.js verify must pass (empty window fails); summary reports the orphan-artifact rate ("did it matter").
Phase 1: Position Stating (Scatter & Verdict Gate)
- Unconditioned parallel subagent dispatch (no anchor bias, unconditioned priors).
- Active Dialectic Mandate for Seat 2: Seat 2 (auto-seated consulted counterweight or counterpart) is an active dialectic participant from Round 1 onward, with an explicit mandate to evaluate boundaries and cross-examine assumptions rather than acting as a passive observer.
Prompt Sanitization Rule: The orchestrator MUST prompt each panelist to evaluate the subject against first principles and issue an explicit verdict from the correct gate (definitions:
.agents/references/vespyr-dna.md):- Decision Gate — proposals, ideas, designs under stress-test:
[GO]/[RESHAPE]/[NO-GO]. - Review Gate — claims about existing state (implementation reports, records, checkboxes):
[CONFIRMED]/[PARTIAL]/[FALSIFIED].
The orchestrator is STRICTLY FORBIDDEN from asking "How do we build this safely?" or "What is the blueprint if the user insists?"
- Decision Gate — proposals, ideas, designs under stress-test:
- Plain sentence before the marker: the
[SYNTHESIS: …]line is the machine companion, never the message. The owner-facing brief lands first in plain language ("build this" / "keep the why, replace the how" / "don't build this") — see.agents/references/vespyr-dna.md§The Plain Sentence. A panel that hands the user a bareGO|RESHAPE|NO-GOtoken has failed the gate even ifroundtable_eval.js scorepasses. The same rule covers the Review Gate — "confirmed, I reran it and it holds" / "partly true, <what exists> is real but <what was claimed> is not" / "that's not true — <evidence> says <the opposite>" before[CONFIRMED]/[PARTIAL]/[FALSIFIED]. - Two surfaces (round-table is the clearest case): the transcript is the document —
[VERDICT: …],[SYNTHESIS: …],[RED-TEAM: …], the coverage block, and[MODE: solo …]all belong in it, becauseroundtable_eval.jsreads that file and nothing else. The chat carries the owner brief only: plain wording, the decision's consequence, the options with consequences, and the link. No marker, no token, no card field in chat — not even "for reference" (.agents/references/vespyr-dna.md§Two surfaces). - Zero-Blueprint-on-NO-GO / Zero-Consumption-on-FALSIFIED: An agent issuing
[NO-GO]states the technical autopsy and stops — no compromise options or implementation workarounds. A[FALSIFIED]claim may not be consumed as true by any downstream gate, banner, or sign-off until the record is corrected forward with dated evidence. - Each selected agent states their position, key constraints, and concerns independently.
- Parseable verdicts: each panelist ends their position with a machine-readable line —
[VERDICT: GO|RESHAPE|NO-GO](Decision Gate) or[VERDICT: CONFIRMED|PARTIAL|FALSIFIED](Review Gate). The eval scorer parses these; prose-only verdicts break telemetry.
Phase 2: Targeted Pairwise Cross-Examination (Exchange & Attack)
- The orchestrator identifies core tensions (e.g.
@architectvs@developer,@tech-leadvs@product-manager). - Agent X receives Agent Y's stance with an explicit mandate: identify unstated assumptions, boundary blindspots, and invalid invariants.
- Mandatory Attack Coverage: every Phase-1 position must receive at least one cross-examination before Phase 3 begins. The tension map must assign at least one challenge to each panelist position — a position with zero assigned challenges blocks Phase-3 entry. If no genuine tension exists for a position, assign an adversarial stress prompt instead of skipping. The orchestrator MUST emit the map as a fenced
```roundtable-coverageblock (panel:line +challenges:lines) and validate it —node .agents/scripts/roundtable_eval.js coverage(block on stdin or--file) — before Phase 3: exit 1 means a coverage gap and blocks Phase-3 entry until every panelist is challenged. - Tunnel-breaker (bounded focus): every Phase 2/3 exchange round opens with a machine-readable focus marker —
[FOCUS: Pn]— naming the point that round primarily targets. Depth on one point is legitimate; a silent tunnel is not. After 2 consecutive rounds on the same point, the orchestrator MUST open the next round with a breadth checkpoint —[BREADTH: <pending points dispositioned or named>]— before continuing. The evaluator reports same-point focus runs of ≥3 rounds without a breadth marker astunnelWarnings(advisory, uncalibrated — baseline-first).
Phase 3: Defense & Justified Concession (Rebuttal)
- Challenged agents MUST defend with hard empirical constraints (benchmarks, schema invariants, latency/budget limits) OR formally log an explicit concession with root-cause proof:
[CONCESSION: reason]. - Passive nodding, unacknowledged pivots, or "Preach-then-Comply" workarounds are rejected as Functional Sycophancy.
- Bounded iterations: Maximum 2 exchange rounds. Each Phase 2+3 exchange round MUST open with a machine-readable marker (
[ROUND: 1],[ROUND: 2]) — a third round marker fails the bound check (roundtable_eval.js scorelists it under round-bound violations).
Phase 4: Synthesis Gate & Irreconcilable Trade-Off Escalation
- Point closure gate (blocking — anti-tunnel): before synthesis, every ledger point reaches exactly one terminal state and the transcript carries a fenced
```roundtable-pointsblock: apoints:line (P1 [agenda], P2 [facet]) plus onedispositions:line per point (- P1: covered — <one-line outcome>·- P2: deferred — owner: @<agent>; reason: ...; revisit: ...). States are closed:covered | deferred | rejected | out-of-scope— deferred needsowner+reason; rejected needs a reason; out-of-scope needs a quoted boundary"...". Validate withnode .agents/scripts/roundtable_eval.js points --file <transcript>: exit 1 blocks synthesis until every point is dispositioned; exit 2 means the block is missing or malformed. A point that never came up isdeferredwith a reason — never absent. - No false consensus: if trade-offs are mutually exclusive, log them as an explicit ADR decision record in
artifacts/memory/active-decisions.mdrather than synthesizing a muddy compromise. - Owner brief first (DNA 8): before any marker, write the owner-readable result — one plain sentence of what the panel found; each finding as what's-wrong → why-it-matters → consequence; every open decision as a linked brief (question, context, file link, options with consequences, one recommendation). Machine markers come after the brief, never instead of it.
- End the synthesis with a machine-readable outcome line —
[SYNTHESIS: GO|RESHAPE|NO-GO], or[SYNTHESIS: ADR:<adr-id>]when escalated to a decision record — for eval scoring.
Invariant Anti-Sycophancy & Orchestration Rules
- Mandatory Visible Dialogue Stream: The orchestrator MUST output the visible back-and-forth agent dialogue (e.g.
### @agent-a -> @agent-b) so the train of thought and cross-examination are fully transparent to the user. Pre-digesting the debate into a single summary card or table without showing the dialogue is strictly forbidden. - Prohibition of Functional Sycophancy ("Preach Then Comply"): Emitting verbal warnings while still drafting implementation plans or option menus for a
[NO-GO]ed idea is an engine failure. A technical warning on a flawed premise must halt the implementation track. - Concession Justification Requirement: An agent cannot concede a stated position without citing empirical evidence, constraint violations, or explicit project tradeoffs.
Sycophantic Premature Convergence (SPC) Gate: If all panelists agree in Round 1 with zero friction, the orchestrator must assign a designated Red-Team challenger or inject an adversarial stress prompt before persisting outcomes. The assignment is machine-readable: emit
[RED-TEAM: @agent](or[RED-TEAM: adversarial-prompt]for the injected variant) in the transcript.The premise must be declared, and an undeclared premise FAILS CLOSED. Emit one line at intake:
[TOPIC-PREMISE: sound](the panel may disagree — unanimity then requires a red-team pass) or[TOPIC-PREMISE: flawed](unanimity is expected and correct, and is exempt).roundtable_eval.js scoreenforces all four cases:Premise declared Round-1 unanimity Red-team marker Result soundyes present pass — the challenge happened soundyes absent fail — this is the convergence the gate exists to catch flawedyes — pass, reported as expected, not silently exempt (absent) yes — fail closed The last row is the point. Until 2026-10-14 the gate inferred the premise from
evals/roundtable/topics.json, and a topic registered nowhere was in neither the sound nor the flawed set — so the gate silently did not apply. Measured: a transcript with two instant[GO]verdicts, no evidence, and the flattery "Good call, I agree completely" scoredcoverage compliance: 1,SPC advisory, exit 0. Fail-open is what the explicit declaration replaces. The exemption still needs a judgement no regex can make, so it is now declared in the transcript, where it is auditable and challengeable, rather than inferred where it is invisible.flawedis not a free pass — three checks close the paths to gaming it. Declaring a premise dead exempts unanimity from the red-team requirement, so the declaration itself is the thing to police.roundtable_eval.js scorerejects all three:Path Why it is rejected Retro-fit — declare flawedafter seeing that everyone agreedThe declaration must precede the first [VERDICT:]line. A premise judgement made with the verdicts in hand is a rationalisation, not a judgementNaked claim — declare flawedwith no reason"This premise is dead" is a claim about the world and needs evidence. Write [TOPIC-PREMISE: flawed — <what makes it dead>]. (A topic registered as flawed intopics.jsonalready carries its evidence there; no duplicate reason is demanded.)Self-reclassify — declare flawedon a topic the registry callssoundA topic cannot be reclassified by the panel that wants unanimity. Either run the red-team pass, or record the dissent with [ROUTING-OVERRIDE: registered-sound → transcript-flawed — reason]The honest ceiling, stated rather than implied: a host can still declare
flawedup front and write a plausible reason. No text check can tell a genuine judgement from a confident one. What these three buy is that gaming the gate now requires a deliberate, dated, written claim that appears before the evidence and can be challenged by anyone reading the transcript — instead of a silent choice nobody sees.The panel must hand the owner a choice, not a token. A unanimous panel additionally emits
[USER-DECISION: <plain sentence>]naming the choice and what each option costs, in the owner's language, with no gate token in it — the scorer rejects a missing, token-bearing, or thin line. A unanimous panel that returns only[SYNTHESIS: GO]has made the owner's decision for them, which is the same failure arriving by a different door.- Zero User Deference & Anti-Flattery: Never flatter the user ("Good call [User]", "Great idea", "What [User] wants is..."). The user's input is a hypothesis to be stress-tested, not a mandate to collapse debate. If a user proposal has architectural holes or trade-offs, panelists must attack them directly.
- Mandatory Attack Coverage: no Phase-1 position ends a round unchallenged. The check is mechanical: count challenges in the tension map — one or more per panelist position, verified before Phase 3. Challenges must target unstated assumptions, boundary blindspots, or invalid invariants; performative surface challenges do not count toward coverage.
- Point Coverage Ledger (anti-tunnel): the discussion's points are enumerated and user-confirmed at intake; every point ends the session in exactly one closed disposition (
covered | deferred | rejected | out-of-scope— canon:.agents/references/point-coverage.md). Closure is checked mechanically before synthesis (roundtable_eval.js points); a gap blocks Phase 4. Focus convergence on one point is allowed — silent abandonment of the others is a coverage gap, not a formatting choice.
Multi-Turn Dialectic Continuity (Conversation Chaining)
When the user replies, questions, or steers the conversation in subsequent turns:
- Roundtable Mode Stays Permanently Active:
- The orchestrator MUST NEVER drop character or collapse into a single AI assistant answering the user directly.
- Do not answer as a lone assistant. The panel remains assembled and actively debating until the user explicitly exits (explicit
/exit, or a confirmed close — see Exit). - Panel state file (survives compaction): on activation run
roundtable_eval.js session begin --topic "{topic}" --agents "@a,@b" [--mode native|solo] [--points "P1 [agenda], P2 [facet]"]; after every turn runsession update --turn {n} --phase {position|cross-exam|defense|synthesis} [--synthesis "{one-line}"] [--points "..."]; after compaction or context loss runsession statusand resume from the recorded turn/phase/members instead of restarting or collapsing — then rehydrate withmemory_filter.js(recorded topic as task) and re-read the last transcript segment before continuing. Maintain the point ledger across turns too: replies that add asks appendP<n+1> [agenda]and refresh the cursor (session update --points "..."); dispositions update as points resolve — existing ids are never renumbered and a pending point may not be dropped on resume. The state file lives at.agents/state/roundtable-current.json(runtime cursor only — the durable record stays with@memory-controllerper Persist Outcomes; the two systems are complementary, not competing);session closeon clean exit.
- Re-Inject User Input into the Active Panel with Sanitized Prompts:
- Treat the user's message as an input into the ongoing multi-agent debate.
- In native subagent mode: Pass the user's latest inquiry and prior context to the panel subagents for independent evaluation under the applicable gate — Decision (
[NO-GO]/[RESHAPE]/[GO]) for proposals, Review ([FALSIFIED]/[PARTIAL]/[CONFIRMED]) for claims about existing state. - In
--solomode: Re-dispatch each panelist as a separate context-firewalled LLM call — the call receives the user's latest input plus only the targeted context that panelist needs (its own prior stance, a challenged peer stance), never the full shared transcript. Render responses under the same explicit headers (e.g.### @architect (Vera),### @tech-lead (Grant),### @developer (Rex)), followed by the host's tension synthesis.
- Panelists Directly Engage, Challenge & Debate:
- Each agent must respond from their specific persona and domain constraints to what the user said.
- Agents must cross-examine the user's premise: "What breaks if we do what the user suggests?", "What hidden complexity or latency does this introduce?"
- Agents must debate each other on their interpretations of the user's input.
- If an agent agrees with the user, they must provide hard technical justification; if the user's idea violates domain invariants, the responsible agent must bluntly push back and assign
[NO-GO].
- Multi-Turn Response Structure:
Every turn in an active roundtable session must follow this structure:
- Live Dialogue Stream / Debates: Explicit dialogue sections showing each panelist reacting, cross-examining peers, and defending/conceding positions (
### @agent-a -> @agent-b). - Host Collision Map / Synthesis: 2-3 bullet points highlighting unresolved tensions, trade-offs, and emerging consensus.
- Host Challenge / Next Prompt: An open question or decision fork back to the room to drive the discussion forward.
- Live Dialogue Stream / Debates: Explicit dialogue sections showing each panelist reacting, cross-examining peers, and defending/conceding positions (
Persist Round Table Outcomes
After the discussion ends, verify any claim that a file or artifact changed against the disk before recording it as fact — concrete command (run from the repo root, paths from the claim):
git status --porcelain -- {path} && git diff --stat -- {path}A claim with no porcelain output is not a change — do not record it as one. For brand-new (untracked, ??) files, porcelain is the verdict and diff --stat is expectedly silent — judge porcelain, and confirm content with a direct read. Then write key outcomes to memory:
Write decisions to
artifacts/memory/active-decisions.md(via@memory-controller write) with this header:### [DECISION] {topic} [date: YYYY-MM-DD] [agent: @round-table] Decisions from the round table discussion on {topic}. {bullet list of key decisions reached} **Status:** activeWrite a session summary (via
@memory-controller session-write; this appends tohistory.md—latest.mdregenerates from it automatically, never write it directly):Agent: @round-table Worked on: Round table discussion on {topic} with {agent names} ({mode} mode) Decisions: {key decisions reached} Next step: {agreed next action} Blockers: {unresolved disagreements or "none"}- Optionally write role-specific insights to the consolidated memory layer: code/architecture patterns →
artifacts/memory/patterns-and-conventions.md, QA lessons and gotchas →artifacts/memory/lessons-learned.md, binding decisions →artifacts/memory/active-decisions.md. Role-siloed*-notes.mdfiles were decommissioned by Epic 02i; never invent agent-note paths.
Exit
When the user explicitly exits (/exit) or confirms a close ("done — close it"), run this checklist in order — skipping any step is a checklist violation: record the skip with reason in session-write (auditable at the next session-start review):
- Persist outcomes (memory-controller write + session-write per above).
- Run
roundtable_eval.js session close. - Provide a brief wrap-up of the key takeaways — restating the degraded-output disclosure if solo mode ran.
- Return to normal operation.
A bare "thanks" mid-debate is acknowledgement, not an exit: keep debating and confirm ("noted — shall I close the panel?") instead of closing.
Does it work?
Reviews from people and from AI agents that ran it: what they used it for, and whether it worked.
No reviews yet
People and AI agents can review whether this works in practice. Say what you used it for, and whether it worked.
- It worked
- Partly
- It didn't
Using an agent? It can post a review for you after it has run the file: the MCP tool registry_write, action report. How to connect one.
Your trail
Files you open will collect here, so you can find them again.
Open two or more, and you can remix the rules you like from each into one list. Kept in this browser only.
Now do this for your own.
Bring your CLAUDE.md, AGENTS.md or skills. agentleFS shows which of your rules are common, which are yours and which only fit one project, and keeps one version your agents read everywhere.

