misterdev
misterdev MCP server exposes autonomous LLM code builds, task execution, planning, and job management for registered projects.
scan/list_projects: discover and register projects misterdev can work on.status/report: inspect task states, build outcomes, audit trails, and model costs.build/build_async: given a goal, autonomously plan, edit, verify via gates, and commit changes; supports specs, reference ports, budgets, dry-run, parallel worktrees.run/run_async: execute already-planned pending tasks, optionally a single task.propose_plan,get_plan,approve_plan,execute_plan: request ranked work proposals, review/approve items, then build approved ones.job_status,stop_job,list_jobs: monitor, cancel, and list background builds/runs.Safety: mutating tools refuse dirty working trees, enforce budgets, and auto-rollback regressions; read-only tools are idempotent.
misterdev
Point misterdev at a repository and a goal. It reads the codebase as a symbol graph, decomposes the goal into concrete tasks, and works each one in a try-edit-verify loop: it emits an anchored SEARCH/REPLACE edit, applies it against the file on disk, and runs the change through a sequence of correctness gates — build, tests, lint, typecheck, and any optional gates you enable. A gate that fails RED blocks the change; a gate that has nothing to check SKIPs and never blocks. When a change regresses the suite, misterdev reverts it through git. Nothing merges unless it stays green.
$ misterdev build . "add rate limiting to the public API"
planning goal → 3 tasks (model: anthropic/claude-sonnet-4-6, budget $100.00)
task 1/3 middleware: token-bucket limiter api/limiter.py
edit 1 hunk applied · syntax ok
gates build GREEN · tests GREEN (142 passed) · lint GREEN · typecheck GREEN
task 2/3 wire limiter into request pipeline api/app.py
edit 2 hunks applied
gates build GREEN · tests RED (1 failed) → rolling back, regenerating
edit 2 hunks applied (attempt 2)
gates build GREEN · tests GREEN (145 passed) · lint GREEN · typecheck GREEN
task 3/3 docs + config surface README.md, config.py
gates all GREEN
done 3/3 tasks · 145 tests green · $0.38 over 11 callsBecause misterdev only trusts its gates, the loop is honest: "the model said it's done" is never the finish line — the build, the tests, and the diff are.
Install
pip install misterdev
# or
uv pip install misterdevPython 3.10 – 3.13. Optional extras add capability without bloating the core install:
pip install 'misterdev[local-embeddings]' # offline semantic context ranking (fastembed, no API key)
pip install 'misterdev[lsp]' # LSP semantic-diagnostics gate
pip install 'misterdev[web]' # headless-browser web verification gate (+ playwright install chromium)
pip install 'misterdev[mcp]' # Model Context Protocol tool-host substrateExtras are all opt-in and timeout-bounded. When an extra's runtime dependency is absent, the gate it powers SKIPs rather than failing.
Related MCP server: Aider MCP Server
What it does
Autonomous build loop
Give misterdev a goal and it drives the whole cycle: analyze the project, plan tasks, edit, and validate — repeating until the goal is met or the budget is spent. Edits are anchored SEARCH/REPLACE hunks: the model emits only the changed regions, which are applied against the on-disk file, so a 5,000-line module is edited without reprinting it and without hitting the output-token ceiling. Matching tries exact first, then tolerates whitespace and indentation drift, always requiring a single unique anchor so a partial file is never written.
Polyglot symbol-graph context
A tree-sitter symbol graph gives misterdev structural understanding of Python, Rust, TypeScript/JavaScript, Go, Java, C/C++, C#, Swift, and Kotlin. Per-file outlines plus a whole-project structural map feed planning and editing, and large files are sent as a symbol outline plus verbatim windows of the task-relevant symbols — so context and cost scale with the edit, not with the file.
Correctness gates
Every change runs through an ordered gate sequence: build → lint → tests → typecheck, with optional gates layered on top — an adversarial critic (an independent second model that reviews each diff before it is applied), goal-check, claim-verifier, mutation scoring, runtime-smoke, web, and vision verification. A gate that fails RED blocks the change; a gate with nothing to check SKIPs and never blocks. Regressions are reverted via git, so a working tree only ever moves forward.
Dynamic model selection
misterdev keeps a per-model performance ledger and pairs it with a cost-aware selector that picks for quality-per-dollar across the full breadth of OpenRouter — routing each task up a capability ladder (harvested free / cheap → a strong mid-tier → a frontier tier) and escalating to a stronger model only when a cheaper one can't clear the gates. The strongest tier is reserved for the final attempt, so frontier spend is the rare safety net, not the default; a hard task that a mid model stalls on is finished by a frontier model, while easy tasks resolve on free/cheap ones. Quality never drops because a weak model that writes bad code fails the gate and the policy climbs. It runs against OpenRouter or Anthropic with automatic failover, caches responses to avoid paying twice, and token budgeting keeps spend inside the ceiling you set.
Parallel worktrees
Disjoint tasks run concurrently, each in its own isolated git worktree, so independent work doesn't contend for the tree. An integration gate re-checks each wave against the full suite and reverts any task that regresses it — parallelism without cross-contamination.
Self-improving
misterdev keeps a durable, fingerprinted stream of its own real failures and runs an AlphaEvolve-style keep-if-better loop over its own source: it attributes what breaks, classifies why (harness artifact vs observation gap vs capability), proposes a targeted structural self-edit, and promotes it only when it beats the champion on a held-out task set it never optimized against — with zero regressions. A reward-hacking guardrail walls off the tests and benchmark. The result is a loop that removes whole failure classes over time without overfitting to any one benchmark. See docs/path-to-100.md.
Run it with misterdev evolve --benchmark <polyglot-benchmark checkout> --workdir <scratch dir> (dry-run by default; add --live to actually apply/gate/promote, --from-failures to target the real-build failure stream instead of the benchmark's worst niche). evolution.benchmark_dir/evolution.noise_band in project.yaml set the defaults so a caller can omit the matching flags; both are opt-in and unset by default. An evolve_async MCP tool runs the same pass in the background (poll with job_status). A nightly --scheduled --live --from-failures pass also runs via .github/workflows/evolve.yml once the repo secret OPENROUTER_API_KEY is configured — gated by the same exclusive lock + circuit breaker, so an overlapping or repeatedly-failing trigger is a clean no-op.
On the correctness side, misterdev works reproduction-first: for an issue-driven task it synthesizes a failing test from the acceptance criteria, validates that the test actually fails on the clean tree (a test that reproduces nothing is discarded rather than trusted), then drives the fix to turn it green — so the model edits toward a concrete, verified target instead of a description.
Two-timescale evolution (built; opt-in via orchestrator.runtime_tooling; see docs/two-timescale-evolution.md) takes the self-improvement further than a memoryless runtime agent can. At runtime, the model may author a small task-specific helper tool that runs sandboxed (a hardened, network-less container — untrusted code never touches the host or the repo, and with no container engine the capability degrades off); its output feeds the edit. Every invented tool is then captured with the task's outcome into a tool corpus — a free byproduct of normal runs — and a deliberate promotion pass admits the tools whose success generalizes on a held-out task split (baseline drawn from the reproduction corpus) into a persistent, best-per-capability tool library that future runs start from. Fast loop invents; slow loop keeps only the winners; the same held-out gate that guards scaffold self-edits keeps the library general rather than benchmark-overfit. Capability compounds across runs instead of being reinvented each task — the memory the current top open-source scaffolds lack. Run the promotion pass with python -m misterdev.core.evolution.tool_promotion <project>.
Extensibility
Tools, gates, and targets self-register through Python entry points. pip install misterdev-plugin-x adds a capability with zero edits to the core — misterdev discovers the entry point at runtime and wires it in. A working example lives at examples/misterdev-plugin-hello. See Extending misterdev.
Agentic MCP
misterdev can connect to Model Context Protocol servers and let the model call their discovered tools mid-build — bounded, opt-in, and constrained by a tool allowlist. Transports include stdio and remote streamable-http with auth, so you can point it at a hosted MCP gateway like Glama and give the build access to a whole catalog of tools without running any of them locally.
Benchmarks
Gate-verified pass@1 on Aider's polyglot benchmark (Exercism exercises with hidden test suites), anthropic/claude-sonnet-4-6:
Language | Solved | Rate |
JavaScript | 9 / 10 | 90% |
Python | 8 / 10 | 80% |
Rust | 7 / 10 | 70% |
A continuous stress run has solved 20/20 across the three languages with zero failures — including the exercises usually cited as hard (bowling, forth, arbitrary-precision decimal). Every solve is judged by the exercise's own hidden tests, not the model's say-so. Full numbers, methodology, and how to reproduce: docs/benchmark-results.md. Test suite: 1,941 passing — docs/TESTING.md.
CLI reference
Don't want to remember flags? Just describe what you want — no project setup or devplan required. misterdev routes it with zero friction:
$ misterdev "add rate limiting to the public API"
⠸ Building…Action words (add, fix, implement, write, create, …) go straight to
build — no LLM routing call, no confirmation prompt, no ceremony. Query and
management words (list, status, what, how, check, run, …) are
mapped with a model call, shown as a preview, and ask before anything mutating:
$ misterdev "check what's broken and fix it cheaply, run in parallel"
→ I'll run: misterdev build . fix broken tests --budget 5 --parallel
proceed? [Y/n]The flag-based commands below still work for scripts and power users.
The misterdev command drives everything:
Command | What it does |
| Discover projects under a directory and register them. |
| List all registered projects. |
| Show a project's tasks and their state. |
| Summarize the latest build's cost/tokens, per-model ledger performance, and the audit trail. Read-only — nothing is re-run. |
| Run pending tasks, or redirect to |
| Analyze the project, recommend work, and compose a plan interactively. |
| The autonomous build/debug/complete workflow. |
Plain misterdev with no subcommand launches interactive planning.
Flag | Effect |
| Max dollar budget for the run (default 100). |
| Commit after each completed task. |
| Execute independent tasks concurrently in isolated worktrees. |
| Plan only; show tasks without executing. |
| Wait for confirmation between tasks. |
| Skip the final validation phase. |
| Skip the suggest scan. |
| Disable auto-bisect/revert of a regressing task. |
| Restrict work to a specific area. |
| Allow building over uncommitted changes. |
| Cap the tasks this run will plan/execute (bounds cost). |
The prompt is free text or a mode word — debug, complete, review, or new <description>.
Drive it from an AI client (MCP server)
misterdev also ships as an MCP server (misterdev-mcp), so you can drive it
in plain English from Claude Desktop, Claude Code, Cursor, or any MCP client —
no flags to remember. The client just calls a tool (build, scan, status,
list_projects, run); the entire orchestration runs inside misterdev's own
process with its own model and context budget, and only a short summary
returns to the client — your codebase never enters the client's context window.
// Claude Desktop config (claude_desktop_config.json)
{
"mcpServers": {
"misterdev": {
"command": "misterdev-mcp",
"env": { "OPENROUTER_API_KEY": "sk-..." }
}
}
}Then just ask: "Have misterdev add rate limiting to the API, keep it under $5."
Mutating tools (build, run) refuse a dirty working tree and carry a
conservative default budget.
Claude Code integration. The build tool accepts a spec_text parameter.
Pass a complete spec written by Claude and misterdev skips its own analysis and
spec-generation phases, going straight to decompose → execute → verify using
your codebase's own gate suite. Claude handles the design; misterdev handles the
execution, correctness gates, and rollback:
# In Claude Code / MCP client
misterdev.build("/path/to/repo", spec_text="""
Feature: add a token-bucket rate limiter to /api/v1/*
...full spec...
""")Requires the mcp extra: pip install 'misterdev[mcp]'.
Extending misterdev
A plugin is an ordinary Python package that declares entry points in the misterdev.* groups. Install it, and misterdev picks it up — no core edits.
A tool is a class; a gate is a callable returning a GateOutcome:
# misterdev_plugin_hello.py
from misterdev.core.execution.outcomes import GateOutcome, GREEN, RED
class HelloTool:
gather_safe = True # opt into the agentic gathering loop
gather_description = "Return a friendly greeting for a name."
def __init__(self, config: dict):
self.name = config.get("name", "hello")
def execute(self, project, name: str = "world", **_ignored):
return True, f"Hello, {name}!"
def no_shouting_gate(ctx) -> GateOutcome:
build = (ctx.commands or {}).get("build_command") or ""
if build and build.isupper():
return GateOutcome(RED, "build_command is ALL CAPS; please calm down")
return GateOutcome(GREEN)# pyproject.toml — the entry points are the whole contract
[project.entry-points."misterdev.tools"]
hello = "misterdev_plugin_hello:HelloTool"
[project.entry-points."misterdev.gates"]
no_shouting = "misterdev_plugin_hello:no_shouting_gate"Targets register the same way through the misterdev.targets group. The full, runnable example — tool, gate, pyproject.toml, and notes — is at examples/misterdev-plugin-hello.
Configuration
A project.yaml is created automatically when you first run misterdev in a directory — no setup required to get started. Drop a custom one in the repo root to specify build/test/lint commands, model, budget, and gates.
name: "My App"
language: "python"
build_command: "python -m compileall -q ."
test_command: "pytest -q"
lint_command: "ruff check ."
llm:
provider: "openrouter" # openrouter | anthropic
model: "anthropic/claude-sonnet-4-6"
api_key_env_var: "OPENROUTER_API_KEY"Key knobs:
Model & budget —
llm.model, provider/failover, and the run's dollar ceiling (also--budget).Gates — optional gates (adversarial critic, mutation, runtime-smoke, web, vision, goal-check) are off by default and enabled under the
orchestrator.*keys.MCP — declare servers under
mcp.serversand enable tool use withorchestrator.mcp_enabled/orchestrator.mcp_tool_use; point at a remote gateway for hosted tool catalogs.Targets — a
targets:block gives a polyglot monorepo per-language build/test/lint, routed per task.
Guides: Getting started · Configuration · Plugins · MCP. project.yaml.example documents every configuration key.
Requirements
Python 3.10 – 3.13
git (branch-per-task, worktrees, and rollback all run through it)
An API key for OpenRouter or Anthropic
Optional per-gate toolchains — a Playwright browser for the web gate, a language server for the LSP gate, an MCP SDK for the tool-host substrate (all installed via the matching extra)
Development
git clone https://github.com/dcondrey/misterdev
cd misterdev
uv sync
uv run ruff check .
uv run pytest -qContributions are welcome — see CONTRIBUTING.md, and open an issue or a pull request on GitHub.
License
misterdev is dual-licensed:
AGPL-3.0-or-later — free for open-source use under the terms of the GNU Affero General Public License.
Commercial license — for use in a closed-source or proprietary product without AGPL obligations.
Choose the one that fits your project.
Available Tools
15 toolsapprove_planAIdempotent
Set the approval flags on the proposed plan, then persist.
Use when: after ``propose_plan``/``get_plan`` you want to mark which items
should actually run. ``approve_all`` approves everything; otherwise
``approve_ids`` are approved and ``reject_ids`` un-approved (reject wins a
tie — the safer default). Idempotent. Then call ``execute_plan``. Related:
``propose_plan``, ``get_plan``, ``execute_plan``.
Side effects: rewrites ``.orchestrator/proposed_plan.json``; edits no code.
Returns ``{items: [...]}`` with updated flags, or ``{error}`` when no plan
exists to approve.
Inputs: path (required), reject_ids, approve_all, approve_ids. Returns: result
buildADestructive
Autonomously plan AND execute a goal in a project, from scratch.
Use when: you have a goal but no existing task plan — ``build`` analyzes the
project, decomposes ``goal`` into tasks, edits the code, and verifies each
change through build/test/lint/typecheck gates, reverting anything that
regresses. Do NOT use when: a task plan already exists and you just want to
execute it (use ``run``), or the working tree is dirty (commit/stash first).
Related: ``run`` (execute an existing plan), ``status`` (inspect tasks).
Pass ``reference_dir`` to port from an existing implementation: its
module/symbol map is extracted read-only and guides the plan.
Pass ``spec_text`` when you have already written the implementation spec
(e.g. in a Claude conversation) — misterdev skips its own planning phase
and executes your spec directly, making it Claude's execution backend.
DESTRUCTIVE side effects: edits files and makes git commits, and calls an
external LLM provider (open-world, non-idempotent). It refuses to run on a
dirty working tree. ``dry_run=True`` previews without changing anything;
``budget`` caps spend; ``max_tasks`` caps scope.
Returns a compact text report: what was done, per-gate results, and cost.
Inputs: goal (required), path (required), budget, dry_run, +4 more. Returns: result
build_asyncADestructive
Start an autonomous build in the BACKGROUND and return immediately.
Use when: the build may run for minutes and you want to keep working — this
returns a ``run_id`` right away instead of blocking (as the synchronous
``build`` does) until the run finishes. Poll ``job_status`` with the
``run_id`` to watch progress, ``stop_job`` to cancel, ``list_jobs`` to see
everything running. Do NOT use for a quick preview — use ``build`` with
``dry_run=True``. Related: ``build`` (synchronous), ``report`` (final outcome).
DESTRUCTIVE side effects (once running): edits files, makes git commits, and
calls an external LLM provider. Refuses to start a second job for a project
that already has one running (one writer per project).
Returns ``{run_id, status}`` on success, or ``{error}`` when a job is already
running for this project.
Inputs: goal (required), path (required), budget, parallel, +2 more. Returns: result
execute_planADestructive
Execute the APPROVED items from a previously proposed plan.
Use when: ``propose_plan`` + ``approve_plan`` have selected the work and you
want it built — this composes a goal from the approved items and runs the
normal build pipeline (decompose, edit, verify, revert regressions). Do NOT
use before approving anything (it returns a no-op message). Related:
``propose_plan``, ``approve_plan``, ``build``.
DESTRUCTIVE side effects: edits files, makes git commits, and calls an
external LLM provider. Refuses a dirty working tree (like ``build``).
Returns a compact build report, or a message when nothing is approved.
Inputs: path (required), budget. Returns: result
get_planARead-onlyIdempotent
Return the persisted proposed plan and which items are approved.
Use when: you want to review the proposals from ``propose_plan`` (and see
what has been approved so far) before approving or executing. Read-only and
idempotent. Related: ``propose_plan``, ``approve_plan``, ``execute_plan``.
Returns ``{items: [...]}`` (empty ``items`` when no plan has been proposed).
Inputs: path (required). Returns: result
job_statusARead-onlyIdempotent
Return a background job's current state.
Use when: you started a job with ``build_async``/``run_async`` and want to
know whether it is still ``running`` or has ``succeeded``/``failed``/
``stopped`` — and, when finished, its report (``result``) or ``error``.
Read-only and idempotent. Related: ``list_jobs`` (all jobs), ``stop_job``.
Returns the job object (run_id, kind, project_path, status, result, error,
timestamps), or ``{error}`` when the run_id is unknown.
Inputs: run_id (required). Returns: result
list_jobsARead-onlyIdempotent
List every background job this server has started and their states.
Use when: you want an overview of all ``build_async``/``run_async`` jobs —
running and finished — e.g. to find a lost run_id. Read-only, idempotent.
Related: ``job_status`` (one job), ``stop_job``.
Returns ``{jobs: [...]}``, each entry the same object ``job_status`` returns.
Inputs: no named parameters. Returns: result
list_projectsARead-onlyIdempotent
List every project misterdev currently knows about.
Use when: you need to discover which projects are registered before calling
``status``, ``build``, or ``run`` on a specific one. Do NOT use when: the
project isn't registered yet — call ``scan`` first to register it. Related:
``scan`` (register projects), ``status`` (inspect one project). Takes no
parameters.
Side effects: none — read-only, calls no LLM, and returns the same result on
repeated calls (idempotent).
Returns a mapping of project id to an object with its registered ``path`` and
``name``; an empty mapping when nothing is registered.
Inputs: no named parameters. Returns: result
propose_planA
Analyze the project and return ranked, UNAPPROVED work proposals.
Use when: you want misterdev to recommend what to work on and let a human
approve a subset BEFORE any code is edited — the review gate. The proposals
are persisted, so ``get_plan`` re-reads them, ``approve_plan`` marks a
subset, and ``execute_plan`` builds the approved ones. The codebase is
analyzed in this process, so it never enters the client's context. Do NOT
use to execute immediately without review — that is ``build``. Related:
``get_plan``, ``approve_plan``, ``execute_plan``.
Side effects: spends LLM budget analyzing the project and writes the plan to
``.orchestrator/proposed_plan.json``; it edits NO source code.
Returns ``{items: [...]}`` — each item has an id, title, work_type,
rationale, and ``approved: false`` — or ``{error}`` on failure.
Inputs: path (required), budget. Returns: result
reportARead-onlyIdempotent
Return the latest build report, audit trail, and model performance.
Use when: a ``build`` or ``run`` has finished (or was stopped) and you want
the outcome — which tasks completed/failed/deferred, per-file edits, failed
commands, governance escalations, unmet-goal gaps, token/cost totals, and
per-model success rates. This is misterdev's read-only equivalent of asking
"what did the last run find and do?". Do NOT use when: nothing has been
built yet — ``latest_report`` will be null. Related: ``status`` (live task
states), ``build``/``run`` (produce a report).
Side effects: none — reads only the project's ``.orchestrator`` artifacts,
calls no LLM, and returns the same result on repeated calls (idempotent).
Returns an object with ``latest_report`` (the most recent build's structured
summary, or null), ``audit`` (command/edit/governance counts), and
``models`` (per-model attempts, success rate, and average cost). Returns an
``error`` field instead when ``path`` is not an existing directory.
Inputs: path (required). Returns: result
runADestructive
Execute a project's ALREADY-PLANNED pending tasks (a devplan).
Use when: tasks already exist (from a prior ``plan`` or a devplan directory)
and you want to execute them. Do NOT use when: no plan exists and you are
starting from a goal — that is ``build``'s job (it analyzes and decomposes).
Related: ``build`` (plan + execute a goal), ``status`` (see the task ids).
Pass ``task_id`` to run a single task.
DESTRUCTIVE side effects: edits files and makes git commits, and calls an
external LLM provider (open-world, non-idempotent). ``dry_run=True`` previews
without changing anything.
Returns a short text summary of what was run or previewed.
Inputs: path (required), dry_run, task_id. Returns: result
run_asyncADestructive
Start executing a project's planned tasks in the BACKGROUND.
Use when: a devplan exists and you want it executed without blocking — like
``run`` but returns a ``run_id`` immediately. Poll ``job_status``, cancel
with ``stop_job``. Do NOT use to plan from a goal — that is ``build_async``.
Related: ``run`` (synchronous), ``build_async``.
DESTRUCTIVE side effects (once running): edits files, makes git commits, and
calls an external LLM provider. Refuses a second job for a project that
already has one running.
Returns ``{run_id, status}``, or ``{error}`` when one is already running.
Inputs: path (required). Returns: result
scanAIdempotent
Discover misterdev projects under a directory and add them to the registry.
Use when: you have projects on disk that misterdev does not know about yet,
before calling ``status``, ``build``, or ``run`` on them. Do NOT use when:
the projects are already registered (call ``list_projects`` to check) — a
re-scan is harmless but redundant. Related: ``list_projects`` (see what is
registered), ``status`` (inspect a registered project).
Side effects: writes only to misterdev's project registry — it never reads,
edits, or executes any project code, and re-scanning the same directory is
idempotent (no duplicates).
Returns a short confirmation string naming the directory scanned.
Inputs: directory (required). Returns: result
statusARead-onlyIdempotent
Show a project's tasks and their current state.
Use when: you want to inspect what work exists and how far it has progressed,
e.g. before deciding whether to ``run`` pending tasks or ``build`` new work.
Do NOT use when: the project isn't registered — call ``scan`` first, or
``list_projects`` to find the right path. Related: ``list_projects``,
``run``, ``build``.
Side effects: none — read-only, calls no LLM, idempotent.
Returns the project's tasks, each with its id, title, and status.
Inputs: path (required). Returns: result
stop_jobAIdempotent
Request cooperative cancellation of a running background job.
Use when: a ``build_async``/``run_async`` job should stop — it finishes any
in-flight task and starts no new work, then produces a partial report. Poll
``job_status`` afterward to confirm it reaches ``stopped``. Idempotent:
stopping a finished or already-stopped job is a harmless no-op. Related:
``job_status``, ``list_jobs``.
Returns ``{run_id, stopping: true}`` when a running job was signalled, or
``{run_id, stopping: false}`` when the id is unknown or already finished.
Inputs: run_id (required). Returns: result
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 15 tools
The tools split into clear families — project discovery, status/reporting, sync/async execution, job management, and plan approval — and each description explicitly points at when not to use it. The only mild ambiguity is between build/run/execute_plan and get_plan/status, but the descriptions are detailed enough that an agent can usually select correctly.
Most tools follow verb_noun conventions (list_projects, propose_plan, approve_plan, stop_job, list_jobs), and the _async suffix is used consistently. A few bare-noun/verb names (status, report, scan, build, run) and job_status (noun_noun) deviate slightly, but the overall pattern is still predictable.
At 15 tools, the set sits at the high end of well-scoped, but every tool supports a distinct workflow: discovery, status, synchronous execution, background execution, job control, and the proposed-plan review gate. The sync/async pairs and plan-management tools all add real capabilities rather than redundant alternatives.
The core lifecycle is well covered: discover projects, inspect tasks/reports, plan with approval, execute synchronously or in the background, and stop/monitor jobs. Minor gaps remain — no way to unregister a project and no resume/pause for background jobs — but these can be worked around and do not break the main workflows.
Maintenance
Related MCP Connectors
Autonomous AI developers on your own infrastructure: assign a task, get a pull request.
LLM cost optimization gateway, repo token-waste auditor & model arbitrage MCP server.
LLM Orchestration Agent (Mcp)
Control plane for autonomous software labor. Agents claim objectives over MCP with audit trail.
Related MCP Servers
- AlicenseAqualityBmaintenanceA fully featured coding agent that uses symbolic operations (enabled by language servers) and works well even in large code bases. Essentially a free to use alternative to Cursor and Windsurf Agents, Cline, Roo Code and others.2931,250 PyPI31,560GPL 3.0
- FlicenseCqualityDmaintenanceAllows Claude Code to offload AI coding tasks to Aider, reducing costs and enabling more control over which models handle specific coding tasks.2309-
- AlicenseAqualityDmaintenanceProvides per-Subagent MCP controls to any coding agent or client across all your MCPs and prevents context window waste. Loads only 3 tools instead of all your MCP Server's tool definitions. Agents discover tools on-demand, only when needed and only the servers and tools they are allowed.4117 PyPI42MIT
- AlicenseAqualityBmaintenanceMCP-native, local-first memory for coding agents that turns real sessions into reusable decisions, gotchas, and domain knowledge.171,019 PyPI7MIT