Discussion (Preview)

Discussion is Sophon's multi-agent deliberation feature. You define a topic, pick panelists (agents with differing perspectives), pick a judge, set the number of rounds, and start. The panelists debate in turn; the judge synthesizes and renders a verdict. It's useful for research, decision-making, and anywhere two or three perspectives beat one.

Agents can also invoke discussions themselves during a chat via the discussion.run tool — "let's have the reviewer and architect debate this design before I write code."

Concepts

• DiscussionDefinition — the spec: topic, panelists, judge, number of rounds.
• DiscussionRun — an instance: status, transcript of turns, final verdict, timestamps.
• Panelist — an agent (or LLM configuration) arguing a position.
• Judge — an agent (or LLM) that evaluates the transcript and renders a verdict.
• Round — one cycle where each panelist speaks once. You pick how many rounds.
• Turn — one panelist's contribution in a round.
• Verdict — judge's final structured output with reasoning and recommendation.

Starting a discussion

From the Dashboard

Discussions → New. Fill in:

• Topic (the question at hand)
• Panelists (pick 2–5; each can be a distinct agent or a one-off LLM persona)
• Judge (pick one agent or LLM)
• Rounds (default: 2)
• Round timeout (default: 180 seconds)

Click Start. The run appears in the Active tab and streams updates live.

From an agent

An agent can invoke a discussion as a tool:

discussion.run({
  topic: "Should we migrate our backend from SQLite to Postgres this quarter?",
  panelists: ["ada-architect", "nora-ops", "finance-agent"],
  judge: "cto-agent",
  rounds: 2
})

The tool is synchronous from the agent's perspective — it waits for the verdict and returns it, so the agent can continue the conversation informed by the outcome.

Lifecycle

Queued → Started → RoundStarted → TurnStarted → TurnCompleted → …
       (repeat per round)
       → JudgeStarted → Verdict → Completed
                                 ↘ Failed | Cancelled

Every state transition fires a SignalR event (discussion.started, discussion.round_started, discussion.turn_started, discussion.turn_completed, discussion.judge_started, discussion.verdict, discussion.completed, discussion.failed, discussion.cancelled). The Dashboard subscribes and renders live.

Execution model

Discussions run fire-and-forget in a background queue:

• A DiscussionRunWorker hosted service dequeues and executes one run at a time per tenant (no parallel discussions today).
• Each round has a global timeout (default 180 s). If a panelist doesn't respond within the round timeout, the round completes without their turn.
• If the Gateway crashes mid-discussion, the worker recovers on startup — stuck runs are marked Failed with a diagnostic message.

This isolates long discussions from the orchestration pipeline so they don't tie up chat resources.

The verdict

The judge receives the full transcript plus a structured prompt, and returns a verdict with:

• Summary — short paragraph of what was argued
• Decision — the judge's recommendation (yes / no / conditional / no consensus)
• Reasoning — why the judge weighted one panelist's argument over another
• Caveats — what the judge is uncertain about

The verdict is persisted alongside the transcript. You can query past discussions from the Dashboard or via GET /api/discussions/runs.

Managing runs

Dashboard

Discussions → Active shows running discussions with live turn updates. Runs shows history (completed / failed / cancelled) with filters for topic, date, judge, and outcome.

Click any run to see the full transcript side-by-side with the verdict.

CLI

sophon discussion list
sophon discussion start --topic "..." --panelists a,b,c --judge j --rounds 2
sophon discussion describe <run-id>
sophon discussion cancel <run-id>
sophon discussion verdict <run-id>

Cancelling

Click Cancel in the Dashboard or run sophon discussion cancel <id>. Cancellation flows through a cooperative cancellation token — the currently-running turn finishes; subsequent turns are skipped; the judge is not invoked. State transitions to Cancelled.

Limits and gotchas

• One discussion at a time per tenant. Parallel discussions aren't supported today.
• Panelists must have compatible capabilities. If you pick a panelist whose model doesn't support function calling but the topic requires tools, that panelist's turns will degrade gracefully.
• Round timeout is global, not per-panelist. A slow panelist in round 1 eats everyone's budget.
• Verdict quality depends on judge capability. Reasoning-tier judges produce better verdicts. Pick a capable model.
• Transcripts are saved verbatim. Don't discuss secrets you wouldn't put in memory.
• Preview status — the structure of DiscussionVerdict and some event shapes may change. Pin to a specific Sophon version if you build automation around discussion output.

Where to go next

• Agents & SOUL — pick panelists with distinct perspectives
• Tasks — discussions show up in the task ledger with nested child tasks per turn