Slash commands

All autoducks commands are issue comments. The full grammar:

/<trigger> [model:<model>] [effort:<level>] [turns:<n>] [mode:<mode>] [#auto:<agent>+<agent>...]

The bare /<trigger> form (e.g. /execute) is the default — no prefix word between the slash and the verb. If your repository sets a command namespace in .autoducks/autoducks.json, insert it right after the slash instead: /<namespace> <trigger> ... (e.g. /quack execute). See Namespace below.

Cheat sheet

You want to…	Comment
Run the whole pipeline on an issue	/execute
Design (or revise the design) only	/architect
Plan (or revise the plan) only	/engineer
Design + plan, then stop for review	/architect #auto:engineer
Review a finished PR before merging	/review
Turn unresolved review feedback into a follow-up task	/rework
Save unresolved review feedback for later, merge/close now	/defer
Groom the backlog: priorities + duplicate proposals	/triage
Mark an issue as a duplicate of another	/merge #<issue>
Re-run a failed task	/fix (on the task issue)
Undo the plan, keep the issue	/revert
Tear everything down	/close
Use a stronger model at max effort	/execute model:opus effort:max
Cap the agent’s turns	/execute turns:30

Command routing

Command	Issue state	Who answers
/architect	any	Architect
/engineer	any (needs Design:done, else cascades to Architect)	Engineer
/execute	Task issue	Developer
/execute	has Tactics:done	Maestro
/execute	anything else	Engineer → cascade
/review	feature/bug issue with an open pipeline PR, or the PR itself	Reviewer
/rework	feature/bug issue with an open pipeline PR, or the PR itself	Rework agent
/defer	feature/bug issue with a pipeline PR (any state), or the PR itself	Defer agent
/triage	any issue (scoped) or no issue (full backlog sweep)	Product Owner
/merge	any open issue	Product Owner
/fix	any task	Fix agent
/revert	planned issue	Revert agent
/close	planned issue	Close agent

Routing signals are labels (with the native issue type as an org-only enhancement): Task, Tactics:done, Design:done, Feature/Bug. Agents apply them automatically — no manual labeling required.

Built-in aliases

Canonical verb	Aliases
architect	design
engineer	tactics
execute	run, work
fix / revert / close / review / rework / defer / triage / merge	(none)

Aliases behave identically to the canonical verb, including routing and cascade.

Overrides

Overrides apply to the triggered run — and propagate to chained agents and wave workers only when you set them explicitly (each agent otherwise resolves its own defaults).

Note

/triage and /merge don’t parse model:/effort:/turns: or #auto: from the comment at all — they’re a narrower grammar than the pipeline verbs. /triage’s model/effort/turns are only overridable via its workflow_dispatch inputs (falling back to its defaults.json/global config otherwise); /merge never invokes an LLM, so no override applies. See the Product Owner reference for details.

model:

/execute model:opus
/architect model:claude-sonnet-5

Alias	Resolves to
opus	claude-opus-4-8
sonnet	claude-sonnet-5
haiku	claude-haiku-4-5
any claude-* id	used as-is

Bare aliases also work positionally: /execute opus.

effort:

LLM effort level, passed straight through to the provider’s native reasoning-effort control — not injected into the prompt as a “think harder” instruction. For Claude, this is the CLI’s --effort flag, forwarded via claude_args alongside --model/--max-turns/--allowedTools (“effort” follows the cross-provider convention — OpenAI reasoning_effort, Anthropic output_config.effort).

Value	Description
off	No extended thinking
low	Faster, less thorough
medium	Balanced
high	Thorough (config default)
max	Maximum reasoning depth

On adaptive-reasoning models, off degrades to the model’s minimum reasoning effort rather than fully disabling thinking — the provider has no hard “no thinking” switch. max meaningfully increases per-run token spend, since the model reasons for longer before responding.

/engineer effort:max

Bare values also work positionally: /engineer max.

turns:

Maximum number of agentic turns for this run (1–1000). turns=<n>, max-turns=<n>, and max_turns=<n> are equivalent forms. Malformed or out-of-range values are ignored (the next tier of defaults applies).

/execute turns:80

On the wave path, the Maestro forwards model:/effort:/turns: from your comment to every dispatched Developer.

Priority (highest to lowest): inline directive → per-agent defaults.json → global autoducks.json → provider default (50 for turns).

mode:

Overrides the orchestrator’s dispatch topology for this run — waves or sequential.

/execute mode:sequential

Only meaningful on the wave path (/execute routed to the Maestro on an issue with Tactics:done); ignored elsewhere. A malformed or missing value simply falls through to the next tier of resolution.

Priority (highest to lowest): mode: directive → Mode:waves/Mode:sequential label on the issue → orchestrator.mode in autoducks.json → hard default waves.

#auto: — chaining

Queue agents to run after this one finishes, separated by +:

/architect #auto:engineer            # design → plan → stop
/architect #auto:engineer+execute    # full pipeline, explicit

Semantics:

• Only architect, engineer, execute, and review are chainable. Utility verbs (fix/revert/close/rework/defer/triage/merge) never carry or continue a chain — they always run standalone, even if you write #auto:fix, #auto:revert, #auto:close, #auto:rework, #auto:defer, #auto:triage, or #auto:merge.
• Verbs are alias-normalized (#auto:tactics+run ≡ #auto:engineer+execute), deduplicated, and capped at 5.
• A verb can appear at most once in a chain (loop protection); Definition-of-Ready delegations re-queue the current agent into the same chain.
• A chained execute targets the Maestro.
• A blocked run (e.g. Engineer in Questions Mode) stops the chain — answer and re-run.

See Chaining & overrides for recipes.

Can I run this again?

Yes — every agent recomputes from visible ITS/git state, so re-issuing the same comment is always safe and is how you resume an interrupted run, refine a design or plan, or retry after a fix. See Re-running agents for what each stage does on a second run and how to steer it.

Namespace

By default command is empty ("") in .autoducks/autoducks.json, so every trigger is a bare verb: /execute, /architect, /fix, and so on. Setting command to a word gives you a namespaced prefix instead — the escape hatch for repositories that need one, e.g. to avoid colliding with another bot’s slash commands:

{ "command": "quack" }

turns every trigger into /quack <verb> (/quack execute, /quack architect, …). The value is /-tolerant — "quack" and "/quack" both work — and must otherwise match ^/?[a-z0-9-]+$ (or be empty); anything else falls back to the default. GitHub evaluates workflow if: guards without reading repository files, so after changing command you must re-bake the guards and commit:

bash scripts/update-triggers.sh

The same applies to custom trigger aliases.

Bounded blast radius

A bare verb is shorter and slightly more likely to be matched by an unrelated comment than a namespaced one. Two safeguards bound the consequences of an accidental fire, whether or not you use a namespace:

• The Authorization Gate runs before anything else — an off-target match from an untrusted commenter is denied before any LLM call, comment, branch, or PR.
• Agents are safe, state-based no-ops — they recompute from visible ITS/git state rather than acting blindly, so a stray trigger with nothing to do (e.g. /revert on an issue that was never planned) is a no-op, not a destructive action.

Set command to a namespace word if you want the extra margin on top of those two gates.

Programmatic dispatch

Every pipeline workflow also accepts a direct workflow_dispatch:

# Full pipeline from the design stage
gh workflow run autoducks-architect.yml -f issue_number=42 -f auto_chain=engineer+execute

# Orchestrate a planned issue
gh workflow run autoducks-maestro.yml -f feature_issue=42

# One task against a specific base branch
gh workflow run autoducks-developer.yml -f issue_number=43 -f base_branch=feature/42-my-feature

Inputs actor, model, effort, max_turns, and auto_chain are available on the architect/engineer workflows (actor sets the done-assignee).