Orchestration

Delegate coding tasks to Kimi Code and run them non-interactively

Delegate coding tasks to MiniMax Code and run them non-interactively

Delegate a bounded task to the local OpenClaw agent without interaction

Delegate coding tasks to OpenCode and run them non-interactively

Delegate repository analysis or implementation to Pi non-interactively

Delegate a coding task to the Qoder CLI and get structured output

Delegate coding tasks to Qwen Code and run them non-interactively

Work through GitHub PR review comments in a loop until nothing actionable remains

Inspect and control Herdr panes, tabs, workspaces and commands from the terminal

Coordinate parallel code reviews and consolidate findings by severity

Split a feature into parallel work streams with file ownership and conflict rules

Break work into tasks with dependency graphs and balanced workloads for teams

Set messaging rules for agent teams covering plan approval and shutdown steps

Size and pick the right team of subagents for review, feature or debug work

Monitor and manage OpenCode tasks with helper scripts

Bootstrap a lightweight multi-agent dev team to plan, build and review work

Run an autonomous loop that changes code, measures results and keeps only wins

Read findings, verdicts and work products other agents left on a shared bench

Write structured status signals such as blocked or done for a team dashboard

Create a new workshop from a local directory or a private GitHub repo

Split a finished agent task run into what was tried, what worked and what blocked it

Build a workflow that starts an AI task on a trigger and notifies Slack or email

Design and run JavaScript workflows that coordinate many isolated agents on large audits

Delegate recon, planning and code changes to isolated subagents with clear roles

Read and reply to comments on a PostHog task, its artifacts and its canvases

Route a question to Codex, Gemini or other model CLIs and save the answer

Run a full autonomous build from idea to working code with minimal check-ins

Run a stateful improvement loop with an evaluator contract and a runtime limit

Stop active orchestration modes like autopilot or ralph and clear their saved state

Run declarative DAG pipelines with journaled crash recovery for multi-step work

Loop on a task until it is complete, checked by a configurable reviewer

Coordinate several agents on one shared task list with parallel work

Track several goals in durable plan and ledger files across long sessions

Consult another agent for help or bring in a specific agent the user names

Request a step-by-step plan from a stronger agent and carry it out yourself

Bring another agent into a task for expertise through two-way replies

Pick the allowed tools and skill presets for sub-agent roles before spawning them

Ask Claude or Gemini through their CLIs and save each answer as an artifact

Run interview, plan and goal stages in sequence for autonomous coding work

Run a research loop where a validator gates each step and state persists across runs

Stop any active OMX mode such as autopilot, ultrawork or team and clear its state

Coordinate several agents on a shared task list running in tmux panes

Create and run durable multi-goal plans that persist as repo-native artifacts

Define the acknowledge, mailbox and task lifecycle for tmux-based agent teams

Create, list, hibernate and manage AI Maestro agents from the CLI

Run and monitor local CLI agents in tmux sessions on a cron schedule

Send and read signed messages between agents over the AMP protocol

Apply design patterns for permissions, tools and human review in coding agents

Build autonomous agents that plan, act and self-correct reliably