subtask

Name: subtask
Author: tedin7

by tedin7version 0.5.9i★ –iRuns on your computer

Registry nameio.github.tedin7/subtask

Install

Overview

Description from the maker (original English)

Background sub-agents for Claude Code, Codex, Kimi and OpenCode, over MCP, with a spend cap.

PopNx MCP’s three pillars

These three are never merged into one score: opinions, measurements and popularity are different things.

User voiceiNo reviews yetReviews open together with accounts in a later step
Our basic checksi1 of 1 passedChecked from public information; code not scanned yet
UsageiNot measured yet★ –

What you can do with it

We have not written a plain-language summary for this one yet. Below are the facts we read from the registry.

Connection: Runs on your computer
Transport: stdio
Category: Other

Install

Pick the AI app you use, then copy the settings.

Before you install

Basic checks: 1 of 1 passed
Runs on your computer with your user’s permissions (files, network, apps).
The registry lists no key to fill in.

You need

PyPIPython’s uv installed (for the uvx command)

Which app do you use?

ClaudeClaude CodeCursorVS CodeChatGPT

Pick your app above. We remember it, so next time the button says “Install in …”.

Open Claude Desktop → Settings → Developer → Edit Config, and paste this into claude_desktop_config.json

{
  "mcpServers": {
    "subtask": {
      "command": "uvx",
      "args": [
        "subtask-mcp"
      ]
    }
  }
}

Run this in your terminal

claude mcp add subtask -- uvx subtask-mcp

Open in Cursor

Or copy the settings yourself

Paste into .cursor/mcp.json in your project, or ~/.cursor/mcp.json

