OpenCode + Oh My OpenAgent: My AI Dev Team That Never Sleeps

What OpenCode Is

OpenCode is an open-source AI coding agent written in Go. The important thing to understand is that it's model-agnostic — it doesn't care which AI backend you use. You can route it through Claude, GPT, Gemini, Grok, Kimi, or any model with an OpenAI-compatible API. That includes local models via Ollama, proxied enterprise subscriptions, and GitHub Copilot's API endpoint.

The interface is a TUI (terminal UI) that feels like a more capable version of what you'd get if you combined a coding chat agent with a shell. It reads your files, runs commands, writes code, and operates on your local codebase — same as Claude Code. The difference is in how flexible the model routing is and, more relevantly here, what Oh My OpenAgent builds on top of it.

If you're familiar with Claude Code, the mental model maps easily: OpenCode is the runtime; your agent configuration and harness live on top of it. Oh My OpenAgent is that harness.

What Oh My OpenAgent Adds

Oh My OpenAgent (sometimes called oh-my-opencode in the community) is a plugin/configuration system built on top of OpenCode. It ships with a set of named specialist agents, each with a distinct role, personality, and model assignment. The core idea is that different kinds of work benefit from different models — and routing them automatically at the agent level is more effective than picking one model and hoping for the best.

You don't micromanage which agent runs what. You just describe the task and the harness figures out the routing. Most of the time you'll interact with one of these five:

Sisyphus — The Orchestrator

Sisyphus is the main event. It's described as the "discipline agent" — it doesn't stop until the task is done, looping through errors, retrying, calling on other agents, and pushing forward exactly like the mythological figure pushing his boulder uphill. It's powered by Claude Opus, Kimi K2.5, and GLM-5 depending on task type, and it orchestrates the other agents as subprocesses.

If Claude Code does in 7 days what a human does in 3 months, Sisyphus does it in 1 hour.

— Community comparison floating around the Oh My OpenAgent Discord

That's obviously an enthusiastic benchmark, not a scientific claim. But the direction is real: a persistent orchestrator that doesn't context-switch away and doesn't give up is qualitatively different from a single-shot agent. Sisyphus keeps its own working notes, escalates blockers, and delegates sub-tasks to the appropriate specialist.

Hephaestus — The Deep Worker

Hephaestus is the autonomous builder. Powered by GPT-5.4 (when available via API or proxy), it's designed to receive a goal — not a recipe — and produce working code. You don't tell it step by step what to do. You say "build a rate-limited queue processor that handles retries with exponential backoff" and it goes away and builds it.

The distinction between Hephaestus and Sisyphus is: Sisyphus orchestrates and persists across the full project; Hephaestus is the skilled craftsman you call in when you need something built to spec without hand-holding.

Prometheus — The Strategic Planner

Prometheus runs in interview mode. Before any code gets touched, it asks you a sequence of clarifying questions — what does success look like, what are the constraints, what edge cases matter, what does the existing codebase assume. It produces a structured implementation plan that the other agents then execute against.

This is the agent you want for anything non-trivial. Skipping the planning step is the single biggest reason AI-assisted code gets messy fast — Prometheus forces you to be explicit before the blast radius gets wide.

Oracle — Architecture and Debugging

Oracle is the consultant. It doesn't write code — it reviews architecture decisions, diagnoses bugs, and explains what's wrong and why. Think of it as the senior engineer you can ask "why is this pattern a bad idea" without getting a generic answer.

Explore and Librarian — Fast Cheap Lookup

These are lightweight agents. Explore handles codebase search — finding where a pattern is used, tracing how data flows through modules, locating the config that controls a behaviour. Librarian handles documentation lookup. Both are intentionally cheap to run: fast, small context, narrow scope. You don't send them in for reasoning, you send them in for retrieval.

The model routing here matters: why burn GPT-5.4 tokens on "find all files that import useAuth" when a fast Gemini Flash call gets the answer in 300ms at 1/20th the cost?

The Magic Word: ultrawork

The trigger for full orchestration is a single word: ultrawork (or the alias ulw). Type it as your opening command and every agent activates in coordinated sequence — Prometheus plans, Hephaestus builds, Sisyphus loops until done, Oracle reviews, Explore maps the blast radius. The session doesn't end until the task is complete.

This isn't just a convenient shortcut. It's the mental model shift: you're not asking an AI for help with a task, you're handing off the task entirely. The difference in how you write the prompt changes too — instead of "help me refactor this auth module" you write a spec: goal, constraints, acceptance criteria. Then you type ultrawork and step back.

