Say what you want
UseStage reads your repo and asks about anything you left open — before a single task exists.
Open source · Apache 2.0 · Eight coding agents
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.
curl -fsSL https://usestage.dev/install.sh | sh
npm install -g usestage
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.
one goal → six tasks → three agents → one integration branch
UseStage reads your repo and asks about anything you left open — before a single task exists.
Swap any task, agent or model before anything runs. The plan is a draft, not a contract.
Change tasks work side by side on their own branches. Yours waits for you at the end.
Interactive planner
Type a goal, rearrange who does what, then approve and watch the run.
UseStage would read your repo and ask one clarifying question first. Here, pick a goal (or write your own) and draft the plan.
How it works
Every task is written out with the agent, model and effort that will run it. You can change any of it first.
01 · Plan
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
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
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
Most agent tools start typing the moment you press enter. UseStage is built around the pause before the work.
Approval
The plan is yours to rewrite before anything builds: prompts, agent, model, effort, mode and dependencies.
Evidence
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
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
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
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
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
OpenAI's coding agent. Strong on self-contained refactors and test repair. codex signed in once, then available to every plan.
Runner
Open-source runner with the widest model catalog — DeepSeek, Qwen, GLM, Kimi and more via OpenRouter or a local endpoint.
Runner
Google's agent for long-context research tasks: whole-repo audits, doc sweeps and migration inventories.
Runner
Pair-programming veteran. Good fit for small, tightly-scoped edits on a branch you watch closely.
Runner
Drives Cursor's agent from the plan when your team already lives in the editor. Tasks land as branches, not chat threads.
Runner
Block's open-source agent, extensible with MCP tools. Picks up your Goose extensions inside UseStage tasks unchanged.
Runner
Sourcegraph's agent for fast, parallel exploration. Useful as the research leg before a heavier model builds.
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
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
Generated from your goal and the planner's research. Rewrite any line; the runner gets your version, not the draft.
Runner + model + effort
Picked per task from that runner's real catalog. A rename doesn't need high effort; a data migration does.
Mode
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
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
Each build task works on its own stage/… branch. Nothing reaches your working tree until you merge it from the review screen.
Two surfaces
The same plan, the same state, in both places. Start a run in one and finish reviewing it in the other.
$ 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.
# 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
Approval is the default, not a setting you have to hunt for. Loosen it per project when a workflow has earned it.
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
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
The planner questions every vague corner of the request — scope, edge cases, what "done" looks like — before drafting a single task.
/to-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
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
A workflow is a saved plan shape: the same cast and order, pointed at a new goal each time.
workflow: feature
workflow: sweep
workflow: deflake
CLI reference
Everything the editor panel does, the terminal does too. The commands you'll actually live in:
| Command | What 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 runners | List 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 / resume | Freeze 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
The short version: your agents, your keys, your call — UseStage just keeps them on one plan.
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.
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.
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.
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.
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.
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
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.
curl -fsSL https://usestage.dev/install.sh | sh