Skip to main content
Glama

What is Threnody?

A local-first MCP meta-harness for developer workflows — small, auditable, and host-native, not a hosted swarm platform. Register it in Claude Code, Copilot CLI, Codex, Cursor, Junie, or OpenCode: Threnody plans and routes in MCP; the host shell executes via host_spawn / host_spawn_waves (Agent or Task subagents). When a handoff includes host_spawn_waves, spawn subagents — do not substitute direct edits on planned files.

execute_subtask is utility delegation only (opt-in): OpenCode, Aider, and local loopback endpoints — never other host CLIs. Same-host work returns HostNativeRequired with a spawn payload; host→host delegation returns HostDelegationBlocked. Claude Code is a router-only host by default.

On Claude Code, an opt-in mode (routing_policy.shells.claude-code.workflow_emit) emits tier-aware Dynamic Workflow scripts for fan-out plans — each agent() routes to its Threnody tier model, where a vanilla workflow runs every agent on the session model. Recurring shapes can be approved and saved as permanent /workflow commands.

For operators who want multi-agent coding without a permanent agent army, a second hosted control plane, or hidden coordination-token drift.


Related MCP server: Agent Squad Bridge

Install

Requires: Python 3.10+ and macOS or Linux for the supported installation paths. The full install.sh workflow expects at least one host AI CLI (gh, claude, codex, cursor-agent, junie, or opencode); the packaged MCP server can start without one for setup and diagnostics.

Claude Code plugin marketplace (recommended) — bundles the MCP server and nine routing skills, no shell restart:

claude plugin marketplace add timjensgrossinger/threnody
claude plugin install threnody@threnody

MCP package via uvx or pip — works with any MCP-aware host:

claude mcp add threnody -- uvx threnody-mcp
pip install threnody-mcp
threnody-mcp

The package entry point is a local stdio server. The packaged server can start for setup and diagnostics without a host CLI; THRENODY_ALLOW_NO_HOST=1 is only used by the full install.sh workflow to bypass its host-CLI check.

Full CLI install (adds ghc/ghcs/ghce aliases, syncs routing instructions; restart shell after):

curl -fsSL https://raw.githubusercontent.com/timjensgrossinger/threnody/main/install.sh | bash
# plugin-only (skips shell aliases): ... | bash -s -- --plugin-mode

For a configured power-user installation, run threnody settings to finish setup. The packaged stdio entry point does not run the interactive wizard.

Provider terms: Threnody is not affiliated with or endorsed by any AI provider. Credentials stay in provider-native stores; configure auth in each host CLI. See docs/LEGAL.md.

Docs: plugin install · limitations · legal · architecture


Compliance posture (defaults)

With default config, Threnody matches Anthropic's intended MCP pattern for Claude Code:

Control

Default behavior

Execution

Host runs work via Agent and direct edits — Threnody returns host_spawn / host_spawn_waves, not subprocess loops

Router-only

Claude Code is a coordination anchor; not a subprocess backend

Same-host execute_subtask

Returns HostNativeRequired with a spawn payload

Host→host delegation

HostDelegationBlocked — no subprocess to other CLIs from MCP

Utility delegation

Off by default; opt-in targets OpenCode, Aider, and local endpoints only

Routing policy

Advisory by default — route_task recommended, not mandatory; opt into guarded for coordination gates (docs/HOOKS.md)

Operator opt-in risk: Enabling providers.router_only_allow_execution can subprocess Claude Code. With subscription OAuth that pattern is documented as high policy risk in docs/LEGAL.md. Verify your auth mode and provider terms before changing defaults.


How it works

