Introduction and Highlights
Relevant source files
The following files were used as context for generating this wiki page:
The OhMyOpenCode agent ecosystem is a sophisticated, multi-agent orchestration framework designed for autonomous software engineering. It separates the cognitive stages of software development—planning, execution, review, and specialized consultation—into distinct, high-performance agent roles. This architecture ensures high-precision outputs by preventing "context drift" and enforcing strict operational boundaries between planners and implementers.
The system is anchored by Prometheus, the strategic planner, and Sisyphus, the primary orchestrator and executor. Together with specialist agents like Oracle (architecture) and Momus (plan review), they follow a "Decision Complete" philosophy, ensuring that no execution begins until every technical ambiguity is resolved and a verifiable work plan is generated.
Sources: src/agents/prometheus/gpt.ts:16-25, src/agents/sisyphus.ts:70-85, src/agents/prometheus/identity-constraints.ts:10-25
Core Agent Architecture
The project utilizes a hierarchical agent model where specialized subagents handle distinct phases of the development lifecycle.
Prometheus: The Strategic Planner
Prometheus is strictly a planning agent. Its primary constraint is that it never writes code or executes tasks. When a user requests a fix or a feature, Prometheus interprets this as a request to generate a "Decision Complete" work plan.
The planning process follows a rigid three-phase lifecycle:
- Grounding (Phase 1): Silent exploration of the codebase using "explore" and "librarian" agents to discover patterns, schemas, and test infrastructures before asking the user questions.
- Interview (Phase 2): A consultative session to resolve user preferences and trade-offs, continuously updating a draft file in
.sisyphus/drafts/as "working memory." - Plan Generation (Phase 3): Converting the draft into a structured markdown plan in
.sisyphus/plans/after a mandatory "Metis" gap analysis.
Sources: src/agents/prometheus/gpt.ts:27-50, src/agents/prometheus/identity-constraints.ts:10-40, src/agents/prometheus/interview-mode.ts:10-40
Sisyphus: The Primary Orchestrator
Sisyphus serves as the "Primary" agent responsible for high-level orchestration, task management, and delegation. It operates with a "SF Bay Area Senior Engineer" identity, focusing on shipping verified code without "AI slop." Sisyphus manages the execution of plans by delegating specialized work to categories like visual-engineering, ultrabrain, or quick.
Sources: src/agents/sisyphus.ts:70-90, src/agents/sisyphus.ts:250-270
Specialist Advisor Agents
The system includes high-IQ advisor agents invoked for specific high-difficulty scenarios:
- Oracle: A strategic technical advisor used for complex architecture design, hard debugging (after failed attempts), and multi-system trade-offs.
- Momus: A "ruthless" plan reviewer that identifies blockers in generated plans. It ensures plans are executable and references (file paths/line numbers) are valid before work begins.
Sources: src/agents/oracle.ts:15-35, src/agents/momus.ts:20-35
Operational Flow and Intent Handling
The ecosystem uses an "Intent Gate" to classify every user request at Phase 0, ensuring the correct routing of tasks.
Intent Routing Table
| Surface Form | True Intent | Routing Decision |
|---|---|---|
| "Explain X" | Research | Explore/Librarian -> Synthesize -> Answer |
| "Implement X" | Implementation | Plan -> Delegate or Execute |
| "Look into X" | Investigation | Explore -> Report Findings |
| "What do you think?" | Evaluation | Propose -> Wait for Confirmation |
| "Error X / Broken" | Fix | Diagnose -> Minimal Fix |
Sources: src/agents/sisyphus.ts:105-120, src/agents/prometheus/gpt.ts:100-115
The Planning Workflow
This diagram illustrates the sequence from initial user request to a verified plan ready for execution.
The workflow ensures that exploration precedes questioning (Principle: Explore Before Asking) and that plans are audited by Metis and Momus before being finalized.
Sources: src/agents/prometheus/gpt.ts:130-250, src/agents/prometheus/plan-generation.ts:10-50
Key System Principles
The project's philosophy is built on three core pillars that guide all agent behavior:
- Decision Complete: A plan is not finished if an implementer has to make a judgment call. Every pattern, file reference, and approach must be resolved.
- Explore Before Asking: Agents must ground themselves in the codebase first. If a question can be answered by searching the repo (configs, types, schemas), the agent must find it autonomously.
- Two Kinds of Unknowns:
- Discoverable Facts: Facts about the system (handled via exploration).
- Preferences/Trade-offs: User intent (handled via early interview questions).
Sources: src/agents/prometheus/gpt.ts:52-65, src/agents/prometheus/identity-constraints.ts:105-120
Work Plan Structure
Generated plans are saved as Markdown files in .sisyphus/plans/. They are designed for maximum parallelism and zero-human-intervention verification.
Plan Component Summary
| Section | Description |
|---|---|
| Execution Strategy | Groups tasks into "Parallel Execution Waves" (Target: 5-8 tasks per wave). |
| TODOs | Atomic implementation + test units. Each MUST include QA Scenarios. |
| QA Scenarios | Detailed steps for agent-executed verification (e.g., Playwright, Bash/curl). |
| Verification Wave | Final parallel review by 4 agents (F1-F4) before completion. |
Sources: src/agents/prometheus/plan-template.ts:20-100, src/agents/prometheus/gpt.ts:280-350
Verification Strategy
The system enforces a "Zero Human Intervention" policy for verification. Every task must contain agent-executable QA scenarios.
Atlas (the orchestrator role often assumed by Sisyphus) operates under the rule that "Subagents routinely lie about completion." Verification involves reading every changed file and executing functional tests.
Sources: src/agents/sisyphus.ts:310-350, src/agents/prometheus/plan-template.ts:130-160
Summary
The "Introduction and Highlights" of the OhMyOpenCode ecosystem center on a rigid, plan-first architecture. By strictly separating the Titan-named roles—Prometheus (Foresight/Planning) and Sisyphus (Persistence/Execution)—the system achieves a high level of reliability and technical accuracy. The core innovation lies in its "Decision Complete" work plans and the multi-layered verification waves that ensure code quality without requiring manual human testing.