| name | superdelegate |
| description | How to hand work to another agent, run Autopilot, and work through an issue backlog with safe parallelism. Loaded into every session. |
| auto | true |
Handing work out
Which lane
| The work | Use |
|---|
| One command, one answer | shell |
| The same thing to N independent parts | delegate |
| Run Autopilot / keep going from context | Autopilot below |
| A backlog of issues, in parallel | the method below |
Run a single command yourself. Starting an agent to run pwd costs minutes and
real money and hands back an answer nobody watched being produced.
delegate starts child coding agents that run the same prompt in parallel, each
with its own file and shell tools. Children start with no context from this
conversation and cannot ask questions, so the prompt carries everything. Every
child gets the same prompt and is told its own number separately — write for
whichever child is reading rather than naming one.
The delegate tool uses the child lane configured for this Coder session. The
standalone openagents delegate command accepts --lane; supported values are
openagents, gemini, opencode/<model>, devin, claude, and codex.
Choose the lane before you start a fan-out.
devin runs the children on the Devin CLI, and devin:<mode> picks a
permission mode other than the default dangerous. A Devin child brings its own
credentials and model rather than spending this session's grant. Prefer it over
running devin yourself through shell: a fleet child renders, stops with
ctrl+x, and does not block the turn, while a shell child is one opaque call
that freezes the session until it ends.
Autopilot
When the person says run Autopilot, start it. Do not reimplement the loop
in this session.
openagents coder --autopilot
openagents coder --autopilot "work the open issues"
openagents coder --autopilot --dry-run
openagents --autopilot
The CLI takes stock of this workspace, recent local Coder sessions, and open
issues, then keeps iterating until a stop condition. --dry-run prints that
plan without calling a model. Hosted lanes need a token; --lane local can
run unsigned when Ollama answers.
Autopilot is one unattended loop that picks the next unit itself. delegate
fans the same prompt out to N children. Do not wrap Autopilot in delegate.
Do not start Autopilot for one named issue you can finish here. The
openagents-cli skill has the rest.
Burning through a backlog
When the task is "work the issues" rather than one named thing, this is the
method. It is opinionated on purpose: the decisions below are the ones that go
wrong when they are made ad hoc.
1. Read the board before touching it
List open issues in every repository the account can reach —
OpenAgentsInc/openagents and OpenAgentsInc/openagents.com at least. Use the
openagents tool, read the plain output, and use --json only to take a field.
2. Workable means unblocked
openagents issue view <n> reports Blocked and Blocked by. A blocked issue
is not workable, however ready it looks, and starting one wastes a child and
produces a change that cannot land. Name the blocked ones as blocked, say what
they wait on, and leave them.
Prefer agent-ready. An issue whose shape is still a question is not ready for
a child that cannot ask one.
3. One child per surface
Two children editing the same files is a merge conflict nobody asked for. Group
the workable issues by the surface they touch — a package, a directory, a
module — and keep one child in flight per surface. Issues on different
surfaces run together freely.
If two issues must touch the same surface, run them in sequence, or give each
child its own git worktree so their edits cannot meet.
4. Route by the kind of thinking
- Devin for straightforward engineering: a named fix, a test to write, a
migration, a rename, a documented change with a clear shape.
- OpenAgents for design, architecture, and work where the shape of the
answer is still the question.
If you cannot tell which, it is the second kind.
5. Find the width, do not pick it
Never choose a number and hope. Start at about four and climb:
- Run a round of four.
- Before widening, look: system load and free memory
(
uptime, vm_stat or free), openagents auth status for the account,
and whether any child came back with a rate limit, a quota refusal, or a
provider error.
- If all three are clean, raise the width — four, six, eight — and go again.
- At the first sign of a limit, stop raising and hold at the last width
that was clean. Do not push past it to confirm; the confirmation costs a
round of failed children.
The width is a measurement, not a setting. A machine with sixteen idle cores and
a healthy account should be running far more than four; one that is swapping
should be running fewer. Report the width you reached and what stopped it.
6. Report as you go
After each round, say which issues were selected, which were skipped and why,
what each child returned, and where the width stands. A backlog run that reports
only at the end is one nobody can steer.
Working and completing issues
When assigned or requested to fix or work on an issue, deliver the solution
completely: verify the fix with tests, push directly to main (or the working branch),
and close the issue without a separate confirmation step.
Take care not to step on other people's concurrent work: check git status and remotes
before pushing. An agent reporting that it finished is not evidence that it did:
read the diff, run the test, and verify the output before closing.
