[OpenCode Field Notes Part 4] Building a parallel sub-agent workflow with oh-my-opencode

1. Why plugins became necessary

In the context of Part 1, my goal was clear: keep the workflow stable even when tools change or sessions get long.

OpenCode is already strong out of the box, but as workload grows, role separation matters more.

Especially when operating multiple subscription accounts and auth paths, plugins were often essential. Connection methods varied by service, and default settings alone were not enough. Plugins let me integrate those channels into one working environment.

So for me, plugins were less about “adding features” and more about “binding multiple subscription channels into one practical workflow.”

Because default oh-my-opencode tends to be Claude Opus-oriented, I mostly used oh-my-opencode-slim for better cost/usage balance.

After moving to the oh-my-opencode family, my parallel routine across discovery/implementation/validation became stable.

2. Plugin setup

Install oh-my-opencode first.

Recommended:

bunx oh-my-opencode install

Alternative:

npx oh-my-opencode install

Then define plugins in your config.

• Global config: ~/.config/opencode/opencode.json
• Project config: <project-root>/opencode.json or <project-root>/opencode.jsonc

Both json and jsonc are valid. If your current setup already uses json, keep it. In my case, I operate with global ~/.config/opencode/opencode.json.

Example (opencode.json):

{
  "plugin": [
    "opencode-antigravity-auth@latest",
    "opencode-anthropic-auth",
    "opencode-cursor-auth",
    "@tarquinen/opencode-dcp",
    "oh-my-opencode-slim"
  ]
}

Restart opencode after saving.

I also manage provider blocks in the same file, such as google, anthropic, github-copilot, opencode, and cursor.

I included opencode-cursor-auth to leverage an already-paid 1-year Cursor subscription.

2-1. How I set a default prompt

I place AGENTS.md at project root to pin rules I want every session to follow.

You can generate it with /init in OpenCode, or create AGENTS.md manually.

Example:

# Project Rules

## Output
- Respond in English
- Do not output only answers; include 3 lines of core reasoning
- Add detailed comments in code
- Provide at least 2 examples (input/output)

## Coding
- Summarize impacted files before changes
- Provide test commands after changes
- Explain risky commands before execution

For learning use cases, these two rules were especially effective:

• “Do not output only the final answer; explain why”
• “Always include example inputs/outputs”

This keeps teaching-style output consistent without repeating the same instruction each session.

2-2. Role-based model mapping in oh-my-opencode-slim

I define role-based models in ~/.config/opencode/oh-my-opencode-slim.json. The structure is:

• choose active preset via preset
• assign model IDs in presets.<name>.<role>.model

My real setup (summary):

{
  "preset": "my-set",
  "presets": {
    "my-set": {
      "orchestrator": { "model": "opencode/kimi-k2.5-free" },
      "oracle": { "model": "kimi-for-coding/k2p5" },
      "librarian": { "model": "google/antigravity-gemini-3-flash", "variant": "low" },
      "explorer": { "model": "google/antigravity-gemini-3-flash" },
      "designer": { "model": "openai/gpt-5.2-codex" },
      "fixer": { "model": "kimi-for-coding/k2p5" }
    }
  }
}

So instead of putting expensive models everywhere, I split models by role to balance cost, speed, and quality.

Restart opencode after editing to confirm changes are applied.

3. Workflow: role split + parallel execution

• Discovery agent: locate files and relevant code paths
• Implementation agent: build/update features
• Validation agent: lint/test/regression checks

The key is narrowing responsibility per agent to reduce context collision and quality drift.

This was especially effective in long sessions: less context entanglement, less slowdown, and lighter session handoff burden.

4. Benefits I saw from this workflow

1. Shorter end-to-end lead time
2. Higher automation ratio for repetitive tasks
3. Better traceability even when many changes happen together

When “find-fix-verify” runs concurrently instead of sequentially, the speed gain is very noticeable.

5. Safe usage tips

• Keep each agent goal short and explicit
• Limit change scope by file boundaries
• Keep final merge decisions under human review
• Because CLI progress visibility is lower, leave short checkpoints per step

The faster the tool gets, the stronger review standards should be.

6. Why this also works for learning

OpenCode lets you control output format, so students do not have to consume only final answers.

For example, request this instead of “answer only”:

• add detailed comments in code
• provide at least two input/output examples
• present solution steps in sequence

This makes it easier to guide understanding-first learning, for both classroom support and self-study.

7. Sources

• oh-my-opencode: https://github.com/code-yeongyu/oh-my-opencode
• oh-my-opencode-slim (author): https://github.com/alvinunreal/oh-my-opencode-slim
• opencode-antigravity-auth: https://github.com/NoeFabris/opencode-antigravity-auth
• opencode-cursor-auth: https://github.com/POSO-PocketSolutions/opencode-cursor-auth
• opencode-anthropic-auth (npm): https://www.npmjs.com/package/opencode-anthropic-auth

Note: opencode-anthropic-auth worked when I used it, but npm currently shows a deprecation notice. Check status before use.