Skip to main content
Glama

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 connected

roundtable 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

Meeting

Talk with one persona on a chosen provider/model.

“Start a meeting via roundtable with cfo about our Q3 budget.”

Local meeting

Talk with a persona through your installed Claude CLI and login.

“Start a local meeting with product-lead about onboarding.”

Collaboration: collaborate

Personas take turns building a shared idea.

“Have cfo and product-lead collaborate on launch priorities for three rounds.”

Collaboration: debate

One proponent faces challengers.

“Have cfo defend our pricing plan against skeptic in a roundtable debate.”

Collaboration: waffle-house

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.”

Collaboration: conversation

Informal colleague chat with an optional theme and private grounding.

“Let cfo and product-lead chat about the launch in conversation mode.”

Ultraplan

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.”

Agent workshops

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.”

Prototype mode

Show ephemeral proposals on a local prototype board for assessment.

“Run a prototype collaboration on checkout with product-lead and skeptic.”

Casting Call

Audition personas for a brief; find redundancy, gaps and a recommended cast.

“Cast our personas for a bounded-memory queue module.”

Duel

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.”

Public sessions

Mirror an explicitly public session to ntfy or a webhook.

“Make that pricing debate public and give me the viewing link.”

Terminal command

Purpose

roundtable up, doctor

Set up, check your install (keys, git, Docker, Chrome) and start the local service.

roundtable cast

Audition personas and recommend a cast for a brief.

roundtable duel

Two teams build competing artifacts; judges assess them; dissents are recorded.

roundtable debate, waffle, meeting

Stream a discussion with per-seat models and spend.

roundtable preview

Preview a task's or prototype's dev server live in a locked-down container on 127.0.0.1.

roundtable config

Save env-file and persona-directory settings; show set/unset status.

roundtable agents

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_meeting

Start a conversation with one persona.

Meetings

say

Send a message in an API meeting.

Meetings

end_meeting

End an API meeting, optionally with a summary.

Meetings

list_meetings

List active API meetings.

Local meetings

start_local_meeting

Start a persona meeting on the local Claude CLI.

Local meetings

say_local

Send a message in a local meeting.

Local meetings

end_local_meeting

End a local meeting, optionally with a summary.

Local meetings

list_local_meetings

List active local meetings.

Collaborations

start_collaboration

Start a discussion between two or more personas.

Collaborations

continue_collaboration

Run additional rounds.

Collaborations

nudge_collaboration

Inject guidance without consuming an agent turn.

Collaborations

pause_collaboration

Pause after the current turn.

Collaborations

end_collaboration

End a discussion and return its transcript and optional summary.

Collaborations

get_collaboration_transcript

Read a discussion without ending it.

Collaborations

list_collaborations

List active collaborations.

Casting Call

casting_call

Audition personas and recommend a cast for any brief.

Duel

start_duel

Run a duel: two teams build competing artifacts, judges assess them, dissents are recorded.

Ultraplan

start_ultraplan

Collect input and begin a reviewed plan.

Ultraplan

submit_plan

Review a full plan version or collect final sign-offs.

Ultraplan

end_ultraplan

Close a plan without sign-offs.

Agent workshops

create_agent

Have specialists design and optionally save a new agent.

Agent workshops

improve_agent

Review and optionally update an agent with a backup.

Contracts

propose_contract

Turn a plan into a draft execution contract.

Contracts

amend_contract

Apply a versioned contract merge patch.

Contracts

freeze_contract

Freeze the current contract after consent.

Contracts (both servers)

file_dissent

File, complete or explicitly excuse a draft dissent.

Contracts

score_dissent

Record an advisory assessment of a dissent's prediction.

Runs

execute

Preflight and start an authorized frozen contract.

Runs

execution_status

Report progress, blockers, budget and context.

Runs

control_execution

Pause, resume, steer, abort or purge a run; stop an agent; write a handoff.

Runs

resolve_escalation

Decide, huddle, retry, reassign or amend after an escalation.

Runs

join_execution

Register an external worker and return its token once.

Postmortem

postmortem

Opt in per project, keep the running draft of findings, read lessons and records.

Postmortem

hold_postmortem

Hold the blameless meeting after the fixes, then conclude it with accepted artifacts.

Workers (both servers)

read_blackboard

Read shared run state and your inbox.

Workers (both servers)

claim_task

Claim or release an external worker task.

Workers (both servers)

lease

Request or release path leases.

Workers (both servers)

post_update

Post progress, notes, interfaces, needs, acknowledgements or an external worker's usage.

Workers (both servers)

run_command

Run structured argv or a contract check in the sandbox.

Workers (both servers)

submit_work

Checkpoint or submit leased changes for checks and merging.

Workers (both servers)

escalate

Raise a blocker, question, conflict or emergency.

Usage

usage

Report who is using what, stop an agent, write a handoff.

Completion

chat_completion

Call any of the six text providers directly.

Diagnostics

debug_env

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

mcp

Start an orchestrator or token-bound worker stdio server.

hook pre-tool-use

Check worker file access and leases using stdin hook JSON.

run <exe>

Run or recover a heads-down runner.

watch <exe> --as <name> [--timeout-min N]

Wait for one orchestrator wake, printing JSON.

status <exe> [--json]

Inspect a run's tasks, budget and health.

verify <exe> [--json]

Verify execution and audit chains.

purge <exe> --confirm

Delete a finished run's worktrees, branches and log.

statusline [--agents N] [--plain] [--no-host]

A Claude Code status line with the host and the roundtable's spend.

usage [--json] [--watch]

Who is using what, on which platform, measured or estimated.

stop <agent> [--execution <exe> | --session <id>] [--reason <text>]

Stop one agent, heads-down or at the table.

serve / notify

Keep runs alive, browse the private index and configure check-ins.

runtimes [--json]

Detect installed CLI runtimes.

agents [--json]

List or import personas, install the starter pack, open the library.

help

Print usage.

cast, duel, debate, waffle, meeting, config, secrets

Table commands: see at the table from the terminal.

Docs

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 tools
amend_contractA
Destructive

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_completionB
Read-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_executionA
Destructive

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_envA
Read-onlyIdempotent

Debug tool to check server environment and API key status.

Inputs: no named parameters.

end_collaborationB
Destructive

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_meetingA
Destructive

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_meetingA
Destructive

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_ultraplanA
Destructive

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.

executeA
Idempotent

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_statusB
Read-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_transcriptA
Read-onlyIdempotent

Get the full transcript of a collaboration without ending it.

Inputs: collaboration_id (required).

hold_postmortemA
Destructive

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_agentA
Destructive

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_collaborationsB
Read-onlyIdempotent

List all active collaborations.

Inputs: no named parameters.

list_local_meetingsA
Read-onlyIdempotent

List all active LOCAL meetings (CLI-based).

Inputs: no named parameters.

list_meetingsA
Read-onlyIdempotent

List all active meetings.

Inputs: no named parameters.

list_previewsB
Read-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_collaborationA
Idempotent

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_blackboardA
Read-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_escalationA
Idempotent

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_commandA
Destructive

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_previewB
DestructiveIdempotent

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).

usageA
Destructive

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

    A3.5/5.0

    Scored across 49 tools

    Disambiguation3/5

    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.

    Naming Consistency3/5

    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.

    Tool Count2/5

    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.

    Completeness4/5

    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

    ActivityActive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      Not graded
      maintenance
      Orchestrates 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.
      -
    • A
      license
      A
      quality
      C
      maintenance
      Enables 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.
      4
      5 npm
      Apache 2.0
    • A
      license
      Not graded
      quality
      C
      maintenance
      Enables 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