Host shell (Claude / Copilot / Codex / Cursor / …)
  → start_task / route_task / plan_task   returns next_action and host_spawn_waves for host-native work
  → host executes            Agent or Task subagents, direct edits (spawned from host_spawn_waves)
  → utility delegation       execute_subtask → OpenCode / Aider / local (opt-in)
  → swarm / learning         execute_swarm (host_native default), memory_*, learning_*
  1. Call the start_task tool (or route_task/plan_task) from your MCP host shell — start_task returns a compact next_action and optional host_spawn_waves for host-native execution.

  2. Threnody scores complexity → low / medium / high tier (no extra LLM call on the hot path). Pass target_files to route_task and the score also reflects the target code's security risk and size, rather than only the wording of the task; omit it and paths named in the task text are used. Security-sensitive work is floored to medium, and a target holding a high-severity security defect to high.

  3. route_task / plan_task return spawn metadata — host_spawn for single-agent, host_spawn_waves for multi-step plans.

  4. The host runs the work — Claude Code uses Agent; other shells use Task.

  5. Swarms or utility delegation — execute_swarm returns a host-native wave plan by default; execute_subtask only for utility backends when enabled.

Local-first: routing state, telemetry, and caches stay in local SQLite (~/.local/lib/threnody/); the MCP server talks to your host over stdio — no Threnody-hosted control plane. Outbound traffic comes only from the provider CLIs you invoke.


Features

Feature

What it does

🎯

Tier routing

Heuristic complexity scoring + host_spawn / execution_hint for host-native work

🧠

Learning loop

Pattern tracking → draft agents → approval queue → plan-time context injection. No auto-promotion; conservative recurrence/quality/rework gates

🐝

Swarm orchestration

execute_swarm returns host_spawn_waves by default; broad reviews default to one agent per file, deep review opts into file × dimension fanout; parallelism.max_workers throttles concurrency separately from plan size

⚡

Dynamic Workflows

Opt-in (claude-code): fan-out plans emit a tier-aware Workflow script; recurring shapes export to permanent /workflow commands

🧾

Receipts and run cards

cost_receipt + inspect_run_receipt(format=json|markdown|html) record plan, waves, model rationale, skipped calls, policy decisions, outcomes

🧩

Task packs and blueprints

Curated packs (security-review, test-gap, release-check); successful runs export to replayable workflow blueprints

🔬

Static pre-scan

Deterministic AST + pattern scan (zero tokens) sharpens review tiering, injects verified-or-refuted leads, and grades reviewers against ground truth

♻️

Prior-review memory

An unchanged (file revision × dimension) already covered at an equal-or-stronger tier is skipped and replayed; findings since fixed are suppressed

🪄

Hybrid diagnose→implement

One read-only high-tier diagnosis produces a change-spec, cheaper implementers execute it. Emits tiers only; the discount is learned per work profile, never hardcoded

✅

Baseline-diff verify gate

Lint/type/test graded against the merge base, so pre-existing red never blocks and only real regressions get a fix pass (in-process, zero tokens on the host path)

📚

Repo beliefs

Each run leaves a free pattern/constraint lesson; later runs get the most relevant ones injected, ranked by SQLite FTS × recency × recurrence (no embeddings)

🪜

Graded task ladder

threnody ladder run executes benchmark cases with deterministic graders on two axes: difficulty (L0–L6) and task kind (xss-fix, boilerplate-crud, refactor, …). Derives the minimum passing tier per model on each — so "which model is good at what" comes from graded outcomes rather than a hand-maintained mapping. Security cases use exploit-style graders that feed real payloads

💾

Cross-session memory

memory_* MCP tools backed by local SQLite, shared across all MCP hosts

🔌

MCP-native

53 published tools over stdio JSON-RPC; works with any MCP-compatible host

📈

Adaptive thresholds

EMA threshold learning from record_outcome (per-project, opt-in)

🛡️

Write safety

Path validation, outside-workspace grant model + audit trail

🔒

Guarded routing

Optional coordination gate + Claude PreToolUse hooks (routing_policy.mode: guarded)

