UseStage

Open source · Apache 2.0 · Eight coding agents

One plan takes the stage.
Every agent plays its part.

UseStage directs Claude Code, Codex and six more coding agents from a single desk — every move in plain sight, and nothing builds until you approve the plan.

macOS & Linux · one binary
curl -fsSL https://usestage.dev/install.sh | sh
Windows · via npm
npm install -g usestage
CA
0xfdd0d987e0bfbe226eca844121ad12f4cd3dee01

Describe the outcome you want. UseStage reads your repository first, asks about anything still unclear, and hands back a plan of tasks you can rewrite line by line. Each task then works on its own branch, and you read the diff before anything merges.

No Node.js needed on macOS and Linux · No extra API key if you already run a coding agent — each agent keeps its own login.

goal
audit sign-in flow● claudeDONE ✓
refactor sessions● codexDONE ✓
refresh the docs● claudeDONE ✓
harden middleware● codexDONE ✓
fix flaky tests● opencodeDONE ✓
integration pass● claudeDONE ✓

one goal → six tasks → three agents → one integration branch

01

Say what you want

UseStage reads your repo and asks about anything you left open — before a single task exists.

02

Arrange the plan

Swap any task, agent or model before anything runs. The plan is a draft, not a contract.

03

Read the diff, then merge

Change tasks work side by side on their own branches. Yours waits for you at the end.

Interactive planner

Feel how a goal becomes a plan.

Type a goal, rearrange who does what, then approve and watch the run.

Plan a goal

UseStage would read your repo and ask one clarifying question first. Here, pick a goal (or write your own) and draft the plan.

Draft plan ready — 5 tasks. Reassign any agent, then approve. Nothing has run yet.

How it works

You see the plan before any build task starts.

Every task is written out with the agent, model and effort that will run it. You can change any of it first.

01 · Plan

It reads, then asks

UseStage studies your repository, then turns your goal into a written plan: ordered tasks, each naming the agent and model that will run it.

02 · Run

Many agents, one plan

Approved tasks run in parallel where the plan allows it. A dependent task waits until its inputs land on the run's integration branch.

03 · Verify

Done means reported

A task counts as finished when its agent reports completion — or when a script's exit status says so. No second model judges the work. A task that never reports fails where you can see it.

Why it's different

Four things UseStage does on purpose.

Most agent tools start typing the moment you press enter. UseStage is built around the pause before the work.

Approval

Build tasks wait for you

The plan is yours to rewrite before anything builds: prompts, agent, model, effort, mode and dependencies.

Evidence

Done means reported

No second model is asked whether the work looks done. The agent's own completion report decides, and a script's exit status decides for scripts.

Mixed cast

Several agents, one plan

Eight supported agents can share a plan. Each task picks its agent, model, effort and mode — and a task can move to another agent mid-flight.

Limits

Limits pause work, they don't end it

A task that hits its agent's usage limit pauses and resumes in its saved session when the limit resets. Move a paused task to another agent and its unfinished work comes with it.

Supported agents

Eight runners. Bring the ones you already use.

UseStage doesn't sell you another model subscription. It drives the coding agents already installed on your machine, each with its own login, its own models and its own usage limits. Mix them in one plan, per task.

Runner · Default planner

Claude Code

Anthropic's terminal agent. Sonnet and Haiku families, high / medium / low effort. claude on your PATH is enough — UseStage plans and runs through it with no extra key.

Runner

Codex

OpenAI's coding agent. Strong on self-contained refactors and test repair. codex signed in once, then available to every plan.

Runner

OpenCode

Open-source runner with the widest model catalog — DeepSeek, Qwen, GLM, Kimi and more via OpenRouter or a local endpoint.

Runner

Gemini CLI

Google's agent for long-context research tasks: whole-repo audits, doc sweeps and migration inventories.

Runner

Aider

Pair-programming veteran. Good fit for small, tightly-scoped edits on a branch you watch closely.

Runner

Cursor Agent

Drives Cursor's agent from the plan when your team already lives in the editor. Tasks land as branches, not chat threads.

Runner

Goose

Block's open-source agent, extensible with MCP tools. Picks up your Goose extensions inside UseStage tasks unchanged.

Runner

Amp

Sourcegraph's agent for fast, parallel exploration. Useful as the research leg before a heavier model builds.

Detection is automatic — and honest

On first run UseStage scans for installed agents and lists only the ones it can actually start. A runner that isn't signed in, or whose binary is missing, never appears in a plan's picker — so a task can't be assigned to an agent that will fail at launch. Add an agent later and run /runners (terminal) or refresh the panel (editor); it joins the cast without restarting the plan.

Inside a plan

Every task carries its full assignment.

Nothing about a task is implied. Before you approve, each card spells out exactly what will run, where, and in what order — and every field is editable.

Prompt

The instruction, in plain words

Generated from your goal and the planner's research. Rewrite any line; the runner gets your version, not the draft.

Runner + model + effort

Who does it, and how hard they think

Picked per task from that runner's real catalog. A rename doesn't need high effort; a data migration does.

Mode

Build, research, or script

Build tasks edit code on a branch. Research tasks report back without touching files. Script tasks run a command and live or die by its exit status.

Dependencies

What has to land first

A task can wait on earlier tasks. Its prompt receives their reports and diffs as context the moment they land on the integration branch.