For precision work where you want more control — stepping through a specific implementation plan piece by piece — press Tab to enter Prometheus planner mode directly. You get the structured interview before anything runs.

Why Multi-Model Routing Actually Matters

Single-model coding setups have a ceiling. Every model has trade-offs: Claude Opus is strong at multi-step reasoning and maintaining long context coherence; GPT-5.4 has strong code synthesis from high-level goals; Gemini Flash is fast and cheap for retrieval tasks; Kimi K2.5 has a 128k context window that handles large codebases without truncation.

Routing automatically based on task type means you're not paying for Opus tokens when you're just searching a file, and you're not using a cheap fast model for something that needs deep reasoning. Over a full day of development work, this compounds significantly — both in cost and in output quality.

• Reasoning and orchestration → Claude Opus / Kimi K2.5
• Code generation from goals → GPT-5.4
• Architecture review and debugging → Oracle (Claude-backed)
• Codebase search and doc lookup → Gemini Flash or equivalent cheap model

My Own Setup: No Per-Token Cost Surprises

One practical note about how I run this: I'm routing through GitHub Copilot's API proxy, which gives me access to Claude Opus and Sonnet, OpenAI's models, and Gemini — all under the flat Copilot subscription. No per-token API costs burning through a budget mid-session.

The setup is: GitHub Copilot subscription → OpenCode Go (the binary) → Oh My OpenAgent harness on top. The Copilot API is OpenAI-compatible, so OpenCode routes to it cleanly. I also have a direct OpenAI API key configured as a fallback for GPT models when I want access to the absolute latest endpoints.

For people coming from Cursor or Windsurf who are nervous about usage caps: the flat subscription model changes the calculus entirely. When you're running Sisyphus on a long task, you're making a lot of API calls. Having those covered under a predictable monthly cost rather than per-token billing makes ultrawork actually practical.

The Security Note You Cannot Skip

Run this inside a sandboxed environment. Not on your host machine.

Sisyphus is an autonomous agent that loops until done. It runs shell commands, installs packages, and writes to your filesystem. That is exactly what makes it powerful — and exactly why you should not hand it full access to your host machine, your SSH keys, or your production secrets.

I covered my sandbox setup in detail in a previous post: How I Built a Bulletproof Vibe-Coding Environment on Linux. The short version: vibebox is a rootless Podman container that can only see /Projects, has npm ignore-scripts=true baked in, and mounts project secrets read-only. Any agent running inside it — Claude Code, Gemini CLI, or OpenCode — operates within those constraints.

The principle is the same regardless of which AI coding tool you use: the more autonomous the agent, the more important the sandbox. Sisyphus looping through 50 steps unattended is great. Sisyphus doing that with access to your AWS credentials and production database is a different situation entirely.

Honest Impressions After Using It

I'll be straight: this is not for every task. For quick single-file edits, targeted bug fixes, or things where you want to stay in the loop at every step, Claude Code's interactive model is still better. The overhead of spinning up full orchestration doesn't pay off when the task takes 10 minutes.

Where Oh My OpenAgent genuinely shines is larger, multi-step work: implementing a new feature end-to-end across multiple files, refactoring a module to a new pattern throughout a codebase, building a new service from a spec, migrating a data model. Tasks where a human would normally block out 2-3 hours.

The community reactions I've seen are real: "use oh-my-opencode, you will never go back" is an overstatement for all cases, but it's not an overstatement for the specific case of handing off a complex autonomous task and coming back to working code.

One thing I do appreciate that's different from Claude Code: the model flexibility. My Claude Code setup is locked to Anthropic's models (though with extensive agent configuration on top). OpenCode lets me swap out which model handles which role based on what's best right now — and "best" changes as models update. The harness abstracts that switching away from the individual task.

Getting Started

Install OpenCode Go binary from the OpenCode website, then clone and configure the Oh My OpenAgent repository. The README walks through the model configuration — you'll need to point it at whichever API endpoints you're using. If you're on GitHub Copilot, the proxy endpoint configuration is straightforward.

1. Install the OpenCode Go binary
2. Clone the Oh My OpenAgent repo and follow the configuration guide
3. Set up your API keys or proxy endpoint (GitHub Copilot works well here)
4. Set up your sandbox first — do not run this on your host with full filesystem access
5. Start with a scoped task: type ulw and describe what you want built
6. Try Tab + Prometheus for anything that involves architectural decisions

The mental shift worth making early: write specs, not requests. "Build X with these requirements and constraints" outperforms "help me with X" by a significant margin when you're running autonomous agents.