Cross-CLI memory: all hosts share one SQLite store at ~/.local/lib/threnody/cache.db. Use global (no project_id), project (pass a stable absolute path, not "."), or task (explicit task_id) scopes. Do not store secrets — any connected host can read keys.

Adaptive routing: route_task returns a task_id; after work, call record_outcome(task_id=…, outcome=accepted|revised|rejected|reworked, actual_model=…) (also recorded as a proxy outcome score in the quality ledger). Enable per project with threnody tune set learning_enabled true --project ..


Project skills

Nine repo-local skills under skills/ guide MCP workflows from any host. install.sh installs them into provider-native roots (directory-style for Claude Code / Cursor / Codex; flat markdown for Copilot CLI / OpenCode).

install.sh also writes the five review-dimension agent definitions into each host's own definition directory, so a review fan-out does not repeat the same checklist in every agent prompt (prompt_economy.externalize_boilerplate). A definition you already have under the same name is never overwritten — your tuned reviewer is the better version of that file.

Skill

Use when

threnody-plan

Plan-only or plan-then-execute; waves vs swarm

threnody-routing

route_task, routing guard, host-native vs utility delegation

threnody-task

plan_task, decompose_task, fleet_plan, host_spawn_waves

threnody-swarm

execute_swarm, topology, budget preview, resume

threnody-fast-review

Default broad review swarm — one read-only agent per file plus synthesis

threnody-swarm-review

Deep review swarm — file × dimension fanout, optional [dims=...], ranked report

threnody-workflow

Claude Code tier-aware Dynamic Workflows; save /workflow commands

threnody-fullstack

Contract-first parallel frontend + backend + API

threnody-subtasks

Monitor opt-in utility execute_subtask runs


Supported providers

Provider

Binary

Role

Claude Code

claude

Host (router-only) — executes via Agent / direct edits

GitHub Copilot

gh

Host — executes via Task

OpenAI Codex

codex

Host — Task execution

Cursor

cursor-agent

Host — Task execution

OpenCode

opencode

Host + utility delegation target

JetBrains Junie

junie

Host / legacy paths

Aider

aider

Utility (opt-in delegation)

Amazon Q / Kiro · Mistral Vibe · Blackbox

q/kiro/vibe/blackbox

Secondary adapters / detect

Windsurf

windsurf

Detect only — never executes

Live matrix: threnody inspect status --project . --details. Full table: docs/PROVIDER_COMPATIBILITY.md


See it in action

plan_task("add JWT auth with tests")
→ host_spawn_waves: [
    { "wave": 1, "agents": [{ "tool": "Agent", "tier": "medium", "target_files": ["src/auth.py"] }] },
    { "wave": 2, "agents": [{ "tool": "Agent", "tier": "low", "target_files": ["tests/test_auth.py"] }] }
  ]
📋 Wave 1 — spawn Agent (host model) → src/auth.py
📋 Wave 2 — spawn Agent (host model) → tests/test_auth.py

Optional utility delegation (opt-in via providers.delegation_utilities_enabled):

execute_subtask(prompt="…", tier="low", provider_id="opencode")  → OpenCode utility backend
execute_subtask(prompt="…", tier="medium")                       → HostNativeRequired + spawn payload
execute_subtask(provider_id="codex")                             → HostDelegationBlocked

Shell commands

ghc agent "implement JWT auth for the user service"   # multi-agent waves
ghcs "how to list files recursively in python"        # quick routed call
threnody inspect status --project . --details         # provider readiness
threnody quality --since 7d                           # model quality ledger
threnody ladder run --tier low,medium,high            # graded ground truth (spends tokens)
threnody ladder run --provider codex                   # grade another host's tier models; in Claude Code use /threnody-ladder
threnody ladder run --stale                           # re-grade only tiers whose model changed
threnody db learn status                              # durable learning journal + table counts
threnody db learn rebuild                             # rebuild the DB's learning tables from the journal
threnody-watch                                        # live TUI monitor

Full reference: docs/CLI.md


Documentation

