Skip to main content
Glama

execute

Idempotent

Starts a background run of a frozen contract after verbatim human confirmation, preflights required settings, and returns the execution ID plus commands to watch progress.

Instructions

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.

Tool call template

Replace each placeholder with a value matching the input schema. Only required parameters are included; add optional parameters as needed.

{
  "id": 1,
  "jsonrpc": "2.0",
  "method": "tools/call",
  "params": {
    "arguments": {
      "contract_id": "<contract_id>",
      "confirmation": "<confirmation>"
    },
    "name": "execute"
  }
}

Input Schema

NameRequiredDescriptionDefault
leadNoThe persona that decides escalations when you are away (the contract's authority.lead).
sandboxNodocker (default) or local. local is weaker than a container and counts as the human's opt-in to it.
budget_usdNoThe run's total budget in US dollars, as the human set it (applied to the contract).
visibilityNoHow the human follows the run: dashboard (a local web page), github (issues and a project board), or chat_only (neither). Ask the human; dashboard and github may be combined.
contract_idYesThe frozen contract (ctr-<6 characters>-<n>).
confirmationYesThe human's own words asking you to execute, quoted verbatim (e.g. "yes, go ahead and build it"). Never invent it.
max_parallelNoWorkers at once (1–16; applied to the contract).
worker_modelNoModel for the workers (the CLI's model name).
worker_driverNoWorker CLI: claude-code (default), codex (an explicit opt-in) or runtime:<name>, a runtime profile such as runtime:gemini (needs ROUNDTABLE_ALLOW_RUNTIME_WORKERS=1).

Schema Changelog

Changes observed during successful MCP inspections.

  1. Addedv2.0.0

TDQS

A4.8/5.0
Behavior5/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations declare the safety profile (readOnly=false, destructive=false, openWorld=true, idempotent=true), and the description adds substantial non-redundant behavior: a preflight that starts nothing, the exact {status:"needs_input", questions[]} contract, enumerated missing-input conditions, the warn-only dirty worktree, audited amendments, and background start with pid and dashboard URL. The re-call behavior is consistent with idempotentHint, so there is no contradiction.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

It is long, but front-loaded with the hard constraint before the procedural detail, and nearly every sentence carries actionable information (preflight, needs_input contract, amendment rule, watch re-arm). A few of the enumerated preflight clauses are dense run-on lists that could be tightened, but nothing is filler.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a nine-parameter, nested-object, no-output-schema tool with side effects, the description compensates fully: it describes the failure return shape, the success return shape (execution_id, pid, dashboard URL, watch argv/command/instructions) and what to do with each. An agent has everything needed to invoke it correctly and handle both outcomes.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 100%, so the baseline is 3, but the description adds real meaning: it lists the settings (budget_usd, max_parallel, lead, sandbox, worker_driver, worker_model) that become an audited amendment when they differ from the contract, and explains the visibility/dashboard/GitHub/chat_only choice and its defaults. It stops short of syntax or format detail for individual fields, which the schema already carries.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The opening sentence states a specific verb and resource — "Start a heads-down run of a frozen contract" — and immediately distinguishes it from the status-check path by naming execution_status for progress questions. An agent can tell what this does and what it is not without opening the schema.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines5/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

It gives an explicit gating condition ("ONLY when the human has asked for it in this chat"), defines the evidence required (verbatim confirmation), and separates follow-up behavior ("Calling it again for a started run returns the run's current info") from progress questions, which route to execution_status. Nothing about when to invoke is left to inference.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.