Branch

Every change, isolated

Each build task works on its own stage/… branch. Nothing reaches your working tree until you merge it from the review screen.

Two surfaces

Run it from the editor, or never leave the terminal.

The same plan, the same state, in both places. Start a run in one and finish reviewing it in the other.

terminal — stage
$ stage plan "add rate limiting"
▸ reading repo… 42 files scanned
▸ drafting… 5 tasks, 3 runners
? limiter storage: redis (existing)
✓ plan saved → .stage/plans/rate-limit.md
$ stage run rate-limit
✓ 5/5 tasks reported · diff ready

The terminal UI runs inside tmux — on Windows, that means WSL. Planning, execution and the CLI itself run natively everywhere.

stage.toml — project config
# who is in the cast, and the house rules
[planner]
runner = "claude"
effort = "medium"

[autonomy]
mode = "guarded"   # guarded | watch | autopilot

[branches]
prefix = "stage/"
integration = "stage/integration"

One config file per project: default planner, autonomy mode and branch rules, checked into the repo with everything else.

Autonomy

Decide how far a run may go without you.

Approval is the default, not a setting you have to hunt for. Loosen it per project when a workflow has earned it.

Guarded — the plan waits for your word

Every run stops after planning. Nothing executes until you approve the plan, and nothing merges until you approve the diff. Two separate approvals, on purpose: agreeing with the plan is not the same as accepting the code.

default for every new project · stage.toml → autonomy.mode = "guarded"

Built-in skills

Reusable moves the planner already knows.

Skills are named planning habits. Attach one to a goal and the plan is drafted that way from the start — or write your own and keep it in the repo.

/grilling

Interrogate the goal first

The planner questions every vague corner of the request — scope, edge cases, what "done" looks like — before drafting a single task.

/to-spec

Turn the goal into a spec

Drafts a short written specification from the goal and the repo, then plans against the spec. The spec stays in .stage/specs/ for the next run.

/tdd

Tests before implementation

Every build task is preceded by a failing-test task assigned to a different runner, so the agent that writes the code isn't the one that wrote its exam.

Workflows

Plans people run every week.

A workflow is a saved plan shape: the same cast and order, pointed at a new goal each time.

Ship a feature

workflow: feature

  1. Research — Amp maps the codebase and reports the touch points.
  2. Spec — Claude Code drafts the change against the report.
  3. Build — Codex implements on its own branch.
  4. Verify — OpenCode writes and runs the tests; you read the diff.

Sweep the repo

workflow: sweep

  1. Audit — Gemini CLI inventories dead code, stale docs and TODO debt.
  2. Triage — the planner groups findings into small, independent tasks.
  3. Clean — Aider takes the small edits, one branch each.
  4. Report — a single summary lands with the integration diff.

Fix the flaky test

workflow: deflake

  1. Reproduce — a script task runs the suite until the failure shows itself.
  2. Diagnose — Claude Code reads the failures and names a root cause.
  3. Fix — Codex patches it; the suite runs twenty more times to prove it.

CLI reference

The whole show, from one command.

Everything the editor panel does, the terminal does too. The commands you'll actually live in:

CommandWhat it does
stage plan "<goal>"Read the repo, ask what's unclear, and draft a plan without running anything.
stage run <plan>Execute an approved plan; tasks report back as they finish.
stage review <plan>Open the run's combined diff, task by task, ready to merge or discard.
stage runnersList the agents UseStage can actually start on this machine right now.
stage move <task> <runner>Reassign a waiting or paused task to another agent, work-in-progress included.
stage pause / resumeFreeze a run in place, or pick it back up in the same sessions.
stage skills add <name>Scaffold a custom skill in .stage/skills/ for your repo's own habits.

FAQ

Asked often, answered plainly.

The short version: your agents, your keys, your call — UseStage just keeps them on one plan.

Does UseStage need its own API key or subscription?

No. UseStage drives the coding agents already installed on your machine, and each one keeps its own login and billing. If an agent works when you run it yourself, it works inside a UseStage plan.

What stops an agent from building the wrong thing?

The approval gate. A plan is only a draft until you approve it — prompts, agents, models and dependencies are all editable first. And even a finished run changes nothing on your branch until you merge the diff from the review screen.

Can different tasks really use different agents?

Yes — that's the point. One plan might research with Amp, build with Codex and test with OpenCode. Each task names its own runner, model and effort, and a task can be moved to another agent mid-flight with its unfinished work attached.

What happens when an agent hits its usage limit mid-run?

The task pauses instead of failing. Its session is saved, and when the limit resets the task resumes where it stopped. If you'd rather not wait, move the task to another agent and it continues there.

How does UseStage decide a task is done?

By the agent's own completion report — or, for script tasks, by the command's exit status. No second model reviews the work and declares it finished, and a task that never reports is shown as failed, not quietly marked complete.

Is UseStage open source?

Yes, under the Apache 2.0 license. The planner, the CLI, the editor panel and the built-in skills are all in the open — read exactly what an approval means before you ever give one.

Get started

Put your next goal on stage.

Install the binary, run stage in any repository, and describe what you want. The first thing you'll see is a plan — and the second thing is your own approval, because nothing moves without it.

install · macOS & Linux
curl -fsSL https://usestage.dev/install.sh | sh
Copied to clipboard