Doc

Contents

Plugin Install

uvx, plugin marketplace, --plugin-mode

MCP Tools

All 53 MCP tool surfaces

CLI Reference

Shell aliases and operator commands

Architecture

Trust boundaries and local-first design

Configuration

Safe starting config

Routing Quality

Eval methodology and accuracy

Host routing hooks

Claude PreToolUse guard script

Cost savings

Host-native vs utility delegation

Competitive positioning

Threnody vs heavy swarm platforms

Release Limitations

Beta scope, privacy, roadmap

Legal and Provider Terms

Operator responsibilities

Troubleshooting

Common fixes


Beta status

Public alpha v0.3.0-alpha.3 — MCP tool schemas may change between releases; pin a git tag for stability. macOS and Linux (zsh/bash); Windows not supported by the installer. See CHANGELOG.md.

Running tests

THRENODY_TEST_MODE=1 python3 -m pytest tests/ -q
THRENODY_TEST_MODE=1 python3 -m shared.routing_eval
python3 scripts/check_release_archive.py

Uninstall

~/.local/lib/threnody/uninstall.sh [--purge-data]

Threnody is an independent open-source project, not affiliated with or endorsed by Anthropic, OpenAI, GitHub, Google, Cursor, JetBrains, or any other provider named here. Provided "AS IS" under the Apache License 2.0 (no warranty). You are solely responsible for determining whether your routing patterns comply with each provider's current terms.

Operator responsibilities: docs/LEGAL.md · Third-party attributions: NOTICE

Built by @timjensgrossinger.

Available Tools

55 tools
agent_queue_approveC

Approve one pending approval-queue item for one project.

Inputs: queue_id (required), project_id (required), operator_id (required).

agent_queue_listC

List pending approval-queue items for one project.

Inputs: project_id (required), limit.

agent_queue_mergeC

Merge one pending approval-queue item into a canonical agent.

Inputs: queue_id (required), project_id (required), operator_id (required), canonical_agent_id (required), +1 more.

agent_queue_rejectC

Reject one pending approval-queue item for one project.

Inputs: queue_id (required), project_id (required), operator_id (required), reason.

apply_previewB

Approve or deny a pending outside-workspace file write preview created by execute_subtask.

Inputs: approve (required), preview_token (required).

approval_queue_approveD

Compatibility alias for agent_queue_approve.

Inputs: queue_id (required), project_id (required), operator_id (required).

approval_queue_listD

Compatibility alias for agent_queue_list.

Inputs: project_id (required), limit.

approval_queue_mergeD

Compatibility alias for agent_queue_merge.

Inputs: queue_id (required), project_id (required), operator_id (required), canonical_agent_id (required), +1 more.

approval_queue_rejectD

Compatibility alias for agent_queue_reject.

Inputs: queue_id (required), project_id (required), operator_id (required), reason.

cache_getA

Look up a cached result for a task.

Inputs: task (required).

cache_putC

Store a completed task result in the cache.

Inputs: task (required), model (required), result (required).

cache_statsB

Return cache statistics: total entries and breakdown by model.

Inputs: no named parameters.

check_providersA

List detected AI CLI providers with routeability, detection reason, model summary, and health status. Output is compact and secret-safe.

Inputs: no named parameters.

decompose_taskA

Alias for plan_task. Preferred entry point for multi-file or multi-concern tasks.

Calls the planner to decompose a task into independent subtasks with model tier assignments and dependency waves.

Returns:

  • analysis: planner reasoning

  • subtasks: list with id, description, tier, model, depends_on

  • waves: parallel execution groups

  • strategy: parallel | sequential | dag

Use this instead of route_task whenever the task spans more than one file, module, or concern. Spawn one agent per subtask; run waves in order.

Inputs: task (required), cwd.

execute_subtaskA

Execute a prompt via the cheapest available AI CLI provider.

