Subagentmaxxing: Cheap AI Coders as Claude Subagents

Subagentmaxxing is a new open-source command-line tool, released in July 2026, that lets you drive OpenAI Codex, Cursor, and Grok coding agents as subagents with the same ergonomics as a native Claude Code subagent. The idea is simple and increasingly popular: keep a flagship Claude model as the orchestrator, then hand the bulk execution work to far cheaper models. The project reports blended savings of roughly 15 to 30 times on agentic coding runs while holding quality near the flagship line. It is MIT licensed, written in pure Python with no third-party dependencies, and shipped with 13 of 13 parity checks passing on a headless Linux host.

What Subagentmaxxing Actually Does

Claude Code already supports subagents: scoped, isolated helper agents that a main session can spin up to handle a defined task. Subagentmaxxing extends that pattern outward. Instead of every subagent being another Claude call, it wraps three backends behind one CLI so any of them can act as an execution subagent. The backends are claude, codex, and cursor, and each exposes its own models: Claude runs Opus, Sonnet, and Fable 5; Codex runs GPT-5.5 and GPT-5.6 "sol"; and Cursor exposes Composer 2.5, Grok 4.5, and a set of Cursor-hosted Opus, Sonnet, Gemini, GLM, and Kimi variants.

The core insight the maintainer makes is a division of labor. A frontier Claude model is the strongest planner: it decomposes a goal, routes subtasks, and verifies results. But paying flagship per-token prices for the huge volume of routine execution work is waste. Subagentmaxxing lets you pay flagship prices only for the thin orchestration layer, which the project estimates at 10 to 15 percent of tokens, and cheap-executor prices for the 85 to 90 percent that is actual edits, file writes, and test runs.

The Orchestrator and Executor Split

The economics are the whole point. Coding-agent quality is usually measured with SWE-bench-style task benchmarks, and the project publishes its own head-to-head numbers to justify the split. According to the repository, Cursor's Composer 2.5 scores 62 at about $0.07 per task, while Opus 4.7-max scores 66 at about $4.10 per task. That is roughly 94 percent of the quality for about 1.7 percent of the cost. The blended figures the maintainer reports are equally blunt: routing an Opus workload to Composer comes out about 25 times cheaper, and a Sonnet workload about 32 times cheaper.

Treat these as the project's own benchmarks rather than an independent audit. The pattern, though, is sound and matches a broader 2026 trend: use the smartest model to think and cheaper specialized models to do. The savings compound because execution volume dwarfs planning volume on any real codebase task.

Backends and Models at a Glance

The CLI keeps each backend behind a consistent surface, so switching an executor is a one-flag change rather than a rewrite of your harness. Cursor is the interesting middle layer here, because through its agent it exposes both its own Composer models and a menu of hosted frontier and open models.

Because Cursor and Codex are both accessed through their own authenticated CLIs, subagentmaxxing does not resell any tokens or hold your keys. It shells out to tools you have already installed and logged into, which keeps the trust surface small.

A Step-by-Step Orchestration Workflow

Here is a concrete way to put the tool to work on a real feature branch.

1. Install and check. Clone the repo, run bash install.sh, then subagent doctor to confirm which backends are authenticated. The doctor command tells you whether claude, codex, and cursor-agent are on your path and logged in.
2. Plan with Claude. Use your normal Claude Code session as the orchestrator to break the feature into independent, scoped subtasks. This is the 10 to 15 percent of tokens you happily pay flagship rates for.
3. Dispatch execution to a cheap model. Run subagent run cursor -m composer-2.5 "implement the parser changes in src/parse.ts and add tests". Add --worktree feature-x so the executor works in an isolated git worktree and cannot stomp your main tree.
4. Fan out when you want consensus. For risky changes, subagent fanout "refactor the auth guard" --on cursor:composer-2.5 --on codex:gpt-5.5 runs the same prompt across models in parallel so you can compare diffs before choosing one.
5. Run long jobs in the background. Add --background, then use jobs, wait, and logs to manage execution without blocking your orchestrator session.
6. Verify with the flagship. Bring the resulting diff back to Claude for review and final sign-off. The expensive model reads and judges rather than typing every line, which is exactly where its money is well spent.

Structured output is available through --json and --schema FILE, which matters if you are wiring subagentmaxxing into your own automation rather than driving it by hand.

What This Enables for Creators and Builders

For anyone building software with AI agents, the practical unlock is running more, and more ambitious, agentic work at a cost that does not spike your bill. A solo builder can leave background executor jobs churning through a refactor while the orchestrator plans the next module. A small studio shipping client sites or internal tools can hold Claude-level planning quality while cutting the per-task execution cost by an order of magnitude or more. And because the tool leans on the native subagent model rather than a bespoke framework, what you learn transfers directly back to your normal Claude Code habits.

The fanout command is worth calling out for creative and exploratory work. Generating three independent implementations of the same component and diffing them is a cheap way to escape a single model's blind spots, and at Composer prices you can afford to do it routinely instead of only on the scariest changes.

How It Differs From Routers and Proxies

Subagentmaxxing sits next to a growing family of cost-cutting tools, but it is not the same thing as a router. A router or proxy sits between your editor and the model APIs and silently swaps which model answers a given request. Subagentmaxxing instead exposes explicit subagent commands you invoke on purpose, with worktree isolation and fanout, and it never handles your API keys because it shells out to CLIs you already run. If you prefer a hosted approach, see our coverage of Sakana Fugu, which offers one API to orchestrate top models, and Weave Router, a proxy that cuts coding costs 40 to 70 percent. The three represent different points on the same spectrum: explicit local subagents, a hosted orchestration API, and a transparent routing proxy.

What to Do Next

If you already have Claude, Codex, or Cursor installed and authenticated, subagentmaxxing is a fast thing to try on a throwaway branch. Clone the repository, run the installer, and start with a single subagent run before graduating to fanout. Point it at a well-scoped task first, such as adding tests to one file, so you can judge the executor's quality against your own bar before trusting it with larger work. Keep your flagship Claude session in the loop as the reviewer, and let the cheap models carry the volume.

Frequently Asked Questions

Is subagentmaxxing free to use?

The tool itself is MIT licensed and free. You still pay each backend provider for the tokens you consume, so your actual cost depends on which executor models you route to. The whole design is aimed at making that provider bill smaller.

Do I need all three backends installed?

No. The tool works with any subset of claude, codex, and cursor that you have installed and authenticated. Run subagent doctor to see which backends are available on your machine.

Does it store or proxy my API keys?

No. It shells out to the official CLIs you have already logged into, so it never holds your credentials or resells tokens. That keeps the trust surface small compared with a hosted proxy.

How much can it actually save?

The project reports roughly 15 to 30 times blended savings, with specific examples of about 25 times cheaper when routing an Opus workload to Composer and about 32 times cheaper from Sonnet. These are the maintainer's own benchmarks, so treat them as a starting estimate and measure against your own workload.

What is the fanout command for?

Fanout runs the same prompt across several executor models in parallel so you can compare their diffs and pick the best one, or use agreement between them as a rough quality signal on risky changes.

Is it safe to run against my real repository?

Use the --worktree flag so executors work in an isolated git worktree, and set --sandbox read when you only want analysis. Keep a flagship model as the final reviewer before anything merges.