Skip to main content
Glama

run_subagent

Submit a task to a local AI sub-agent, receiving a run ID for asynchronous execution, or wait for the result directly when blocking execution is preferred.

Instructions

Submit a local Fluxion executor as a sub-agent task.

By default (wait_for_result=false) this returns as soon as the task is queued: you get a run_id — poll get_task_status and read get_task_result once terminal. Set wait_for_result=true for small smoke checks that should block until done; if the wait elapses first the task continues in the background (queued or running, bounded by task_timeout_sec) and is collected later via get_task_result with the run_id (the run is not canceled). For long or open-ended work prefer the default. timeout_sec only limits this blocking wait; it is not the executor runtime limit. The actual task execution cap is settings.task_timeout_sec.

agent: "auto" (default; uses the configured default) or one of "claude", "codex", "antigravity".

workspace: directory the agent runs in. With a configured project, "." is the project root. WITHOUT a project (the default), pass an ABSOLUTE path to the target repo — "." resolves against the server's workspace_root, not the caller's cwd, so it is rarely what you want. Use list_projects to see configured projects.

profile/mode: for edit/fix/implement tasks set profile=implement and mode=workspace-write; the defaults profile=inspect / mode=read-only are intentionally read-only.

Workspace authorization: an unapproved workspace makes this call wait in place for the user to approve the notification Fluxion just raised (up to FLUXION_MCP_AUTHORIZATION_WAIT_MS, default 60s), then run normally — so an approved task usually needs no follow-up at all. If the user has not answered by then it returns error_code=WORKSPACE_NOT_AUTHORIZED with pending=true and an authorization_request_id. That is a pending HUMAN decision, not a transient failure, so retrying right away cannot succeed: call wait_for_authorization with that id instead of ending your turn to ask the user to report back. Retry this call only when the wait reports approved (pass the same id) or project-allowed (pass no id). If it reports denied, report the refusal instead of re-requesting.

task_name: optional free-form label for the run. It is shown as-is in the UI and also slugified into the agent-path segment (lowercased, non [a-z0-9] runs collapsed to _), so spaces, uppercase, and hyphens are all accepted — no need to pre-format it.

model: optional per-run model override for executors that support model selection. Leave empty to use the executor's configured/default model. To choose explicitly, call list_agent_models first and pass one of the returned models[].id values. Do not pass price_references[].id; those entries are pricing context only and may not be accepted by the executor. model is not a provider selector: provider, base URL, and auth remain settings-level configuration. Ping tasks keep their cheapest-model default unless model is explicitly set.

reasoning_effort: optional per-run reasoning depth, e.g. "low", "medium", "high", "xhigh", "max". Valid values differ per model — read models[].supported_reasoning_efforts from list_agent_models; asking for one a model does not publish returns error_code=MODEL_UNRESOLVED listing what it does publish, rather than silently running at a neighbouring effort. Leave empty for the model's own default. Antigravity encodes effort in the model id (gemini-3.7-flash-high); pass models[].id plus reasoning_effort and Fluxion selects the published variant, or pass one of models[].variants verbatim. The run payload reports what was actually used as effective_model / effective_reasoning_effort.