Routes to the cheapest model for the given tier across all installed CLI tools (GitHub Copilot, Codex, Cursor, and others). Falls back to next cheapest on failure.

When target_file is provided, writes the result directly to that path and returns file metadata. This is the preferred way to create files for low-tier subtasks — saves tokens by avoiding round-trip through the main agent.

Surgical edit modes (set mode=): rewrite (full-file injection + length-ratio guard), blocks (Aider-style SEARCH/REPLACE, token-efficient), patch (unified diff).

Returns:

  • result: the model's response text

  • provider: which CLI tool was used

  • model: which model handled it

  • tier: the tier that was requested

  • fallback_used: whether a fallback provider was needed

  • file_written: path written to (when target_file is set)

  • lines_written: line count of written file

  • diff: unified diff showing changes (when target_file is set)

  • change_type: 'created', 'modified', or 'unchanged'

  • lines_added: number of lines added

  • lines_removed: number of lines removed

Inputs: prompt (required), mode, tier, effort, +8 more.

execute_swarmC

Start a swarm run; returns an immediate run contract (swarm_id, wave summary, cost estimate) or a budget preview.

Inputs: task (required), topology, task_spec, task_text, +6 more.

expand_host_planC

Expand a host-native swarm/plan run with additional file-scoped subtasks. Returns pending host_spawn_waves for discovered files not yet assigned.

Inputs: discovered_files (required), reason, run_id, swarm_id, +3 more.

fleet_planA

Plan a task AND format it for /fleet execution.

Calls the LLM planner to decompose the task, then produces ready-to-run /fleet command strings — one per wave, respecting dependency order.

Returns:

  • plan: full plan (same as plan_task)

  • fleet_waves: list of wave objects, each with: wave_number: int command: '/fleet "[tier] subtask1" "[tier] subtask2"' agents: list of {tier, model, prompt}

  • execution_note: how to run the waves

  • cache_hit: bool

Use this when you want copilot-router's model intelligence combined with /fleet's true parallel execution. Run wave 1 command, wait, run wave 2, etc.

Inputs: task (required).

inspect_qualityA

Return the granular model quality ledger: per-(model x effort x dimension x sub_dimension) average score (0-10), sample count, findings/judge breakdown, and approximate escalation rate for a time window. e.g. opus | high | security/sql-injection.

Inputs: since.

inspect_run_receiptC

Return an operator run receipt by run_id/swarm_id, as JSON, Markdown, or local HTML.

Inputs: format, run_id, swarm_id.

inspect_spendB

Return aggregated spend and savings telemetry from delegated subtasks (est_cost_usd vs counterfactual) and persisted cost receipts for a time window.

Inputs: since.

inspect_statusB

Return a compact readiness/status snapshot for one project, including enabled features, current limits, and pending approvals.

Inputs: project_id.

inspect_swarmB

Return compact swarm run summary from SQLite (status, progress, host metadata).

Inputs: swarm_id (required), run_id.

inspect_taskA

Return structured provider/model/tier telemetry and fallback/speculation flags for a previously routed task.

Inputs: task_id (required).

inspect_write_auditB

Return recent out-of-workspace write audit log entries.

Inputs: limit.

learning_agent_summaryA

Get summary of all learned agents by status (active, pending, rejected).

Returns compact agent list with description, lane, pattern hash, and status. Sensitive data (tokens, secrets) is filtered out.

Inputs: no named parameters.

learning_audit_logB

Get audit trail for agent creation, approval, and registration events.

Returns event stream with timestamps and operator identity. Sensitive fields (tokens, API keys) are filtered out.

Inputs: limit, agent_id.

learning_outcome_statsA

Get outcome distribution snapshot over 1-hour recent window grouped by tier and model.

Returns: outcome counts (accepted, revised, rejected, reworked) per tier:model combination, coverage percentage, and window timestamps. Aggregates are computed in background and retrieved from memory. Use for operator observability into routing quality by model.

