agent-roundtable
A multi-agent collaboration server that lets you convene persona-based meetings and multi-agent discussions across six LLM providers, then optionally hand off to autonomous execution.
1:1 meetings with personas —
start_meeting/say/end_meeting/list_meetingsrun a synchronous API-backed conversation with an agent (e.g. CFO, FP&A, Product), with optional context docs, model and provider selection.Local (subscription) meetings —
start_local_meeting,say_local,end_local_meeting,list_local_meetingsrun the same flow through your installed Claude CLI and login instead of API credits.Multi-agent collaborations —
start_collaborationhas 2+ personas take turns building on each other's ideas over configurable rounds, withcontinue_collaboration,pause_collaboration,nudge_collaboration(orchestrator injection),get_collaboration_transcriptandend_collaboration(with optional summary of agreements, disagreements and action items).Multi-provider model access — every tool accepts a
provider(anthropic, openai, together, replicate, ollama, openai_compatible) plusmodel,base_urloverrides, so seats can be pinned to different models.Direct LLM calls —
chat_completionfor raw system/user/assistant message completions withmax_tokensandtemperaturecontrol.Diagnostics —
debug_envinspects configuration and API-key presence without exposing key values.Broader platform (per README) — the full server exposes 43 tools covering ultraplans, agent workshops, casting calls, duels, dissents, and heads-down parallel execution with budgets, leases, escalations and postmortems, plus a 15-subcommand CLI.
Enables using local Ollama instances as a provider, allowing offline model access for meetings, collaborations, and chat completions.
Provides access to OpenAI's Chat Completions API for meetings, collaborations, and direct chat completions with configurable models.
Integrates with Replicate's predictions API, allowing models to be called via owner/name, version, or URL.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@agent-roundtable Start a collaboration between the CEO and engineer personas on the Q3 roadmap"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
agent-roundtable
Agents talk it out at the table, then go heads-down. An MCP server for multi-agent collaboration across six LLM providers: discuss, challenge and agree on a plan, then execute a contract with parallel workers, budgets and human oversight. Runs locally over stdio with Claude Code or any MCP client. Requires Node 22.19+.
Install and register with Claude Code
npm install -g agent-roundtable
claude mcp add --scope user roundtable \
-e ROUNDTABLE_AGENTS_DIR="$HOME/my-project/.claude/agents" \
-- roundtable mcp
claude mcp list # roundtable should show as connectedroundtable mcp starts the orchestrator server, the same as running the binary with no arguments. Without the global install, use -- npx -y agent-roundtable@2.0.0 or -- node /absolute/path/to/dist/index.js (a source checkout). --scope user makes it available in every project; leave it out (or use --scope project) to register it for one project only. Then ask Claude Code to "list the roundtable tools": you should see the 43 tools, named mcp__roundtable__<tool>.
Create personas in that directory or install the starter pack with roundtable agents starter. Set keys for the providers you use; local meetings use your Claude CLI login. For source installs, .env, add-json and project .mcp.json registration, see getting started and configuration. After a rebuild, reconnect with /mcp.
Related MCP server: modelmux
Other ways to install
A Docker image recipe, a Claude Code plugin and an MCP registry listing are described in distribution. Until the package is published to npm, the npx and plugin paths do not resolve.
Modes
At the table
Ask in chat; the host calls the tools and keeps session ids for follow-ups.
Format | What it does | Example prompt |
Talk with one persona on a chosen provider/model. | “Start a meeting via roundtable with cfo about our Q3 budget.” | |
Talk with a persona through your installed Claude CLI and login. | “Start a local meeting with product-lead about onboarding.” | |
Personas take turns building a shared idea. | “Have cfo and product-lead collaborate on launch priorities for three rounds.” | |
One proponent faces challengers. | “Have cfo defend our pricing plan against skeptic in a roundtable debate.” | |
A defender refines an idea through repeated attacks and rebuttals. | “Run a two-round waffle-house: product-lead defends one-click checkout against cfo and skeptic.” | |
Informal colleague chat with an optional theme and private grounding. | “Let cfo and product-lead chat about the launch in conversation mode.” | |
Collect input, review revisions and record sign-offs on a plan. | “Ultraplan the launch with product-lead, cfo and skeptic; show the final document verbatim.” | |
Specialists create or improve an agent and reusable skills. | “Have cfo and skeptic create a budget agent, then improve product-lead's escalation rules; preview both.” | |
Show ephemeral proposals on a local prototype board for assessment. | “Run a prototype collaboration on checkout with product-lead and skeptic.” | |
Audition personas for a brief; find redundancy, gaps and a recommended cast. | “Cast our personas for a bounded-memory queue module.” | |
Two teams build competing artifacts (a page, code, a diagram or a document); judges assess them; dissents are recorded. | “Run a duel on a rate limiter module with architect and engineer against pragmatist and reviewer, judged by security-lead.” | |
Mirror an explicitly public session to ntfy or a webhook. | “Make that pricing debate public and give me the viewing link.” |
Terminal command | Purpose |
Set up, check your install (keys, git, Docker, Chrome) and start the local service. | |
Audition personas and recommend a cast for a brief. | |
Two teams build competing artifacts; judges assess them; dissents are recorded. | |
Stream a discussion with per-seat models and spend. | |
Preview a task's or prototype's dev server live in a locked-down container on | |
Save env-file and persona-directory settings; show set/unset status. | |
Browse and import personas, install the starter pack, or open the library drop zone. |
Heads-down
Heads-down runs execute an agreed, frozen contract in parallel task worktrees with leases, checks, a watchdog and escalations. Example: “Execute the approved contract with a $20 budget and a dashboard; keep me posted here.” See the example contract.
Postmortem mode is opt-in per project: while testing sends fixers back the orchestrator keeps a draft of every finding, then the agents that did the work meet it (the human has no seat) and leave lessons that are read before the next plan. Example: “Turn on postmortem meetings for this project.”
Tools
43 tools on the orchestrator server; 8 on worker servers. The seven execution worker tools appear in both; the orchestrator's copies also require execution_id and agent_token. Dissent filing is also available on both servers. The table follows the registered definitions in src/tools/*.ts; full arguments and examples.
Group | Tool | Purpose |
Meetings | Start a conversation with one persona. | |
Meetings | Send a message in an API meeting. | |
Meetings | End an API meeting, optionally with a summary. | |
Meetings | List active API meetings. | |
Local meetings | Start a persona meeting on the local Claude CLI. | |
Local meetings | Send a message in a local meeting. | |
Local meetings | End a local meeting, optionally with a summary. | |
Local meetings | List active local meetings. | |
Collaborations | Start a discussion between two or more personas. | |
Collaborations | Run additional rounds. | |
Collaborations | Inject guidance without consuming an agent turn. | |
Collaborations | Pause after the current turn. | |
Collaborations | End a discussion and return its transcript and optional summary. | |
Collaborations | Read a discussion without ending it. | |
Collaborations | List active collaborations. | |
Casting Call | Audition personas and recommend a cast for any brief. | |
Duel | Run a duel: two teams build competing artifacts, judges assess them, dissents are recorded. | |
Ultraplan | Collect input and begin a reviewed plan. | |
Ultraplan | Review a full plan version or collect final sign-offs. | |
Ultraplan | Close a plan without sign-offs. | |
Agent workshops | Have specialists design and optionally save a new agent. | |
Agent workshops | Review and optionally update an agent with a backup. | |
Contracts | Turn a plan into a draft execution contract. | |
Contracts | Apply a versioned contract merge patch. | |
Contracts | Freeze the current contract after consent. | |
Contracts (both servers) | File, complete or explicitly excuse a draft dissent. | |
Contracts | Record an advisory assessment of a dissent's prediction. | |
Runs | Preflight and start an authorized frozen contract. | |
Runs | Report progress, blockers, budget and context. | |
Runs | Pause, resume, steer, abort or purge a run; stop an agent; write a handoff. | |
Runs | Decide, huddle, retry, reassign or amend after an escalation. | |
Runs | Register an external worker and return its token once. | |
Postmortem | Opt in per project, keep the running draft of findings, read lessons and records. | |
Postmortem | Hold the blameless meeting after the fixes, then conclude it with accepted artifacts. | |
Workers (both servers) | Read shared run state and your inbox. | |
Workers (both servers) | Claim or release an external worker task. | |
Workers (both servers) | Request or release path leases. | |
Workers (both servers) | Post progress, notes, interfaces, needs, acknowledgements or an external worker's usage. | |
Workers (both servers) | Run structured argv or a contract check in the sandbox. | |
Workers (both servers) | Checkpoint or submit leased changes for checks and merging. | |
Workers (both servers) | Raise a blocker, question, conflict or emergency. | |
Usage | Report who is using what, stop an agent, write a handoff. | |
Completion | Call any of the six text providers directly. | |
Diagnostics | Inspect configuration and key presence without key values. |
CLI
No arguments starts the orchestrator MCP server. The binary has 15 subcommands, plus 7 table commands that run at the table from a terminal (cast, duel, debate, waffle, meeting, config, secrets). Both are documented in the CLI reference; roundtable is a second name for the same binary.
Subcommand | Purpose |
| Start an orchestrator or token-bound worker stdio server. |
| Check worker file access and leases using stdin hook JSON. |
| Run or recover a heads-down runner. |
| Wait for one orchestrator wake, printing JSON. |
| Inspect a run's tasks, budget and health. |
| Verify execution and audit chains. |
| Delete a finished run's worktrees, branches and log. |
| A Claude Code status line with the host and the roundtable's spend. |
| Who is using what, on which platform, measured or estimated. |
| Stop one agent, heads-down or at the table. |
| Keep runs alive, browse the private index and configure check-ins. |
| Detect installed CLI runtimes. |
List or import personas, install the starter pack, open the library. | |
| Print usage. |
| Table commands: see at the table from the terminal. |
Docs
Distribution: Docker, Claude Code plugin, MCP registry and the owner release checklist
Mode guides: collaborations, ultraplan, agent workshops, prototypes, public sessions, postmortems
Heads-down user guide and design specification; postmortem design specification
Usage visibility: the status line, the usage report, the dashboard Usage page and stopping an agent
At the table from the terminal:
duel,debate,waffle,meeting, per-seat models and replayDuel and the demo recording script
CLI runtimes at the table: installed agents alongside API providers
Secrets broker and connectors (workers and seats at the table)
Security
Read the security policy and private reporting instructions, and the October 2026 audit.
Contributing
Build and run npm test before a pull request. See contributing for test isolation and checks.
License
Apache License 2.0; see also NOTICE.
Available Tools
49 toolsamend_contractADestructive
Amend a contract with an RFC 7396 merge patch (objects merge, arrays replace, null deletes) to produce v(N+1). Only its orchestrator may. A draft gets a new proposal; a frozen contract is amended in force: removed tasks are cancelled and the agents of affected tasks get a directive to re-read it. from_session (an archived replan or ultraplan) first replaces the structure with that session's roundtable-tasks block (pass patch: {}). id, version, status, consent, frozen, the scope's orchestrator, repository, base commit and parent, and the goal's original_prompt cannot change. Consent counts only for the version it was given on. A draft amendment needs every participant's consent again before a freeze: consent: true asks them all, and an objector who now agrees has the objection resolved by the amendment. On a frozen contract, a run-wide change (budget, scope, sandbox, authority, validation, workers, connectors, goal, dissents) needs consent: true (everyone is asked about it first, and it applies only if all agree) or override_consent: true (audited); other changes apply at once, and consent: true then asks the personas of affected tasks. patch: {} with consent: true just asks everyone without an agreement on the current version. Returns the affected tasks, the consent outcome and the contract markdown.
Inputs: patch (required), reason (required), contract_id (required), orchestrator (required), +6 more.
await_subtasksA
Wait for your latest subtask batch (default 30 seconds, at most 120). Returns child states, scrubbed summaries, changed files and merge status. ready: true means every child merged and the runner brought integration into your worktree. When children are still running, call again. Failed or cancelled children are reported for you to retry with new ids or escalate.
Inputs: agent_token (required), execution_id (required), timeout_s.
casting_callA
Audition 2 to 24 personas for any brief. A neutral casting director cross-examines their claims, identifies redundancy and gaps, and recommends a cast (with duel teams when at least four seats are requested). Returns the roster in markdown, archive id and usage. Runs the whole casting call with progress notifications on every visible step. dry_run performs static checks without keys or provider calls.
Inputs: brief (required), mix, seat, model, +10 more.
chat_completionBRead-only
Call an LLM for text completion. Providers: anthropic (claude-opus-5-5 / claude-sonnet-5-5), openai (gpt-5.6-luna), together (Together AI), replicate (any Replicate text model), ollama (local, optional), openai_compatible (any /v1/chat/completions server).
Inputs: messages (required), model, base_url, provider, +2 more.
claim_taskA
External agents only: claim a ready task (all dependencies accepted, nobody holding it) or, with release: true, give yours back (its leases are released; the work stays in the worktree). Without task_id, the first ready task (your team's first) is claimed. Returns the task card and the worktree to work in. External workers' claims expire after 15 minutes without a tool call.
Inputs: agent_token (required), execution_id (required), note, release, +1 more.
continue_collaborationA
Continue an active collaboration for additional rounds. Agents take turns responding. In a prototype session it also resumes a paused session while a prototype is under assessment.
Inputs: collaboration_id (required), rounds.
control_executionADestructive
Steer a heads-down run when the human asks. pause / resume: the whole run, or only task_ids (paused work starts nothing new; running workers finish their turn). steer: a directive (message) to targets (agents, teams or tasks; default every agent), which workers must acknowledge. abort: stop the run and its workers, keeping the worktrees, branches and log. purge: delete a finished (completed, failed or aborted) run's worktrees, branches and log; needs confirm: true, which only the human's agreement justifies, and is audited. stop_agent: stop the live workers named in targets (the human asked, in plain words or from the dashboard): the runner stops each worker, keeps its branch and worktree and blocks its task, and the watcher wakes you with two choices: rework around the stopped agent with resolve_escalation, or write a handoff. An external worker is told to stop through steer instead. handoff: pause the run (if live) and write executions//HANDOFF.md from the blackboard (contract summary, goal, every task with its state, owner, branch and last note, stopped agents, open escalations, budget with provenance split, resume commands); returns its path and the document. Back to the table: pause with to_table: true (recorded in the log as a mode change), run the format with execution_status(view: "context"), amend_contract(from_session), then resume with to_table: true.
Inputs: action (required), execution_id (required), reason, confirm, +5 more.
create_agentA
Have specialists design a new Claude Code subagent in one call: sequential contributions, architect draft, independent reviews, then revision if needed. Pass agents and task, or from_session (the id of a live collaboration or meeting, e.g. collab-4k9q2mzt, or of any ended session in the archive) to inherit participants, topic and discussion; explicit agents are combined with inherited ones. Each contributes expertise, guardrails and skills. Default write: true saves the agent to ROUNDTABLE_AGENTS_DIR and new skills to ROUNDTABLE_SKILLS_DIR; existing agents are never overwritten. write: false previews files without writes. Creation includes the destination project's .claude/skills in lookup even when the configured skills directory differs. Skill lookup follows Claude Code precedence: personal ~/.claude/skills, then .claude/skills beside the agent file when it is in .claude/agents, then ROUNDTABLE_SKILLS_DIR. Any skill found is reused, never overwritten or shadowed. Tools fail closed: a list with no allowlisted matches or a value of the wrong type is rejected and the architect retries once. Omitting tools gives the new agent tools: Read, Grep, Glob. The result reports actual paths, warnings and next delegation instructions: use Claude Code's Agent tool with the returned agent.name as subagent_type when saved in .claude/agents, or start_meeting. perform_task: true with writes starts a private meeting on the task; follow its next instructions with say and end_meeting. Public workshops post contributions, reviews and a redacted summary of the final definition (name, description, model, tools, skill names and status, contribution credits, changes and open questions), without its system prompt, skill instructions or descriptions derived from instructions; copied private passages in summary fields are withheld. They never post context, personas, fleet listings or source-session transcripts.
Inputs: name, task, model, write, +8 more.
debug_envARead-onlyIdempotent
Debug tool to check server environment and API key status.
Inputs: no named parameters.
end_collaborationBDestructive
End a collaboration and optionally get a summary of the discussion. Prototype sessions also return the prototype outcomes and the shortlist for the human (resolved prototypes appear as stubs in the transcript).
Inputs: collaboration_id (required), request_summary.
end_local_meetingADestructive
End a LOCAL meeting and optionally get a summary. Prototype meetings also return the prototype outcomes and the shortlist for the human.
Inputs: meeting_id (required), request_summary.
end_meetingADestructive
End a meeting and optionally get a summary. Prototype meetings also return the prototype outcomes and the shortlist for the human.
Inputs: meeting_id (required), request_summary.
end_ultraplanADestructive
Close an ultraplan WITHOUT collecting sign-offs. Returns a markdown document marked not signed off with the latest plan, agent input and revision history (or no plan if none was submitted). Show the document to the user verbatim. Use submit_plan with final: true instead when you want sign-off.
Inputs: ultraplan_id (required).
escalateA
Raise an escalation when you are blocked or something is unclear. kind: blocker, ambiguity, resource, conflict, assistance or emergency; with: orchestrator, management, team, agent or path_owner (target: the agent or path). blocking: true blocks your task: end your turn with a one-line summary and you will be resumed with the resolution. emergency: money, credentials, scope or human_action.
Inputs: kind (required), with (required), summary (required), agent_token (required), +7 more.
executeAIdempotent
Start a heads-down run of a frozen contract, ONLY when the human has asked for it in this chat: confirmation is their words, verbatim (recorded in the event log and the audit log). A preflight runs first. When something is missing it returns {status: "needs_input", questions[]} and starts nothing: ask the human each question in plain words and call again with the answers. It asks when no visibility is chosen (dashboard, GitHub, or chat_only; ROUNDTABLE_DEFAULT_VISIBILITY sets a default), when no budget is set (here, in the contract, or ROUNDTABLE_DEFAULT_BUDGET_USD), when no sandbox is available (Docker down and the local sandbox not allowed with sandbox: "local"), when the worker CLI is missing or lacks flags (codex needs worker_driver: "codex", a runtime worker needs ROUNDTABLE_ALLOW_RUNTIME_WORKERS=1), when GitHub was asked for but gh lacks scopes or access, and when the repository has submodules. A dirty main worktree only warns. Settings given here that differ from the contract (budget_usd, max_parallel, lead, sandbox, worker_driver, worker_model) are applied to it first as one audited amendment. Then the runner starts in the background, and the result has the execution_id, the runner's pid, the dashboard URL (when there is one) and watch {argv, command, instructions}: start watch.command as a background shell command right away, re-arm it after handling each wake, and answer progress questions with execution_status. Calling it again for a started run returns the run's current info.
Inputs: contract_id (required), confirmation (required), lead, sandbox, +5 more.
execution_statusBRead-onlyIdempotent
How a heads-down run is doing. Without execution_id: every run with its status. With one, view summary (default) gives weighted completion (accepted 1, submitted 0.8, otherwise the worker's percent or 0.4), blockers, the latest checks, a rough ETA, the budget, runner health, the dashboard URL and GitHub sync health; tasks, escalations, events (since_seq, limit), budget and context are the other views. focus answers questions such as "how close is the nav?": fuzzy words and prefixes matched against task ids, titles, teams, paths and interface names ("nav" finds build-nav-bar and src/components/nav/**); an escalation id as focus picks that escalation for view context. view context returns a redacted bundle (no chat, no secrets) to pass to a format at the table. Restarts the runner of a live run that lost it.
Inputs: view, focus, limit, since_seq, +1 more.
file_dissentA
File or update a structured dissent on a draft contract, creating a new version. Tripwires are data only. An agent files as its authenticated identity; an orchestrator may file for any participant. A dissent needs a tripwire before freeze or explicit excusal with a reason. Frozen contracts require amend_contract and consent.
Inputs: dissent (required), contract_id (required), agent_token, execution_id, +3 more.
freeze_contractA
Freeze a contract so it can be executed. Only its orchestrator can, and only once every participant has agreed to its current version. Refuses, listing every reason, while an objection or UNCLEAR answer is unresolved, a participant has not answered about the current version, a consent round is in flight (abandon_round declares a dead one abandoned), the source session is busy, or, for a child contract, while the parent is not frozen or the caller is neither the parent task's persona nor the parent's orchestrator. excuse sets objections aside, each with a reason; excusals and the frozen sha256 go to the audit log. Freezing starts nothing: the run starts with execute, when the human asks.
Inputs: contract_id (required), orchestrator (required), excuse, abandon_round.
get_collaboration_transcriptARead-onlyIdempotent
Get the full transcript of a collaboration without ending it.
Inputs: collaboration_id (required).
hold_postmortemADestructive
Hold the postmortem meeting for a draft, then conclude it. Refused while any finding's fix is pending or a task with a finding is still running (the error names what); a draft with no findings closes with no meeting. action hold (default): every agent named in a finding, every agent that did the original work in the run (or the participants you pass), and you sit at the table. opening is your account of what happened, including your own part: turn 0. The format is waffle-house when exactly one agent is responsible for every finding (it defends, the others challenge, your opening is the charge), otherwise collaborate for rounds (default 2, 1-4); format forces either. The meeting is private and takes no outside input: the human has no seat, nothing they type reaches it, and its context never carries their chat, confirmation or original request. It ends with an artifact block, one line each: Artifact: | | | . Kinds: fix (follow-up), rule and contract rule (project lessons, read before the next plan and contract), persona addendum (appended to an agent's persona file under ## Postmortem addenda, with a backup), agent rule (shown in that agent's task card), memory (the agent's memory file; memory_target: "claude" also writes the repository's .claude/agent-memory). Dissent score artifacts carry a dissent id, finding ids, an outcome (vindicated/refuted/untested) and supporting evidence; the meeting context and docs/modes/postmortem.md give the exact artifact syntax. The reviewed run’s dissents are included; scores remain advisory. Accepting one requires orchestrator (the contract’s orchestrator identity) and project opt-in; it uses the same scoring path as score_dissent. The result has the transcript, the proposed artifacts and any lines that could not be used. action conclude: pm, your closing statement, and accept[] (artifact ids) / reject[{id, why}]. Only accepted artifacts take effect, each audited. The result has a summary and the record path to relay to the human, who can read every turn (postmortem read).
Inputs: pm, work, model, accept, +13 more.
improve_agentADestructive
Refine an existing Claude Code agent in one call, preserving its identity and useful instructions. By default the target reviews itself candidly; add specialists with with or inherit participants/discussion via from_session (the id of a live collaboration or meeting, or of any ended session in the archive). They suggest gaps, replacements, skills and cuts; an architect drafts the definition, participants review independently, and the architect revises if needed. The target is an agent name or a .md path inside the agents directory, /.claude/agents, ~/.claude/agents or a directory listed in ROUNDTABLE_AGENT_PATHS. write: false previews without writes. Frontmatter is read the way Claude Code reads it, including one quoting and leading-tab recovery pass. Exactly the keys Claude Code sees are preserved; improve refuses files Claude Code cannot parse or whose frontmatter contains '---' inside a value, with an error asking you to fix the file first. Identity collision checks use the same metadata view. Model output only supplies name/description/model/tools/skills. Only one improve run per target is allowed; a second fails fast: improve_agent is already running for ; wait for it to finish. Default write: true saves .bak-, then atomically replaces via a temp file and rename, keeping the original mode. If the target changed, was renamed or was deleted during the run it is not overwritten: changes go to .proposed-, which is not an agent file and keeps the original mode; next explains recovery. Creation includes the destination project's .claude/skills in lookup even when the configured skills directory differs. Skill lookup follows Claude Code precedence: personal ~/.claude/skills, then .claude/skills beside the agent file when it is in .claude/agents, then ROUNDTABLE_SKILLS_DIR. Any skill found is reused, never overwritten or shadowed. New skills go beside a target in .claude/agents to its project's .claude/skills only if neither .claude nor .claude/skills is a symlink and the skills realpath stays inside the project. Otherwise they fall back to ROUNDTABLE_SKILLS_DIR with a warning. Results report file realpaths, warnings and next instructions. Tools fail closed: a list with no allowlisted matches or a value of the wrong type is rejected and the architect retries once. Omitting tools keeps the target's own tools line; a target without one keeps inheriting every tool, and the result warns: tools omitted: the target has no tools line, so it still inherits every tool; list tools to restrict it. Public workshops post contributions, reviews and a redacted summary of the final definition (name, description, model, tools, skill names and status, contribution credits, changes and open questions), without its system prompt, skill instructions or descriptions derived from instructions; copied private passages in summary fields are withheld. They never post context, personas, fleet listings or source-session transcripts. Public improve runs never include the target's recent activity in any prompt; contributors, reviewers and the architect point to passages rather than reproduce them. Private improve contributor prompts include recent topics and outcomes from the local activity log.
Inputs: agent (required), with, focus, model, +8 more.
join_executionA
Register an external worker (for example this chat, or another host) in a heads-down run. Returns an agent_token ONCE: pass it with execution_id to every worker tool (read_blackboard, claim_task, lease, post_update, run_command, submit_work, escalate, spawn_subtasks, await_subtasks). With task_id, the task's worktree is created (or reused) and its task card returned. External workers are not sandboxed: their leases are checked when they submit.
Inputs: agent (required), execution_id (required), team, task_id.
leaseA
Request or release leases on repository paths (globs: , * and ?; no braces). You may edit only what your leases cover; .git metadata needs a lease that names it. A request that conflicts with another agent's lease is queued (FIFO), and the response names the holders: then escalate(with: "path_owner"). release takes lease ids or globs ("*" releases all of yours).
Inputs: paths (required), action (required), agent_token (required), execution_id (required), +2 more.
list_collaborationsBRead-onlyIdempotent
List all active collaborations.
Inputs: no named parameters.
list_local_meetingsARead-onlyIdempotent
List all active LOCAL meetings (CLI-based).
Inputs: no named parameters.
list_meetingsARead-onlyIdempotent
List all active meetings.
Inputs: no named parameters.
list_previewsBRead-onlyIdempotent
The running dev-server previews: id, url, what they show and the page check.
Inputs: no named parameters.
nudge_collaborationA
Inject a message from the orchestrator into the collaboration. Use to redirect discussion, ask clarifying questions, or provide additional context. In a prototype session nudges are refused while a prototype is under assessment; never use a nudge to relay the human's feedback on prototypes before the session ends.
Inputs: message (required), collaboration_id (required).
pause_collaborationAIdempotent
Pause a running collaboration. Resume it with nudge_collaboration (continue_collaboration only advances a running collaboration).
Inputs: collaboration_id (required).
postmortemA
Postmortem mode: while testing sends fixers back, you keep a running draft of every finding; when all fixers are done the agents that did the work meet with you (hold_postmortem) and leave actionable artifacts, kept per project and read back before the next plan. Off by default: action enable turns it on for a project ONLY when the human asked for postmortem meetings, retrospectives, or agents improving themselves or each other; reason quotes their words verbatim (recorded in the project's log and the audit log). Nothing infers it. A heads-down run inherits it from its contract (propose_contract sets it); the runner then records a finding by itself when a submission is sent back after testing. disable turns it off and keeps stored postmortems. record adds a finding to the draft of a scope (execution_id for a run, or work for at-the-table work): {summary, detected_by, responsible[] (persona names, or "orchestrator"), category, task?, evidence[] (refs only: sha256: blob refs, event ids, commit shas, paths)}. fix sets a finding's fix {status: pending|fixed|abandoned, by?, ref?}; in a run, retries, merges and failures update fixes by themselves. draft returns the findings, what is still pending and whether the meeting can be held. lessons returns the active lessons of a project (always, whether or not the mode is on); list shows its drafts and postmortems; read returns a postmortem's full record (every turn) for you to show the human verbatim.
Inputs: action (required), pm, fix, work, +5 more.
post_updateA
Post to the blackboard. kind progress: percent and text. note: a broadcast note (topic, refs). interface: publish an interface you own (name, text = its definition, path), which unblocks tasks waiting on it. need: say you are waiting for a task, interface or artifact (name; topic = task | interface | artifact), which blocks your task until it arrives. ack: acknowledge a directive (directive_id). usage (external workers only): report what you have used since your last report (tokens, usd, model); it is recorded as reported, not measured, and counts toward the budget.
Inputs: kind (required), agent_token (required), execution_id (required), usd, +10 more.
propose_contractA
Turn an agreed plan into a heads-down contract: a draft v1 in a new execution, which workers build in parallel once every participant consents and you freeze it. The structure comes from, in order: contract (an explicit object with tasks: the most reliable route), the last ```roundtable-tasks JSON block in plan or in the archived from_session (an ultraplan started with execution_ready: true ends with one), or a structuring call on the plan text (one retry quoting the validation errors). A contract object without tasks overlays the structure (budget, sandbox, workers, authority, scope.paths, ...). original_prompt is the human's request, verbatim (default: the session's task). repo_dir (default the workspace) resolves to its git top level and base_ref (default HEAD) to a commit. Participants default to the session's agents plus every task persona. consent: true asks each participant for Consent: AGREE | OBJECT (an unclear answer is re-asked once, then counts as an objection). Nothing is written to the repository: the contract lives under ROUNDTABLE_HOME/executions. Returns the contract as markdown and a JSON summary (contract_id, version, status, warnings, consent, next). Show the contract to the human before freezing.
Inputs: goal (required), orchestrator (required), plan, model, +14 more.
read_blackboardARead-onlyIdempotent
Read the shared blackboard of this heads-down run: what every task, team and agent is doing. section: summary (default), goal, contract, tasks, task (task_id, default yours), interfaces, decisions, leases, claims, files, diffs, checks, escalations, notes, inbox, budget, agents, teams, events (filters: since_seq, limit, task_id, query = event type prefix), blob (ref: a sha256:… ref from an event; redacted, at most 16 KB), or query: fuzzy matching over tasks, teams, paths and interfaces ("is the nav done?").
Inputs: agent_token (required), execution_id (required), ref, limit, +4 more.
resolve_escalationAIdempotent
Answer an escalation the watcher woke you for (execution_status(view: "escalations") lists them). action: decide (decision is the answer, delivered to the requester, who resumes), huddle (a format with participants: micro by default, or meeting, collaborate, debate, waffle-house, conversation, replan, ultraplan; calls the provider), retry, reassign (participants[0] takes the task over), amend (amendment is a merge patch of the contract), dismiss, or await_human (only when the human must act). resolved_by defaults to the contract's orchestrator. An escalation already resolved is returned unchanged. The runner applies any resume, retry or stop on its next tick.
Inputs: action (required), execution_id (required), escalation_id (required), model, +7 more.
run_commandADestructive
Run a command in the sandbox, in your task worktree (there is no shell). command_id runs a contract command (recorded as a check of your task); argv runs an ad-hoc program with its arguments. Returns the exit code, a failure signature and the last ~8 KB of output; the full output is stored as a blob (read_blackboard section blob).
Inputs: agent_token (required), execution_id (required), argv, timeout_s, +1 more.
sayA
Continue a conversation in an active meeting. In a prototype meeting you assess the agent's prototypes: give Verdict on Pn: APPROVE|REVISE|REJECT — reason on its own line, grounded in the artifact and its demo; the reply ends with a Prototypes block (the board URL, live prototypes and those destroyed this call).
Inputs: message (required), meeting_id (required).
say_localA
Continue a conversation in an active LOCAL meeting (CLI-based). In a prototype meeting give Verdict on Pn: APPROVE|REVISE|REJECT — reason for the agent's prototypes; the reply ends with a Prototypes block.
Inputs: message (required), meeting_id (required).
score_dissentA
Record or revise an advisory dissent outcome on a frozen contract. Only its orchestrator may score. Scores are display-only and never weight votes or consent.
Inputs: outcome (required), dissent_id (required), contract_id (required), orchestrator (required).
spawn_subtasksA
Delegate 1–8 subtasks through the runner when the frozen contract enables swarms. Child ids are namespaced under yours. Paths must be within your current leases and must not overlap siblings. Children inherit your checks; only siblings in this call may be dependencies. Delegated paths are unavailable to you until the children finish. Subtasks cannot delegate.
Inputs: subtasks (required), agent_token (required), execution_id (required).
start_collaborationA
Start a collaboration where agents take turns responding; returns a collaboration ID. Default collaborate builds on ideas. Debate has agents[0] defend a position against challengers; waffle-house distills an idea through repeated attacks and rebuttals. Conversation is an informal chat from each agent's own situation, with short turns and no agenda or deliverable; topic is optional only in conversation mode. In conversation mode, put what you know about the agents' current situation in context (what was just built, what each agent last did). Private conversations default to grounding from workspace, memory and local activity; public conversations never get grounding, never open on the founder angle, and their directive does not ask agents to talk about the founder or whoever they report to. Pass prototype: true (not with conversation) to have agents show proposals as ephemeral prototypes that the other agents assess. Continue, nudge, inspect or end with the collaboration tools.
Inputs: agents (required), duel, mode, model, +15 more.
start_duelA
Run a duel and return its result: two teams each build an artifact for the same brief (a web page, code, a Mermaid diagram or a text document), judges assess both against a rubric, and the losing side files dissents. The call runs the whole duel, which can take several minutes and sends a progress notification on every turn, artifact and verdict; the host's request timeout must be long enough or reset on progress. No room is opened. The result has the duel id, winner, tally, each team's artifact title, kind and ok flag, the judges' verdicts, the dissents, a usage summary and the archive id (duels/.json, replayable with roundtable duel --replay). It never includes artifact source.
Inputs: topic (required), judges (required), team_a (required), team_b (required), +11 more.
start_local_meetingA
Start a LOCAL meeting with an agent using the installed Claude CLI. This uses your Claude Pro/Max subscription instead of API credits. Returns a meeting ID for follow-up messages. Ideal for cost-conscious lengthy conversations. Pass mode: "debate" to have the agent stress-test your agenda as a challenger instead. Pass prototype: true to have the agent show its proposals as ephemeral prototypes that you assess.
Inputs: agent (required), agenda (required), duel, mode, +6 more.
start_meetingA
Start a meeting with an agent. Returns a meeting ID for follow-up messages. Use this to begin a synchronous conversation with another agent (CFO, FP&A, Product, etc.). Pass mode: "debate" to have the agent stress-test your agenda as a challenger instead. Pass prototype: true to have the agent show its proposals as ephemeral prototypes that you assess.
Inputs: agent (required), agenda (required), duel, mode, +11 more.
start_previewA
Preview a web app live: run a heads-down task's dev server (execution_id and task_id) or a duel prototype directory (prototype) in a locked-down Docker container, published on 127.0.0.1 only (no tunnel, never 0.0.0.0). It runs the package's dev, start or preview script (script picks one) as npm run <script>; the server must listen on 0.0.0.0 and honour PORT. When the source has no installed packages the dependencies are installed inside the container, through a proxy that allows only the npm registry, with lifecycle scripts off. Returns the preview id and its http://127.0.0.1: url, and the page check. The dashboard task page, the duel room and the serve index embed it. Idle previews stop after 30 minutes; at most 3 run at once.
Inputs: port, script, task_id, prototype, +1 more.
start_ultraplanA
Plan with specialist agents: you (the orchestrator) own and write the plan; agents give input before the draft, review each version, then sign off. With no draft_plan, returns input and awaiting_plan: write v1 with contributor tags such as [cfo], then call submit_plan. With draft_plan, reviews it as v1 and returns awaiting_revision. Revise in response to amendments, explaining rejected advice; call submit_plan with final: true to collect sign-offs and close. Alternatively set planner to a persona to draft/revise/sign off server-side in one call. If that run returns a step with error, the session remains open. A step with phase: "plan" returns the unreviewed latest version and previousReviews when an earlier version was reviewed. Continue with submit_plan: omit plan to review or sign off that version as-is, or pass a full revised plan; or close with end_ultraplan. Show the final document to the user verbatim, including every agent's input and sign-off. The final result ends with a JSON trailer {ultraplan_id, archived, tally}; signed off means no OBJECT and no UNCLEAR sign-off. With execution_ready: true, plans end with a roundtable-tasks block and sign-offs check it, so propose_contract { from_session: ultraplan_id } can build a contract from it. Public runs post the task and phase outputs, never context.
Inputs: task (required), agents (required), duel, model, +12 more.
stop_previewBDestructiveIdempotent
Stop a preview and remove its container.
Inputs: preview_id (required).
submit_planA
Submit a full next plan version, or omit plan to review or sign off the latest version as-is without creating a version. This also recovers a stopped planner run with phase: "plan". If no version exists yet, pass plan. You write revised plans from agent input/reviews; tag contributing agents on steps and explain which amendments you accepted or rejected and why. Default final: false collects independent reviews and leaves the session awaiting_revision. Set final: true to collect sign-offs, close, and return the final markdown document; with a supplied plan this is allowed straight after input without a review. Show that final document to the user verbatim, including input and sign-offs. A failed phase leaves the previous state intact so you can retry.
Inputs: ultraplan_id (required), plan, final.
submit_workA
Commit your leased changes and submit them. ready: true submits the task: the diff is recorded and your task's checks run in the sandbox (at most 15 minutes); if they pass, the runner merges it; if one fails, fix it and submit again. Changes outside your leases reject the submission. ready: false only saves a checkpoint commit.
Inputs: ready (required), summary (required), agent_token (required), execution_id (required).
usageADestructive
Who is using what, on which platform, for the heads-down runs and the sessions at the table. action report (default) returns the usage view: totals, platforms (provider and models), and one entry per agent with its tokens and money, where it works (heads-down, at-the-table or the host), its state and whether it can be stopped, plus recent stops. Each agent's calls list bounded-call provenance (source, dissent id, execution/task, charged identity, provider/model), estimated USD and outstanding reservations; usage reports replace reservations by call id. Every figure says whether it is measured (counted by whoever did the work), reported (told to us by an agent or the host) or estimated (worked out by us); a total that mixes them shows the split. Money for a model with no price is absent: you get its tokens instead. Narrow it with execution_id, session_id or agent ("what has cfo cost so far?"). Nothing in it is message text, a prompt, a diff or command output. stop (only when the human asks you to stop an agent): stops agent, a heads-down worker (the runner stops it, keeps its work, and wakes you with two choices) or an at-the-table session (its turn in flight is cut and the session ends; name execution_id or session_id when the agent is in more than one place). A stopped session answers {status: "stopped", …} to its next tool call. Stopping a micro-huddle participant routes its unresolved escalation, retains dispatched unreported spend as estimated, releases unused allowance and preserves dissent holds for explicit resolution. handoff: write a handoff document, for a stopped or ended session (session_id: sessions/.handoff.md) or for a heads-down run (execution_id: HANDOFF.md, without pausing it; control_execution(action: "handoff") pauses first).
Inputs: agent, action, reason, session_id, +1 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 49 tools
The descriptions are extraordinarily detailed and usually spell out exactly when to use each tool (e.g. pause is resumed with nudge_collaboration, not continue_collaboration), which rescues many borderline pairs. However there are near-duplicate families that differ only by billing path: start_meeting vs start_local_meeting, say vs say_local, end_meeting vs end_local_meeting, list_meetings vs list_local_meetings, plus several sibling session starters (start_collaboration, start_duel, start_ultraplan, casting_call, chat_completion) that an agent can easily mispick. postmortem vs hold_postmortem and execute vs execution_status vs control_execution also require reading long text to separate.
The dominant pattern is snake_case verb_noun (start_meeting, end_collaboration, submit_work, resolve_escalation), which is readable and mostly predictable. But the set mixes pure-verb tools (execute, escalate, lease), noun-only tools (usage, postmortem, chat_completion, casting_call), and an inconsistent _local suffix convention that applies to only four of the meeting tools rather than a consistent scope qualifier.
49 tools is very heavy for a single MCP surface and far exceeds the 3-15 sweet spot. The domains are genuinely broad (chat, meetings, collaborations, ultraplans, contracts, executions, blackboard/worker ops, previews, usage, agents, postmortems), but the near-duplicate local/remote meeting quadruplets show the count is inflated by parallel variants that could be one tool with a mode flag.
Coverage is unusually thorough: full contract lifecycle (propose/amend/freeze/execute/status/control), worker primitives (claim, lease, post, run, submit, escalate, spawn/await), previews, usage accounting, and postmortem remediation all have tools. Minor gaps exist — no listing/deletion of created agents, no way to inspect a duel afterwards beyond the inline result, and no delete/discard for archived sessions — but these are workable around.
Maintenance
Related MCP Connectors
Real-time chat hub for AI agents — Claude Code, Cursor, Cline, Codex over MCP or REST.
Real-time chat for AI agents. Claude Code, Cursor, Cline and Codex join channels over MCP.
Multiplayer for the coding agents your team already uses: shared tasks, decisions, skills and tools.
Rooms where Claude, ChatGPT and other AI agents talk to each other and to people. Free to start.
Related MCP Servers
- FlicenseNot gradedqualityNot gradedmaintenanceOrchestrates multiple AI models (Gemini, OpenAI, Claude, local models) within a single conversation context, enabling collaborative workflows like multi-model code reviews, consensus building, and CLI-to-CLI bridging for specialized tasks.-
- AlicenseAqualityCmaintenanceEnables AI agents like Claude Code, Codex, and Perplexity to call each other as tools directly from the terminal, supporting text, code, images, and PDFs passed by file path.45 npmApache 2.0
- AlicenseNot gradedqualityDmaintenanceProvides a local chat room for coordinating work across Git worktrees, coding agents (Claude, Codex), and humans, with tools to start, wake, stop, message, and search agent sessions.Apache 2.0
- AlicenseNot gradedqualityCmaintenanceEnables multiple AI coding CLIs (Claude Code, Gemini/Antigravity, Codex, and OpenCode) to collaborate as a coordinated team by routing cross-agent prompts, sharing messages and review tickets, tracking tasks on a shared store, and isolating each agent in its own Git worktree with turn-budget safeguards—all inspectable and steerable from a local web dashboard.MIT