Orchestration

Debug script runs in two steps when shell and sandbox execution keep failing

Report tool failures openly and deliver a minimal output with clear disclaimers

Find generated files lost in sandbox folders and copy them to expected paths

Track and finish every required deliverable before ending a task

Confirm every required output is complete before the task stops

Track deliverables systematically until the task is fully finished

Recover from failed inline Python with a four-step fallback sequence

Run Python through a fallback method when the sandbox fails with unknown errors

Run Python through a shell heredoc when the code sandbox fails

Run library-dependent Python through the shell when the sandbox fails

Run Python that needs external packages through the shell when the sandbox fails

Run Python scripts from saved files instead of inline heredocs for reliability

Create files with the shell or write_file when sandbox or shell tools fail

Run Python inline through the shell when the sandbox or file reader fails

Read and write files with inline Python in the shell when the sandbox cannot see them

Run code through a shell heredoc with verification when automated tools fail

Write Python to a file and run it through the shell when the sandbox fails

Recover from sandbox failures by writing Python scripts to files and running them

Write the script to a file and run it directly with the shell when the sandbox fails

Switch from the sandbox to file-based shell execution when it fails

Recover from sandbox failures by writing code to a file and running it in the shell

Run Python code through a fallback path when the sandbox execution fails

Run Python code with a fallback when the sandbox raises e2b errors

Run Python by saving scripts to disk and using the shell when the sandbox fails

Run embedded Python through the shell when the e2b sandbox is unavailable

Run Python through a shell heredoc when the sandbox execution tool fails

Find files in real workspace roots and verify output artifacts after generating them

Hand complex tasks to a delegated shell helper when direct tools fail

Create and modify files through a delegated shell helper with error recovery

Delegate file generation to a shell helper and locate the output files afterward

Run embedded Python from a shell heredoc when code execution tools fail

Run complex Python through a shell heredoc when the sandbox fails

Check output format, file coverage and task fit before calling the task complete

Create files and verify them after code execution fails with a fallback workflow

Confirm every required output file exists and is verified before marking done

Check the filesystem to confirm success after a tool reports a misleading unknown error

Classify failures that happen with zero iterations as pre-execution system issues

Create valid YAML workflow definitions through a guided step-by-step conversation

Create GSD milestones and monitor or steer projects from the headless CLI

Run GSD headless builds from a spec and verify the finished product

Design multi-agent workflows with clear handoffs, boundaries and monitoring

Plan and review Codex coding sessions with ChatGPT while Codex runs the code

Route hands-on coding to Codex while keeping specs and verification in Claude Code

Relay messages between Discord and an OpenClaw agent session

Coordinate maintainer work across issues, PRs and repos with bounded parallel workers

Send prompts and posts to an OpenClaw session over local or remote SSH

Build and debug Swarms framework workflows with sequential, concurrent and hierarchical setups

Create subagents with isolated context for verifier, debugger and orchestrator roles

Convene a panel of blind subagent jurors for a rigorous verdict on a decision