Inputs: no named parameters.

learning_pattern_healthA

Get health metrics for the pattern tracking system.

Reveals: total patterns tracked, mature patterns ready for drafting, patterns awaiting proof, draft proposals in approval queue, and active agent count. Use to monitor learning loop maturity.

Inputs: project_id.

list_subtasksA

Return structured status of currently running and recently completed execute_subtask calls.

active: tasks currently executing (show elapsed time, model, prompt excerpt, target file). recent: last 10 completed or failed tasks this session.

Use this to monitor parallel execute_subtask calls — similar to /tasks for background agents.

Inputs: no named parameters.

list_task_packsA

List curated task packs for cheap repeatable planning.

Inputs: no named parameters.

memory_deleteC

Hard-delete one memory value from an explicit scope.

Inputs: key (required), scope (required), task_id, project_id.

memory_getC

Fetch one full memory envelope from an explicit scope.

Inputs: key (required), scope (required), task_id, project_id.

memory_listB

List keys and lightweight metadata for one explicit memory scope.

Inputs: scope (required), task_id, project_id.

memory_setC

Store or overwrite one memory value in an explicit scope.

Inputs: key (required), scope (required), value (required), task_id, +1 more.

plan_taskA

Ask the planner to analyse a coding task, decompose it into subtasks, and assign each subtask a model tier.

Returns an execution plan with:

  • analysis: the planner's reasoning

  • subtasks: list with id, description, tier, model, depends_on

  • waves: groups of subtask IDs that run in parallel

  • strategy: parallel | sequential | dag

Spawn one agent per subtask. Run waves in order — all subtasks within a wave run in parallel.

Inputs: task (required), cwd.

plan_task_packC

Plan a task using a curated task-pack preset.

Inputs: pack (required), task (required), cwd, max_agents.

record_outcomeC

Record an explicit routed-task outcome and persist the latest task snapshot. operator_id must match the authenticated caller when provided; omitted values are stored as anonymous.

Inputs: outcome (required), task_id (required), note, operator_id.

report_host_swarm_completeC

Terminal shortcut for host-native runs — equivalent to report_host_wave with terminal=true. Requires outcome.

Inputs: wave (required), agents (required), outcome (required), run_id, +2 more.

report_host_waveA

Report completion of one host-native swarm/plan wave. Call after spawning and finishing each host_spawn_waves wave. Pass workspace_root from the handoff (learning_report_contract) and per-agent output_excerpt for learning quality. Set terminal=true on the last wave with outcome=accepted|revised|reworked|rejected.

Inputs: wave (required), agents (required), run_id, outcome, +6 more.

report_workflow_resultA

Report the result of a Threnody-emitted Dynamic Workflow run (workflow_emit). Pass the workflow_name from the handoff and the agents[] array the workflow returned (each entry: id/label, tier, model, result{summary,findings,success}). Threnody records per-agent learning telemetry and, once the orchestration shape recurs across successful runs, enqueues it as an approval-gated draft you can approve to save as a permanent /workflow command.

Inputs: agents (required), workflow_name (required), run_id, consensus, +1 more.

resume_subtaskA

Send SIGCONT to a stopped subtask, resuming its execution. Use after stop_subtask. macOS/Linux only.

Inputs: task_id (required).

resume_swarm_confirmC

Resume a failed swarm from a chosen coordinator checkpoint using a new swarm_id.

Inputs: failed_swarm_id (required), checkpoint_index (required), plan_revision.

resume_swarm_inspectB

List compact coordinator checkpoints available for resuming a failed swarm.

Inputs: failed_swarm_id (required), plan_revision.

route_taskA

Quick heuristic classification of a task — no LLM call. Returns model, score, reason, agents. Use for simple tasks or when speed matters more than accuracy.

Inputs: task (required), cwd.

routing_exception_addA

Add a routing bypass rule so that matching tasks skip validate_routing_guard.

