oh-my-openagent

Sisyphus main orchestrator coordinates 11 specialized agents (Hephaestus, Oracle, Librarian, Explore, Atlas, Prometheus, Metis, Momus, Multimodal-Looker, Sisyphus-Junior) with role-specific prompts and tool permission matrices. Each agent is matched to tasks based on capability profiles and model compatibility, with dynamic prompt building that injects agent-specific context. The orchestrator implements a planning workflow that decomposes user intent into subtasks, delegates to appropriate agents, and aggregates results.

The hashline_edit tool implements line-level content hashing (LINE#ID format) that validates code before applying modifications, ensuring zero-error edits by confirming the target content matches expected state. Each editable line is tagged with a hash of its content; edits are rejected if the hash doesn't match, preventing off-by-one errors and stale edit conflicts. This pattern integrates with AST-Grep for structural code navigation and LSP for semantic awareness.

Implements a planning workflow where planning agents (Oracle, Librarian) decompose complex user intents into structured subtasks before delegation to worker agents. Planning agents analyze the task, identify dependencies, and create an execution plan with task ordering and resource requirements. The plan is validated before execution, ensuring feasibility. This two-phase approach (plan then execute) reduces agent errors and enables better resource allocation.

Implements Ultrawork mode, a continuous execution mode where agents autonomously execute tasks without waiting for user confirmation between steps. Agents monitor task progress, handle errors, and adapt execution based on results. Ultrawork mode includes safeguards (resource limits, timeout enforcement, error thresholds) to prevent runaway execution. Session continuity ensures tasks can be resumed if interrupted.

Implements Deep Work mode, a focused execution mode where the Hephaestus agent (specialized in complex code generation and refactoring) works deeply on a single task with extended context and reasoning. Hephaestus has access to advanced tools (AST-Grep, LSP, code analysis) and can maintain longer reasoning chains. Deep Work mode is optimized for complex tasks requiring sustained focus, unlike Ultrawork's breadth-first approach.

Implements non-interactive and CI modes where agents execute without user interaction, suitable for automated CI/CD pipelines and batch processing. In CI mode, agents read input from files or environment variables and write output to files or stdout. Error handling is strict; agents fail fast on errors rather than attempting recovery. CI mode integrates with standard Unix tools (pipes, redirection) for easy pipeline composition.

Implements a debugging workflow where the Oracle agent analyzes errors, generates debugging hypotheses, and recommends fixes. Oracle has access to error logs, stack traces, and code context. The workflow supports interactive debugging (user provides feedback) and automated debugging (Oracle generates and tests fixes). Debugging results are logged for future reference.

Implements concurrent agent execution with task batching, enabling multiple agents to work in parallel on independent subtasks. The orchestrator analyzes task dependencies and groups independent tasks for parallel execution. Concurrency is managed via a configurable thread pool; parallelism is limited by available resources. Results are aggregated after all parallel tasks complete.

Integrates with Tmux (terminal multiplexer) to enable agents to spawn and manage terminal sessions for interactive workflows. Agents can send commands to Tmux sessions, capture output, and respond to interactive prompts. This enables agents to work with CLI tools, REPLs, and interactive applications. Tmux sessions are persistent across agent invocations, enabling stateful workflows.

Implements Ralph Loop, a task tracking pattern where agents maintain a todo list of remaining tasks and enforce completion before marking tasks done. Agents check off completed tasks and update the todo list as work progresses. This pattern prevents agents from skipping tasks or declaring completion prematurely. Todo enforcement is integrated with the planning workflow, ensuring all planned tasks are executed.

Implements automatic error recovery for model failures (rate limits, timeouts, API errors) with configurable retry strategies and fallback models. When a model fails, the system automatically retries with exponential backoff, then falls back to alternative models if retries are exhausted. Error recovery is transparent to agents; they don't need to handle model errors explicitly.

Implements a hierarchical hook system organized into 5 tiers (Session, Tool-Guard, Transform, Continuation, Skill) with 52 total hooks that fire at specific points in the agent execution lifecycle. Hooks enable custom behavior injection at pre-execution, post-execution, tool-call, and result-transform stages. Session hooks maintain state across multiple agent invocations, enabling multi-turn workflows and context preservation. Continuation hooks allow resuming interrupted tasks with full state recovery.

Provides a curated toolkit of 26 tools including Language Server Protocol (LSP) integration for semantic code analysis, AST-Grep for structural code navigation, task delegation primitives, background execution handlers, and session management utilities. Tools are organized by category (Code Manipulation, Interactive, Background Task) with explicit tool permission matrices per agent. LSP integration enables type-aware refactoring; AST-Grep provides syntax-tree-based code search and transformation without regex brittleness.

Implements a three-tier Model Context Protocol (MCP) system that merges built-in MCP servers, Claude Code MCP servers, and skill-embedded MCP servers into a unified tool namespace. Built-in servers provide core functionality; Claude Code servers extend with IDE-specific capabilities; skill-embedded servers are dynamically loaded from the skills system. MCP configuration is declarative via JSON schema, enabling zero-code MCP server registration and tool discovery.

Implements a skills system where reusable capability bundles (skills) can be dynamically loaded and injected into agent prompts at runtime. Skills encapsulate domain-specific knowledge, tools, and MCP servers. Dynamic prompt building injects skill context into agent prompts, enabling agents to discover and use skill capabilities without explicit tool registration. Skills are versioned and can be enabled/disabled per agent or globally.

Provides background task tools that enable agents to spawn long-running tasks (e.g., builds, tests, deployments) and poll for completion without blocking. Tasks are assigned unique IDs and their state is persisted, enabling recovery if the agent session is interrupted. Background task tools integrate with the session continuity system, allowing agents to resume monitoring tasks across session boundaries.

Implements dynamic agent-to-model matching that selects the optimal LLM provider and model for each agent based on capability profiles and availability. If the primary model is unavailable or rate-limited, the system automatically falls back to alternative models with compatible capabilities. Model resolution is declarative via configuration, enabling zero-code model switching without agent code changes.

Implements a categories system that classifies tasks into semantic categories (e.g., 'refactoring', 'testing', 'documentation'), enabling automatic routing to appropriate agents and tools. Categories are hierarchical and configurable; each category can specify preferred agents, allowed tools, and execution constraints. Task classification is performed by planning agents before delegation, ensuring tasks reach the right agent.

Implements a declarative configuration pipeline using JSON schema (oh-my-opencode.schema.json) that validates all configuration before runtime. Configuration covers agents, models, tools, hooks, skills, categories, and MCP servers. Schema validation catches configuration errors early, preventing runtime failures. Configuration is composable; multiple configuration files can be merged with explicit precedence rules.