thread / session_policy scope which executor session is reused. Default (empty thread) = a FRESH isolated session per call: independent tasks don't resume, so they can't inherit stale context or have their workspace edits reconciled away by a resumed agent. To CONTINUE a prior run (resume — reuses the agent's context, saving tokens), pass the SAME stable thread string on each call. session_policy is "auto" (default), "continue", or "new" (force a brand-new session even for a reused thread). Note: a resumed Antigravity run may reconcile the workspace to its remembered state, so avoid editing the workspace out-of-band between two same-thread runs.

Results: both are finalized only at terminal status (changed_files_available stays false until then). changed_files is the authoritative, run-scoped list of what THIS run touched — act on it. diff_summary.files mirrors that count, but its additions/deletions are NOT measured per run and are always 0, flagged by lines_counted=false — a whole-tree git diff --stat would fold in pre-existing edits and earlier runs, so no line total is reported rather than a misleading one. For exact line counts, run git diff over the changed_files yourself.

artifacts is not an inventory of files the run produced: it lists only files the agent explicitly declared for delivery via ACTIONS_JSON.upload_files, which it is prompted to do only when asked to send files. Screenshots and other by-products of the work appear in changed_files, not here.

Input Schema

TableJSON Schema
NameRequiredDescriptionDefault
modeNoread-only
agentNoauto
modelNo
promptYes
threadNo
profileNoinspect
projectNo
client_idNomcp
task_nameNo
workspaceNo.
parent_pathNo/root
timeout_secNo
include_stdoutNo
session_policyNoauto
wait_for_resultNo
reasoning_effortNo
authorization_request_idNo
include_subagent_preambleNo

Output Schema

TableJSON Schema
NameRequiredDescriptionDefault

No arguments

Schema Changelog

Changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. Changed1 schema field changedv1.6.0
    • addedInput schema / properties / reasoning_effort
      Added value: +{
      +  "default": "",
      +  "title": "Reasoning Effort",
      +  "type": "string"
      +}
  2. Changed2 schema fields changedv1.5.0
    • addedInput schema / properties / authorization_request_id
      Added value: +{
      +  "default": "",
      +  "title": "Authorization Request Id",
      +  "type": "string"
      +}
    • addedInput schema / properties / client_id
      Added value: +{
      +  "default": "mcp",
      +  "title": "Client Id",
      +  "type": "string"
      +}
  3. Addedv1.2.0
  4. Removedv1.0.11
  5. First observedv1.0.1

TDQS

A4.8/5.0
Behavior5/5

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

With no annotations provided, the description carries the full burden — and it delivers. It discloses the queued-return behavior, that timeout_sec is not the runtime limit, that a pending WORKSPACE_NOT_AUTHORIZED is a human decision rather than a transient failure, that retrying immediately cannot succeed, that resumed Antigravity runs may reconcile the workspace, and that diff_summary.additions/deletions are always 0 with lines_counted=false to avoid misleading numbers. These are exactly the behavioral traits an agent cannot infer from a schema.

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?

The description is long, but every paragraph earns its place given 18 parameters plus async, authorization, and session semantics; the essential async/wait model is front-loaded. It loses a point for being a dense wall of paragraphs — parameter-by-parameter explanations in a long prose format lack visual scannability for an agent, and the wait_for_result/timeout story is told with some redundancy across the first and third paragraphs.

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 tool of this complexity — async lifecycle, authorization gate, session reuse, per-run model overrides, and result-interpretation traps — the description is remarkably complete. It covers the full operational flow (submit → poll → collect, with the authorization detour), the actual runtime cap (settings.task_timeout_sec), and even interprets output semantics (changed_files authoritative, artifacts only via ACTIONS_JSON.upload_files) beyond what the output schema would convey. The four lightly-documented parameters are minor and carry sensible defaults.

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 description coverage is 0%, so the description must compensate — and it covers most of the 18 parameters in depth, going far beyond names: workspace path resolution against server workspace_root, agent enum values, profile/mode defaults vs. edit-task recommendations, task_name slugification rules, the price_references trap for model, reasoning_effort per-model validity with the MODEL_UNRESOLVED fallback, and thread/session_policy reuse semantics. Minor deduction: client_id, parent_path, include_stdout, and include_subagent_preamble receive no explanation, which with 0% schema coverage leaves small gaps.

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 'Submit a local Fluxion executor as a sub-agent task' names a specific verb and resource, and the submission role is unambiguous against the sibling set (wait_for_authorization, get_task_status, cancel_subagent_run, get_task_result all handle lifecycle stages, not submission). The description goes further by clarifying the async submission semantics, so an agent knows exactly what this entry point does.

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?

The description gives explicit when-to-use guidance with named alternatives: use wait_for_result=true for 'small smoke checks', prefer the default for long/open-ended work, call list_agent_models before choosing a model, use list_projects to resolve configured projects, and call wait_for_authorization instead of retrying on a pending decision. It also states explicit exclusions: do not pass price_references[].id, and do not retry until the wait reports approved. This is exemplary routing and exclusions.

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

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/superposed-labs/fluxion-bus'

If you have feedback or need assistance with the MCP directory API, please join our Discord server