exception_type must be one of: skill, filetype, project, command, caller, path. pattern supports glob wildcards (e.g. 'tgsd-*', '.md', '/home/user/notes').

Examples: routing_exception_add(exception_type='skill', pattern='auto-time') routing_exception_add(exception_type='skill', pattern='tgsd-*') routing_exception_add(exception_type='filetype', pattern='.md') routing_exception_add(exception_type='project', pattern='/home/me/notes') routing_exception_add(exception_type='command', pattern='Write') routing_exception_add(exception_type='caller', pattern='github-copilot') routing_exception_add(exception_type='path', pattern='/tmp/')

Inputs: pattern (required), exception_type (required), note.

routing_exception_listA

List all active routing bypass rules (from the DB; static config.yaml entries are separate).

Inputs: no named parameters.

routing_exception_removeA

Remove a routing bypass rule by type and pattern.

Inputs: pattern (required), exception_type (required).

start_taskA

Start a host-native task handoff with modes implement, review, investigate.

implement: use host-native heuristics for simple tasks and return host_spawn_waves for the host to execute; for complex tasks return a planner handoff (no provider subprocesses launched). review: reuse read-only REVIEW fanout and return host_spawn_waves suitable for review (read-only). investigate: profile repository and return a machine-readable ProjectProfile; read-only.

Returns machine-readable next_action, profile, warnings, selected tier/model/provider metadata, and host_native handoff when applicable. Does not launch provider subprocesses.

Inputs: task (required), cwd, mode, workspace_root.

stop_subtaskA

Send SIGSTOP to a running subtask, pausing its execution. Use list_subtasks to find the task_id. Resume with resume_subtask. macOS/Linux only.

Inputs: task_id (required).

tune_showC

Show persisted operator-facing tuning controls for one project.

Inputs: project_id (required), key.

validate_routing_guardA

Validate whether a direct Edit or Write tool call is allowed for the current routed task context. Intended for Claude Code PreToolUse hooks.

Inputs: cwd, skill, tool_name, target_file.

workflow_blueprint_exportB

Export a successful host-native run receipt into a replayable workflow blueprint.

Inputs: name, run_id, swarm_id.

workflow_blueprint_runB

Replay a saved workflow blueprint with optional string replacements; no planner call.

Inputs: name (required), inputs.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    C2.5/5.0

    Scored across 55 tools

    Disambiguation2/5

    Multiple tools are direct aliases (e.g., approval_queue_list vs agent_queue_list), and several planning tools (plan_task, decompose_task, fleet_plan) have overlapping purposes with only subtle differences, creating confusion for agent selection.

    Naming Consistency3/5

    Most tools use snake_case but follow inconsistent patterns: some are verb_noun (inspect_status, list_subtasks), others are noun_verb (tune_show, memory_list), and some are noun_noun_verb (routing_exception_add). No single convention dominates.

    Tool Count2/5

    With 55 tools, the server is overly large. Many tools are redundant (aliases) or highly specific (e.g., resume_swarm_inspect, apply_preview), which could be consolidated. A more focused set would improve usability.

    Completeness4/5

    The server covers a wide range of agent management tasks: planning, execution, learning, caching, routing, workflow, and inspection. Minor gaps may exist (e.g., no generic project CRUD), but core operations are well represented.

    Maintenance

    ActivitySlowing
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • 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
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables a primary AI coding assistant to delegate tasks to multiple specialized CLI agents (such as Gemini, Claude, Codex, and Cursor) in parallel from a single prompt, sharing project context across all of them. It aggregates their outputs into one synthesized response while relying on the user's existing CLI tools and subscriptions.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables users to delegate tasks from a single prompt in their IDE to multiple specialized AI coding assistants such as Gemini, Claude, Codex, and Cursor, which run in parallel with shared project context. Aggregates and synthesizes their responses into one unified answer, using existing CLI tools and API subscriptions without extra cost.
      -