Orchestration

Execute solution-driven implementation plans as a sub-agent with self-review

Write task prompts and coordinate parallel agent teams without writing code

Boot, race and monitor visible agent teams in the cmux cockpit on macOS

Run multi-agent debates with round-by-round transcripts to weigh options

Refine a target across repeated Algorithm cycles until it nears the ideal state

Delegate coding tasks to external CLIs like Codex and Claude Code

Design autonomous agent harnesses with eval scaffolds, rollback and approval gates

Design hosted background agents with sandboxes, warm pools and session persistence

Choose multi-agent patterns for supervisor, swarm, handoff and parallel coordination

Build self-improving agent harnesses that mine failures and propose bounded edits

Set up a recurring autonomous loop over Sentry issues or tickets with human review

Hand off tasks that need logins or files from another person with full context

Coordinate live multi-agent workers, cross-agent review and channel logs in Trellis

Consult a stronger model at key checkpoints before big decisions or declaring done

Cancel an active Ralph Loop and stop its iterative autonomous run

Split a large goal into parallel cloud agent workers and collect their handoffs

Start an iterative self-referential Ralph Loop that repeats a task until done

Explain how the Ralph Loop plugin works and show usage examples

Build and deploy persistent autonomous agents and visual AI workflows with AutoGPT

Build role-based multi-agent crews with sequential or hierarchical task execution

Evolve and optimize agent prompts and skills against benchmarks with automated loops

Draft a budget increase request when an autonomous agent loop runs low on tokens

Check token budget and spend before and after an agent loop run

Enforce a loop's constraints file on every run before any action is taken

Triage changes, CI failures and issues into a findings report for a loop

Independently verify agent-produced changes by running tests and checking diff scope

Route each request to the right skill by checking intent and risk first

Claim queued tasks, log step progress and verify gates in a SQLite work queue

Split colony work into parallel worker jobs with playbooks and retries

Have two AI models critique each other's answers over rounds before a synthesis

Run independent subtasks in parallel worktrees, each opening its own pull request

Delegate read-only investigation and debugging to sub-agents and synthesize reports

Run all remaining project phases autonomously from discussion through execution

Detect project state and route to the next right workflow step

Route codebase, docs, learnings and memory commands from one entry point

Route exploration, capture, sketch, spike and spec commands from one entry point

Route config, workspace, thread, update, ship and inbox commands from one entry point

Route project lifecycle, milestone, audit and summary commands from one entry point

Route code review, debug, audit, security, eval and UI checks from one entry point

Route discuss, plan, execute, verify and progress commands from one entry point

Replan with cross-model reviews until every plan concern is resolved

Check project progress, advance the workflow or dispatch a freeform request

Plan, dispatch and merge several quick tasks together as one batch run

Request peer review of phase plans from external AI command-line tools

Plan a phase in the cloud, review it in the browser, then import the result

Run parallel workstreams and switch, track or resume each one

Pick the right business diagnosis skill for your question and run it in chat

Simulate a multi-expert discussion on a topic and summarize where they disagree

Feed run feedback back into agent teams and skills to improve an existing harness