{
  "mcpServers": {
    "subtask": {
      "command": "uvx",
      "args": [
        "subtask-mcp"
      ]
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

Open in VS Code

Or copy the settings yourself

Paste into .vscode/mcp.json in your project

{
  "servers": {
    "subtask": {
      "type": "stdio",
      "command": "uvx",
      "args": [
        "subtask-mcp"
      ]
    }
  }
}

Your browser asks to open the app, then the app shows the settings and asks you to confirm. Key values are left empty for you to fill in.

This one runs on your computer, and ChatGPT can only connect to servers on the internet. Pick another app.

Your choice stays on this device in a cookie; no account needed.

These settings are generated from the maker’s registry entry. If the README says otherwise, follow the README.

What it can do

Runs on your computer; the tool list appears in your AI app after you install it.

Basic checksi

We check information anyone can see; we have not read the code. Checks that do not apply are left out of the count. · Checked Nov 6, 2026

✓ Pass
Maker matches the repo
The registry name was verified with the GitHub account tedin7, which owns the repo
… Not checked yet
Still maintained
We have not read this repo from GitHub yet
… Not checked yet
Has a licence
We have not read this repo from GitHub yet
– Not applicable
Endpoint responds
This one runs on your computer; there is no internet endpoint
– Not applicable
Sign-in with OAuth
Runs on your computer and uses local settings instead
… Not checked yet
No hidden instructions in tool descriptions
Runs on your computer; we can only read tool lists from internet endpoints

Compared with others in Otheri

More stars than 0% of the other 32484 servers in this category
Published to the registry more recently than 91% of the other 32484 servers in this category
Basic checks equal to or better than 100% of the other 32484 servers in this category

Compared with every active server in this category in the registry. Stars count only when the publisher owns the repo.

Common questions

Is subtask safe?

It passed 1 of 1 applicable basic checks. We have not read the code. Before adding a key or token, see what access the server asks for and use a key with only the permissions you need.

What keys or codes does it need?

The registry does not list a required key, though some servers ask you to sign in on first use.

Does it run on my computer or in the cloud?

It runs on your computer. Your AI app starts it when needed, and data does not pass through the maker’s servers (unless it calls an online service itself).

Is it still maintained?

The GitHub repo last changed –, and the latest version (0.5.9) reached the registry 3 days ago.

Which apps can use it?

Apps that support MCP, such as Claude Desktop, Claude Code, Cursor and VS Code. You also need Python (uv) on your computer.

What can I use instead?

In the same category: Spec Driven Development, Remote Desktop Commander, Recta

Alternatives

Servers in the same category from other makers, sorted by stars.

Reading a card:★ GitHub starsiThree pillars: reviews · checks · usageiUpdated = latest version published to the registryi

Spec Driven Development

by formulahendry

MCP Server that facilitates spec-driven development workflows, not just Vibe Coding.

Runs on your computer★ 440MITUpdated 14 months ago

Install

Remote Desktop Commander

by desktop-commander

Remote Desktop Commander: use files, terminal and processes on your own computers from any AI app.

Runs in the cloud★ 211Updated yesterday

Install

Recta

by RectaBuild

Cheaper cross-chain stablecoin routes for AI agents; 5 % of the verified saving, nothing if none.

Computer or cloudUpdated today

Install

README from the maker

Open the README

Copied from the maker’s repo as written. PopNx MCP has not reviewed or endorsed it. HTML, images and scripts are removed. Links lead off this site.

subtask

A local delegation scheduler for coding agents. One MCP server (and a twin CLI) lets Claude Code, Codex, Kimi Code or OpenCode start work in parallel, wait for it with a single call, and read back a short summary with evidence. It picks an engine that can take the job, books money and slots safely across processes, and says honestly how isolated each run is.

start_many([{task: "Fix the flaky test in tests/test_sync.py", repo: "/src/app", verify: "pytest -q tests/test_sync.py"},

{task: "List every caller of parse_date()", kind: "read", readonly: true, cwd: "/src/app"}]) -> st-4f2a91 started · sonnet-api · branch subtask/st-4f2a91 · sandbox st-77c0de started · haiku-api · /src/app · readonly wait(["st-4f2a91", "st-77c0de"]) # Claude Code shows: Subtask · 01:16 · 1/2 ended — st-4f2a91 running tests: pytest -q -> st-4f2a91 done · sonnet-api · 6m · 0.412$ · verified · ...

Summary (≤10 lines: the answer, files, commits, tests, what is left)

result("st-4f2a91", evidence=True) # JSON: base/head, changed files, observed commands, verify exit code, cost

Why

Save the caller's context. The worker's search, test runs and dead ends stay in its own session; the caller reads about ten lines.
Few round trips. start_many + one wait replace a polling loop.
Use whatever has room. engine="auto" filters engines that can enforce the requested isolation, are installed, fit the budget and have quota, then ranks them with an explicit utility (subtask routing explain).
Money is a primitive. Paid engines reserve their budget before any work, under one lock with the slot; every reservation is closed exactly once.
Evidence, not claims. verify="..." runs your check on the commit the worker left; result(evidence=True) separates what subtask observed from what the worker reported.

Install

The distribution is subtask-mcp (the PyPI name subtask is an unrelated project). Full guide, per client, with native commands: docs/install.md.

uv tool install "git+https://github.com/tedin7/subtask@main"   # or: uv tool install /path/to/checkout

subtask install --client all # prints the plan for every detected client subtask install --client all --yes # applies it: MCP server + skill subtask doctor --client all # checks app, config entry and a real handshake

subtask --version reports the installed Git commit when the installer records it. For local, editable, or registry installations without Git provenance it reports commit unknown.

Jev provides advisory workflow checks automatically, or only when requested:

subtask jev                 # policy, key availability and the current process's budget limits

subtask jev setup # guided setup; key input is hidden subtask jev auto # automatic routing, feedback and final delivery advice subtask jev manual # explicit review submissions only subtask jev off # block new Jev submissions

New installations start in manual mode. The policy and private key are shared by the configured clients. Enter keys through hidden subtask jev setup input or explicit stdin, never chat, argv or tool arguments. In auto, start_many appends routing advice, reply includes feedback advice, and final wait / result include evidence consistency and risk triage. Read this advice together with the existing baseline output. Routing and feedback preserve authorized work and worker instructions. manual requires explicit submissions; off blocks new ones.

These extra checks share the existing cap and deduplicate identical content. skipped, blocked and unknown are not passes; never retry an unknown send. Distinguish raw provider_choice from filtered assessment: a failed verification can veto supported deterministically, without being a Jev finding. Suggested next actions grant no authority, replace no checks, and trigger no automatic model fallback, merge, retry or release. See Jev setup and limits and the workflow study and its limits. These instructions describe the upcoming release; they do not certify a live install.

Claude Code plugin: claude plugin marketplace add tedin7/subtask then claude plugin install subtask@subtask. Codex: codex plugin marketplace add tedin7/subtask. API engines read ANTHROPIC_API_KEY from ~/.config/subtask/env (chmod 600).

Engines

engine	pays with	read-only	isolation it can enforce
`haiku-api`, `sonnet-api`, `opus-api`	API key, monthly cap	yes	sandbox (Claude Code OS sandbox)
`codex`	Codex login (quota from local session files)	yes	sandbox (`workspace-write`), isolated
`opencode-go`	opencode-go subscription	no	worktree, isolated
`kimi`	Kimi login	no	worktree, isolated
`dsh`	DeepSeek key, same cap (`subtask-mcp[dsh]`)	no	worktree
`opencode`	OpenCode default provider (manual only)	no	worktree, isolated

Add an engine without touching the core: an EngineAdapter registered under the subtask.engines entry point (see CONTRIBUTING.md).

Isolation, honestly

worktree (default): a git worktree and branch per writing job. It prevents collisions; it is not a host sandbox.
sandbox: the engine's own sandbox. Same user: a guard rail.
isolated: bubblewrap. Read-only system, writable worktree and git dir only, a private HOME with only the engine's own state. Needs bwrap.
untrusted: sandbox or stronger, and no network for the worker's commands.

A job that cannot get the policy it asked for is refused, never downgraded. Output is redacted for common secret formats before it is saved or shown; redaction is a second layer, not a guarantee. See SECURITY.md.

Tools (MCP) and CLI

tool	what it does
`start(task, kind, repo, cwd, files, readonly, engine, max_usd, effort, base, max_turns, policy, verify, isolation, max_retries, adversarial, context_refs, auto_repomap, tier, invariants, allowed_paths, symbol_scope, oracle_cmd)`	start one job (see below)
`start_many(tasks)`	start several; partial success is listed per item. Items with `id` and `depends_on` form a group (`grp-…`) run as a DAG without extra turns; `foreach=` makes one copy per item of the parent's `.subtask/fanout.json` (at most 8), and dependents wait for every copy; `after="any"` starts when one parent succeeded
`integrate(ids, action="apply", auto_resolve=False)`	worktree jobs back: `diff`, `apply` (all or nothing, uncommitted), `discard`; `auto_resolve` starts a reconciliation job on conflict
`consensus(prompt, engines, verify_cmd, isolation="worktree")`	2 to 4 engines solve it blind in their own worktrees, then one job compares their diffs as anonymous patches and writes one solution, checked by `verify_cmd` and the invariants; returns a group id
`bisect(good_ref, bad_ref, test_cmd, parallelism=4, auto_fix=False)`	first commit that makes `test_cmd` fail, testing up to `parallelism` (max 8) commits per round in temporary worktrees; returns the commit, author and diff; `auto_fix` starts a verified fix job
`map_reduce(glob_pattern, prompt_template, batch_size=5, concurrency=3, verify_cmd, isolation="worktree")`	one job per batch of files (`{{files}}` in the template), at most `concurrency` at a time; returns a group id
`wait(ids, timeout=300, mode="all", since=None, stall_timeout=None)`	block until they end (`any`: the first; `first_success`: the first done and verified, the others are stopped); returns early on a stalled job; progress notifications while waiting; `since` cursor for clients without progress
`steer(id, action, instruction=None)`	`hint` (queued, sent as a reply when the attempt ends), `abort`, `retry` (fresh job with the instruction)
`inspect(id, tail=80, grep=None)`	raw log lines, only when the summary is not enough
`status(id)` / `result(id, full, evidence)`	one line / summary or full text or JSON envelope
`reply(id, message)` / `stop(id)` / `cleanup(id)`	continue / stop the work / remove a clean worktree (branch kept)
`engines()`	capacity per engine with source, freshness and confidence, plus spend

Options of start:

isolation="worktree": own worktree and branch (like repo=), plus SUBTASK_PORT (from 18100), SUBTASK_ID and a private TMPDIR. The result lists files_modified and diff_stat.
verify + max_retries: a failed check resumes the job with the output; when every retry fails, a worktree goes back to its best attempt (scored from "N passed / N failed").
adversarial=True: a Breaker job writes edge-case tests from the spec only; they are copied into the Builder's worktree and run with verify.
context_refs: file:PATH[:A-B], git:diff[:REF], subtask:ID:summary|diff, resolved before start. auto_repomap=True adds tracked files with their top-level symbols (cached per HEAD).
invariants (default ["no_test_deletion", "no_suppression"], [] turns them off): before verify counts, test functions may not decrease, no new skip/xfail markers, no new # type: ignore, # noqa or # pragma: no cover. A violation is a failed check with the reason, so a retry sees it.
allowed_paths: files changed outside these paths are put back and the revert is committed.
symbol_scope=["path.py::name", ...]: only those top-level functions or classes may change in those files. integrate then merges several jobs' edits to one Python file symbol by symbol; overlaps, import or constant changes, and symbols changed on the target meanwhile are a conflict, never a guess.
oracle_cmd: after a passing verify, runs the command on the job's base and on its result at the same time and reports whether exit code and stdout match, plus duration_ms_before, duration_ms_after, speedup_pct.
tier: fast (effort low), deep (effort high, kind hard), free_only. Past 75% of the monthly cap, auto and balanced go to free engines and the reply carries budget_warning.
Kimi's default K3-256k and supported managed model aliases accept low, high and max effort. Subtask maps medium to high and xhigh to max for those models, which can consume more quota. New sessions retain the effective effort when resumed; custom model aliases keep the requested value.

Memory: when a check fails and a retry fixes it, subtask stores a short lesson for that repository in $SUBTASK_HOME/engrams/ (at most 50, least recently used dropped). Jobs on the same paths get the top three. Groups have a blackboard file for shared notes; new notes show in wait(since=...).

CLI only: subtask board [--json] (the view the OpenCode plugin renders), subtask doctor, gc [--apply], du, roi, routing explain|calibrate, watch ID..., install, uninstall, and --model, --no-sandbox, --untrusted on start.

The gc preview reads recorded job states without settling workers; jobs recorded as active are kept. gc does not calculate file sizes, so its output reports folder counts rather than reclaimed bytes. Run subtask du separately for disk usage; scanning large stores can take time. A copy with files in .reports is kept until a collector leaves a receipt, the regular file .reports/.collected (any content; its mtime must be at least that of the newest report). Empty .reports needs no receipt.

Progress in the chat

client	during a `wait`
Claude Code 2.1 (TUI)	live line under the tool call, verified
OpenCode 2.0	notifications received, not shown: use `wait(since=...)`
Kimi Code 2.1	client does not request progress: `wait(since=...)`

| Codex 0.162 | not yet verified (account at its us

Only the beginning is shown; read the rest in the repo

subtask

Overview

PopNx MCP’s three pillars

What you can do with it

Install

Before you install

What it can do

Basic checksi

Maker matches the repo

Still maintained

Has a licence

Endpoint responds

Sign-in with OAuth

No hidden instructions in tool descriptions

Compared with others in Otheri

Common questions

Alternatives

Spec Driven Development

Remote Desktop Commander

Recta

README from the maker

subtask

Summary (≤10 lines: the answer, files, commits, tests, what is left)

Why

Install

Engines

Isolation, honestly

Tools (MCP) and CLI

Progress in the chat