agent-roundtable
Server Configuration
Describes the environment variables required to run the server.
| Name | Required | Description | Default |
|---|---|---|---|
| OLLAMA_URL | No | Base URL for local Ollama server. Required for provider 'ollama'. Default: 'http://localhost:11434'. | |
| OPENAI_API_KEY | No | Required for provider 'openai'. No default. | |
| TOGETHER_API_KEY | No | Required for provider 'together'. No default. | |
| ANTHROPIC_API_KEY | No | Required for provider 'anthropic'. No default. | |
| REPLICATE_API_TOKEN | No | Required for provider 'replicate'. No default. | |
| ROUNDTABLE_AGENTS_DIR | No | Directory containing agent prompt markdown files. Default: '.claude/agents' relative to working directory; use absolute path. | |
| ROUNDTABLE_MAX_TOKENS | No | Max output tokens (thinking tokens count). Default: '8192'. | |
| OPENAI_COMPATIBLE_MODEL | No | Default model for 'openai_compatible'. Default: 'default'. | |
| ROUNDTABLE_OLLAMA_MODEL | No | Default Ollama model. Default: 'qwen3:14b'. | |
| ROUNDTABLE_OPENAI_MODEL | No | Default OpenAI model. Default: 'gpt-5.6-luna'. | |
| OPENAI_COMPATIBLE_API_KEY | No | Optional API key for 'openai_compatible'. Sent to whichever base URL is used when set. | |
| ROUNDTABLE_LLM_TIMEOUT_MS | No | Per-request timeout in milliseconds. Default: '600000'. | |
| ROUNDTABLE_TOGETHER_MODEL | No | Default Together model. Default: 'zai-org/GLM-5.3'. | |
| OPENAI_COMPATIBLE_BASE_URL | No | Required for provider 'openai_compatible' unless a base_url is passed per call. No default. | |
| ROUNDTABLE_ANTHROPIC_MODEL | No | Default Anthropic model (id or alias). Default: 'claude-opus-5'. | |
| ROUNDTABLE_REPLICATE_MODEL | No | Default Replicate model. Default: 'qwen/qwen3-235b-a22b-instruct-2507'. |
Instructions
Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.
This server publishes no instructions, or was last inspected before Glama recorded them.
Capabilities
Features and capabilities supported by this server
Protocol revision2025-11-25
| Capability | Details |
|---|---|
| tools | {} |
Tools
Functions exposed to the LLM to take actions
| Name | Description |
|---|---|
| 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. |
| sayA | Continue a conversation in an active meeting. In a prototype meeting you assess the agent's prototypes: give |
| end_meetingA | End a meeting and optionally get a summary. Prototype meetings also return the prototype outcomes and the shortlist for the human. |
| list_meetingsA | List all active meetings. |
| 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. |
| say_localA | Continue a conversation in an active LOCAL meeting (CLI-based). In a prototype meeting give |
| end_local_meetingA | End a LOCAL meeting and optionally get a summary. Prototype meetings also return the prototype outcomes and the shortlist for the human. |
| list_local_meetingsA | List all active LOCAL meetings (CLI-based). |
| chat_completionB | 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). |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| pause_collaborationA | Pause a running collaboration. Resume it with nudge_collaboration (continue_collaboration only advances a running collaboration). |
| end_collaborationB | 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). |
| get_collaboration_transcriptA | Get the full transcript of a collaboration without ending it. |
| list_collaborationsB | List all active collaborations. |
| 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. |
| 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. |
| end_ultraplanA | 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. |
| 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. |
| improve_agentA | 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. |
| debug_envA | Debug tool to check server environment and API key status. |
| 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. |
| 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. |
| 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 |
| amend_contractA | 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. |
| 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. |
| executeA | 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. |
| execution_statusB | 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. |
| control_executionA | 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. |
| resolve_escalationA | 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. |
| 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. |
| hold_postmortemA | 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). |
| read_blackboardA | 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?"). |
| 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. |
| 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). |
| 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. |
| run_commandA | 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). |
| 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. |
| 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. |
| 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. |
| 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. |
| 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. |
| 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 |
| list_previewsB | The running dev-server previews: id, url, what they show and the page check. |
| stop_previewB | Stop a preview and remove its container. |
| usageA | 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). |
Prompts
Interactive templates invoked by user choice
| Name | Description |
|---|---|
No prompts | |
Resources
Contextual data attached and managed by the client
| Name | Description |
|---|---|
No resources | |
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.