Oh My Opencode: Diepgaande Analyse en Modelgids voor Gespecialiseerde Agents

De grootste sprong in capaciteit in OpenCode komt van gespecialiseerde agents: een doordachte scheiding van orkestratie, planning, uitvoering en onderzoek.

Oh My Opencode verpakt dit idee in een “alles-inbegrepen” harnas waar Sisyphus een volledig “virtueel team” van agents coördineert met verschillende machtigingen, prompts en modelvoorkeuren.

Dit is de diepe duik in agents en modelroutings. Als je eerder in de reis zit:

• OpenCode quickstart — installeer en configureer de basis-agent
• Oh My Opencode quickstart — installeer de plugin, voer je eerste ultrawork-taak uit
• Oh My Opencode experience — resultaten uit de praktijk en community-benchmarks

Voor de bredere context van de AI-coderings-toolchain, zie de AI-ontwikkelaars tools overzicht.

Wat is Oh My Opencode en hoe breidt het OpenCode uit

OpenCode is een open-source AI-coderingsagent gebouwd voor de terminal. Het wordt geleverd met een TUI (Text User Interface), en de CLI start die TUI standaard als je opencode uitvoert zonder argumenten. Het is flexibel qua provider: het ondersteunt een groot catalogus van providers, inclusief lokale modellen, exposeert provider-configuratie via zijn config-bestand en /connect-flow, en behandelt alles van cloud-API’s tot Ollama-endpoints zonder patches.

Oh My Opencode (ook wel bekend als oh-my-openagent, of gewoon “omo”) is een community-plugin die OpenCode transformeert in een volledig multi-agent ingenieursysteem. Het voegt toe:

• het Sisyphus orkestratiesysteem met parallelle achtergronduitvoering
• 11 gespecialiseerde agents met distinct rollen, prompts die per modelfamilie zijn afgestemd, en expliciete toolmachtigingen
• LSP + AST-Grep voor IDE-kwaliteit refactoring binnen agents
• Hashline — een hash-geankerd bewerkingsgereedschap dat fouten met verouderde lijnen elimineert (zie hieronder)
• Ingebouwde MCP’s: Exa (webzoeken), Context7 (officiële documentatie), Grep.app (GitHub-zoeken), allemaal standaard ingeschakeld
• /init-deep — genereert automatisch hiërarchische AGENTS.md-bestanden door je project heen voor slanke contextinjectie

Een naamseigenaardigheid: het upstream-repository is nu gebrand als oh-my-openagent, maar het plugin-pakket en installatiecommando’s gebruiken nog steeds `oh-my-opencode**. De maintainer suggereert om het “oh-mo” of gewoon “Sisyphus” te noemen.

Waarom Oh My Opencode verschillende modellen toewijst aan verschillende agents

Oh My Opencode is gebouwd rond één fundamenteel idee: verschillende modellen denken verschillend, en de prompt van elke agent is geschreven voor één mentaal model. Claude volgt mechanics-driven prompts — gedetailleerde checklists, templates, stap-voor-stap procedures. Meer regels betekent meer naleving. GPT (vooral 5.2+) volgt principle-driven prompts — beknopte principes, XML-structuur, expliciete besliskriteria. Geef GPT een prompt van 1.100 regels voor Claude en het tegenstrijdt zichzelf. Geef Claude een prompt van 121 regels voor GPT en het dwaalt af.

Dit is geen eigenaardigheid die je kunt configureren. Het is het ontwerp van het systeem.

Het praktische gevolg: wanneer je het model van een agent verandert, verandert je welke prompt wordt afgevuurd. Agents die meerdere modelfamilies ondersteunen (Prometheus, Atlas) detecteren je model automatisch tijdens runtime via isGptModel() en schakelen automatisch van prompt. Agents die dat niet doen (Sisyphus, Hephaestus) hebben prompts die voor slechts één familie geschreven zijn — en ze verwisselen met de verkeerde familie degradeert de output aanzienlijk.

Hoe Oh My Opencode gespecialiseerde agents samenwerken

De vier agent-persoonlijkheidsgroepen

Agents vallen in vier groepen gebaseerd op welke modelfamilie ze geoptimaliseerd zijn voor. Dit is van belang voor zowel het begrijpen van het systeem als voor beslissingen over self-hosting.

Groep 1 — Communicators (Claude / Kimi / GLM): Sisyphus en Metis. Lange, mechanics-driven prompts (~1.100 regels voor Sisyphus). Ze hebben modellen nodig die betrouwbaar complexe, meervoudige instructies volgen over tientallen tool-oproepen. Claude Opus is de referentie. Kimi K2.5 en GLM-5 zijn sterke, kostenefficiënte alternatieven die vergelijkbaar gedragen. Overschrijf deze niet naar oudere GPT-modellen.

Groep 2 — Dual-Prompt (Claude preferred, GPT supported): Prometheus en Atlas. Detecteren automatisch je modelfamilie tijdens runtime en schakelen naar de juiste prompt. Claude krijgt de volledige, mechanics-driven versie. GPT krijgt een compacte, principle-driven versie die hetzelfde resultaat bereikt in ~121 regels. Veilig om beide te gebruiken; het systeem behandelt het schakelen.

Groep 3 — GPT-Native (GPT-5.3-codex / GPT-5.4): Hephaestus, Oracle, Momus. Principle-driven, autonome uitvoerstijl. Hun prompts nemen doelgerichte, onafhankelijke redenering aan — waarvoor GPT gebouwd is. Hephaestus heeft geen fallback en vereist GPT-toegang. Overschrijf deze niet naar Claude; het gedrag degradeert.

Groep 4 — Utility Runners (snelheid boven intelligentie): Explore, Librarian, Multimodal Looker. Voer grep, zoeken en ophalen uit. Gebruik opzettelijk de snelste, goedkoopste modellen die beschikbaar zijn. “Upgraden” van Explore naar Opus is als het inhuren van een senior ingenieur om administratieve klusjes te doen. Dit zijn ook de beste kandidaten voor vervanging door lokale modellen.

Delegatiemechanismen

Oh My Opencode gebruikt twee complementaire gereedschappen voor delegatie:

• task() — categorie-gebaseerde delegatie: kies een categorie zoals visual-engineering of deep, optioneel vaardigheden injecteren, en optioneel uitvoeren in de achtergrond
• call_omo_agent() — directe aanroep van een specifieke agent met naam, die categorierouting omzeilt

Beide ondersteunen parallelle achtergronduitvoering, met concurrentie afgedwongen per provider en per model.

Categorieën zijn modelroutings-presets

Wanneer Sisyphus delegeert aan een subagent, kiest het een categorie, geen modelnaam. De categorie wordt automatisch gekoppeld aan het juiste model.

Categorieën zijn ook de juiste abstractie voor self-hosting: koppel een categorie aan een lokaal model en elke taak die naar die categorie wordt gerouteerd, gebruikt het automatisch.

Model-resolutievolgorde

Agent Request → User Override (als geconfigureerd) → Fallback Chain → System Default

Providerprioriteit wanneer hetzelfde model beschikbaar is via meerdere providers:

Native (anthropic/, openai/, google/) > Kimi for Coding > GitHub Copilot > Venice > OpenCode Go > Z.ai Coding Plan

Oh My Opencode Agents: Volledig Overzicht met Rollen en Modelvereisten

Orchestrators

Sisyphus

Doel: Hoofd-orkestrator. Plant, delegeert en drijft taken tot voltooiing via agressieve parallelle uitvoering.
Groep: Communicator (Claude / Kimi / GLM)
Rol: De teamleider die over het hele codebase coördineert — zijn prompt van ~1.100 regels, gedreven door mechanics, heeft een model nodig dat elke stap kan volgen over tientallen tool-oproepen zonder het spoor te verliezen.

⚠️ Overschrijf Sisyphus nooit naar oudere GPT-modellen. GPT-5.4 heeft een dedicated prompt-pad, maar is niet de aanbevolen standaard. Claude Opus is de referentie.

Fallback-keten: anthropic/claude-opus-4-6 (max) → opencode-go/kimi-k2.5 → k2p5 → gpt-5.4 → glm-5 → big-pickle
Self-gehost: Sisyphus is de moeilijkste agent om lokaal te draaien. De complexiteit van zijn prompt maakt hem afhankelijk van modellen met sterke instructievolging over lange tool-oproepsequenties. Een lokaal Qwen3-coder of DeepSeek-Coder-V3 kan werken voor simpele taken, maar verwacht degradatie bij workflows die multi-agent coördinatie vereisen. Test bij self-hosting eerst met een enkele-agent taak voordat je parallelle uitvoering inschakelt.

Atlas

Doel: “Todo-list orchestrator.” Houdt een gestructureerd plan in beweging door voltooiing en sequentie af te dwingen.
Groep: Dual-prompt (Claude preferred, GPT supported)
Rol: Terwijl Sisyphus het grote plaatje behandelt, drijft Atlas de checklist. Detecteert automatisch je modelfamilie tijdens runtime en schakelt prompts dienovereenkomstig.

Fallback-keten: anthropic/claude-sonnet-4-6 → opencode-go/kimi-k2.5
Self-gehost: Een snel, betrouwbaar lokaal coder-model behandelt Atlas-stijl “drive the checklist”-werk redelijk goed, omdat de taken gestructureerder zijn dan Sisyphus’s orkestratie. Qwen3-coder met 32k+ context is een haalbaar startpunt.

Planning agents

De planninglaaf dwingt “denk voor je handelt”: vereisten verzamelen, gap detectie en plankritiek gebeuren allemaal voordat een uitvoeringsagent de taak ziet.

Prometheus

Doel: Strategisch planner met een interview-stijl workflow. Activeert wanneer je Tab drukt of /start-work uitvoert.
Groep: Dual-prompt (Claude preferred, GPT supported)
Rol: Interviewt je als een echte ingenieur — identificeert scope, brengt ambiguïteiten naar boven en produceert een geverifieerd plan voordat er één regel code wordt aangeraakt. De GPT-versie bereikt hetzelfde in ~121 regels; de Claude-versie gebruikt ~1.100 regels over 7 bestanden.
Samenwerkt met: Metis (gap detectie) en Momus (planvalidatie) voordat het overhandigt aan uitvoering.

Fallback-keten: anthropic/claude-opus-4-6 (max) → openai/gpt-5.4 (high) → opencode-go/glm-5 → google/gemini-3.1-pro
Self-gehost: Haalbaar met een sterk lokaal model met instructievolging bij lage temperatuur. De planningkwaliteit degradeert als het model je beperkingen en acceptatiecriteria niet in context kan houden tijdens een lang, meervoudig interview. Een contextvenster van minimaal 64k wordt aanbevolen.

Metis

Doel: Pre-planning consultant en gap-analyser. Draait op een hogere temperatuur dan de meeste agents om creatieve gap-detectie te bevorderen.
Groep: Communicator (Claude preferred)
Rol: “Wat hebben we gemist?” reviewer voor uitvoering — geen code-schrijvend werker, maar onderdeel van het verhaal van plan-kwaliteitscontrole.
Samenwerkt met: Wordt aangeroepen door Prometheus voordat het plan wordt finalized.

Fallback-keten: anthropic/claude-opus-4-6 (max) → opencode-go/glm-5 → k2p5
Self-gehost: Een lokaal redenerend model is prima. Houd de temperatuur niet-nul als je wilt dat Metis daadwerkelijk randgevallen naar boven haalt — stel het op 0 en het wordt een rubber-stamp.

Momus

Doel: Roekeloze plan-reviewer. Dwingt duidelijkheid en verificatiestandaards af. Kan opereren als een strikte “OK of verwerpen” poort.
Groep: GPT-native
Rol: QA-georiënteerde criticus voor plannen. Tool-beperkingen houden het in review-modus in plaats van uitvoeringsmodus.
Samenwerkt met: Wordt gebruikt na plan-creatie om haalbaarheid uit te dagen voordat het werk begint.

Fallback-keten: openai/gpt-5.4 (medium) → anthropic/claude-opus-4-6 (max) → google/gemini-3.1-pro (high)
Self-gehost: Als je Momus self-host, houd de sampling zeer laag. Het hele punt van Momus is stabiele, reproduceerbare kritiek — creativiteit is het laatste wat je hier wilt. Een sterk lokaal redenerend model bij temperatuur 0.1 of lager is de juiste configuratie.

Worker agents

Hephaestus

Doel: Autonome diepe werker. Geef het een doel, geen recept.
Groep: GPT-native — alleen GPT-5.3 Codex
Rol: De specialist die de hele dag in zijn kamer codeert. Veronderstelt het codebase, onderzoekt patronen en voert end-to-end uit zonder constant toezicht. De maintainer noemt het “The Legitimate Craftsman” (een opzettelijke verwijzing naar Anthropic’s beslissing om OpenCode te blokkeren).

⚠️ Geen fallback-keten — vereist GPT-toegang. Er is geen Claude-prompt voor deze agent. Het uitvoeren zonder OpenAI of GitHub Copilot betekent dat het niet kan uitvoeren. “GPT-5.3-codex-spark” bestaat, maar wordt expliciet niet aanbevolen — het comprimeert context zo agressief dat Oh My Opencode’s contextbeheer breekt.

Fallback-keten: openai/gpt-5.3-codex (medium) — geen fallback
Self-gehost: Er is vandaag geen haalbaar lokaal vervangingsmiddel voor Hephaestus. Zijn prompt is gebouwd rond de principle-driven, autonome exploratiestijl van GPT-Codex. Als je een diepe werker nodig hebt op een volledig lokale stack, gebruik Sisyphus-Junior met de deep-categorie in plaats daarvan (die routeert naar GPT-5.3 Codex, of valt terug op Claude Opus als dat wat je hebt).

Sisyphus-Junior

Doel: Categorie-gespaarne executor gebruikt door het delegatiesysteem.
Groep: Erfenst van welke categorie hem lanceerde
Rol: De “specialist aannemer” die zijn model overneemt van de categorie-configuratie. Dynamisch gecreëerd via task(), vaak met ingespoten vaardigheden, en kan in de achtergrond worden uitgevoerd voor parallelisme. Denk eraan als een blanco werker wiens capaciteit volledig wordt bepaald door welke categorie je toewijst.

Fallback-keten: anthropic/claude-sonnet-4-6 (default); in de praktijk erfgenst van de lancerende categorie
Self-gehost: Sisyphus-Junior is de meest praktische plek om met self-hosting te beginnen. Koppel elke categorie aan een lokaal model in oh-my-opencode.jsonc en elke categorie-gespaarne taak gebruikt het automatisch. Begin met quick (simpele taken), verifieer dat het werkt, en breid dan uit naar unspecified-low voordat je iets aanraakt dat routeert naar deep of ultrabrain.

Specialist subagents

Oracle

Doel: Alleen-lezen consultatie voor architectonische beslissingen en complex debuggen.
Groep: GPT-native
Rol: Senior architect en “laatste redmiddel” debugger. Opzettelijk beperkt van schrijvende en delegerende tools zodat zijn output adviserend blijft. Roep Oracle aan na groot werk, na herhaalde mislukkingen, of voordat je een hoge-stakes architectonische beslissing neemt.

Fallback-keten: openai/gpt-5.4 (high) → google/gemini-3.1-pro (high) → anthropic/claude-opus-4-6 (max)
Self-gehost: Als je Oracle self-host, kies je sterkste lokale redenerend model en houd de sampling zeer laag. Het kwaliteitsverschil tussen een bekwaam lokale redeneerder en GPT-5.4 is significant voor complexe architectonische vragen. In een hybride setup is Oracle een van de agents die het waard is om op een cloud-model te houden terwijl je utiliteitswerk lokaal verplaatst.

Librarian

Doel: Externe documentatie en open-source onderzoek.
Groep: Utility runner
Rol: Documentatie- en bewijsverzamelaar. Tool-beperkingen voorkomen bewerkingen, zodat het zich richt op bronnen en samenvatten. Ontworpen om parallel met Explore te draaien voor gecombineerde “binnen de repo + buiten de repo” bewijsverzameling.

Fallback-keten: opencode-go/minimax-m2.5 → minimax-m2.5-free → claude-haiku-4-5 → gpt-5-nano
Self-gehost: De beste agent om op dag één volledig lokaal te verplaatsen. Het werk van Librarian is ophalen en samenvatten, niet diepe redenering. Elk lokaal model met betrouwbare tool-oproepen behandelt het goed. Zelfs een 7B of 13B model is voldoende als het het “zoeken, verzamelen, rapporteren” patroon kan volgen zonder af te dwalen.

Explore

Doel: Contextuele grep en snel codebase-zoeken.
Groep: Utility runner
Rol: De “vind mij de relevante bestanden en patronen” agent. Voer 10 van deze parallel uit voor niet-triviale vragen, elk gescoopt naar een ander gebied van de codebase, en laat de orchestrator de resultaten synthetiseren.

Fallback-keten: grok-code-fast-1 → opencode-go/minimax-m2.5 → minimax-m2.5-free → claude-haiku-4-5 → gpt-5-nano
Self-gehost: Samen met Librarian is Explore het beste startpunt voor lokale inferentie. Het werk is patroonmatching en gestructureerd rapporteren — het model heeft geen diepe redenering nodig, alleen snelle, betrouwbare tool-oproepen en fatsoenlijke instructievolging. Een klein lokaal coder-model (Qwen2.5-Coder-7B of vergelijkbaar) met hoge doorvoer werkt goed.

Multimodal Looker

Doel: Vision-analist en “diagramlezer”. Analyseert afbeeldingen en PDF’s via een look_at-workflow.
Groep: Utility runner (vision vereist)
Rol: Zwaar tool-beperkt (alleen-lezen) om neveneffecten te voorkomen en het puur interpretatief te houden. Wordt gebruikt wanneer je UI-screenshots, architectonische diagrammen of PDF-pagina’s in de workflow moet voeden.

Kimi K2.5 wordt specifiek genoemd als uitstekend in multimodaal begrip — daarom zit het hoog in deze fallback-keten.

Fallback-keten: openai/gpt-5.4 → opencode-go/kimi-k2.5 → zai-coding-plan/glm-4.6v → gpt-5-nano
Self-gehost: Lokale vision vereist een multimodaal model met solide tool-oproepen en genoeg context. Als je lokale stack daar nog niet klaar voor is, houd Multimodal Looker op een cloud-model — een misconfigureerde lokale vision-pipeline produceert stille onzin, geen nuttige fouten.

Oh My Opencode Model Routing: Fallback Chains en Provider Priority

Per-agent standaarden en het “geen enkel globaal model” ontwerp

Oh My Opencode wordt geleverd met per-agent modelstandaarden en fallback-ketens, niet één enkel globaal model. Het ontwerp is opzettelijk opiniërend:

• Explore en Librarian gebruiken de goedkoopste, snelste modellen omdat ze geen diepe redenering nodig hebben
• Oracle en Momus gebruiken de hoogst-capaciteit modellen omdat hun output uitvoering poort
• Sisyphus en Prometheus krijgen de beste orkestratie-klasse modellen als standaard

De OpenCode Go tier ($10/maand)

OpenCode Go is een abonnementslaag die betrouwbare toegang biedt tot Chinese frontier-modellen via OpenCode’s infrastructuur. Het verschijnt in het midden van veel fallback-ketens als een brug tussen premium native providers en gratis-tier alternatieven.

Als je geen Anthropic- of OpenAI-abonnementen hebt, dekt OpenCode Go plus GitHub Copilot het grootste deel van de fallback-keten tegen lage kosten.

Provider mappings voor GitHub Copilot

Wanneer GitHub Copilot de beste beschikbare provider is, zijn agent-toewijzingen:

Prompt varianten volgen modelfamilies

Als je een agent van Claude naar GPT of Gemini verwisselt, gebruikt Oh My Opencode niet dezelfde prompt. Agents die meerdere families ondersteunen (Prometheus, Atlas) detecteren automatisch via isGptModel() en schakelen. Agents die meerdere families niet ondersteunen (Sisyphus, Hephaestus) hebben één prompt — verwissel ze naar de verkeerde familie en de output degradeert.

Als de output van je agent na een modelwissel niet goed voelt, controleer of je een modelfamiliegrens hebt overgestoken en keer terug.

Oh My Opencode draaien met Self-Gehoste en Lokale Modellen

Er zijn twee lagen om te configureren:

1. OpenCode moet weten over je lokale provider en model-ID’s
2. Oh My Opencode moet worden verteld welke agent welk model gebruikt (omdat de meeste agents je UI-geselecteerde model opzettelijk negeren)

Wat je realistisch lokaal vandaag kunt draaien

Stap 1 — Voeg een lokale provider toe aan OpenCode

OpenCode ondersteunt lokale modellen en aangepaste baseURL-waarden in provider-configuratie — Ollama, vLLM en elk OpenAI-compatibel endpoint zijn eerste-klasse opties. De OpenCode quickstart behandelt provider-authenticatie in detail.

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "ollama": {
      "npm": "@ai-sdk/openai-compatible",
      "name": "Ollama",
      "options": {
        "baseURL": "http://localhost:11434/v1"
      },
      "models": {
        "qwen2.5-coder:7b": { "name": "qwen2.5-coder:7b" },
        "qwen2.5-coder:32b": { "name": "qwen2.5-coder:32b" }
      }
    }
  }
}

Voor vLLM of LM Studio geldt hetzelfde patroon — wijs gewoon baseURL naar het /v1-endpoint van je server en lijst de modellen die je hebt geladen.

OpenCode vereist minimaal een contextvenster van 64k voor orkestratie-agents. Alles kleiner en je zult truncatiefouten zien midden in de workflow.

Stap 2 — Overschrijf agent-modellen in Oh My Opencode-configuratie

Configuratieslocaties (project heeft voorrang boven gebruiks-niveau):

• .opencode/oh-my-opencode.jsonc (project-niveau, hoogste prioriteit)
• ~/.config/opencode/oh-my-opencode.jsonc (gebruiks-niveau)

Een praktische hybride configuratie — lokale inferentie voor utiliteits-agents, cloud voor redenering:

{
  "$schema": "https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/dev/assets/oh-my-opencode.schema.json",

  "agents": {
    // Utility agents: een snel lokaal model is meer dan genoeg
    "explore":    { "model": "ollama/qwen2.5-coder:7b",  "temperature": 0.1 },
    "librarian":  { "model": "ollama/qwen2.5-coder:7b",  "temperature": 0.1 },

    // Sisyphus-Junior in quick-modus: lokaal is prima
    // (gecontroleerd via onderstaande categorieën)

    // Houd de redenerings-agents op cloud
    "oracle":  { "model": "openai/gpt-5.4",          "variant": "high" },
    "momus":   { "model": "openai/gpt-5.4",          "variant": "xhigh" },
    // Hephaestus: niet aanraken — het heeft GPT-5.3-codex nodig, geen fallback
  },

  "categories": {
    // Route simpele, gespaande taken naar lokaal model
    "quick":   { "model": "ollama/qwen2.5-coder:7b" },
    "writing": { "model": "ollama/qwen2.5-coder:7b" },

    // Houd zware redenering op cloud
    "deep":         { "model": "openai/gpt-5.3-codex", "variant": "medium" },
    "ultrabrain":   { "model": "openai/gpt-5.4",       "variant": "xhigh" }
  },

  "background_task": {
    "defaultConcurrency": 2,
    "providerConcurrency": {
      "ollama": 4,    // lokaal endpoint kan meer parallelisme aan
      "openai": 2,    // blijf binnen planlimieten
      "anthropic": 2
    },
    "modelConcurrency": {
      "ollama/qwen2.5-coder:7b": 4
    }
  }
}

Het kostenefficiënte alternatief voor volledige self-hosting

Voordat je je commit aan een lokale GPU-setup, overweeg de OpenCode Go + Kimi for Coding stack. Voor ongeveer $11 per maand dekt het:

• Kimi K2.5 voor Sisyphus en Atlas (Claude-klasse orkestratiekwaliteit tegen lage kosten)
• GLM-5 voor Prometheus, Metis en Momus (solide redenering, gratis tier beschikbaar)
• MiniMax M2.5 voor Librarian en Explore (snel ophalen)

Voor de meeste werklasten is dit goedkoper dan het draaien van een lokale inferentieserver en vereist het geen GPU-hardware.

Oh My Opencode Ingebouwde Gereedschappen: Hashline, Init-Deep, Ralph Loop en MCP’s

Hashline — hash-geankerd bewerkingsgereedschap

Een van de meest praktische verbeteringen in Oh My Opencode is hoe het code-bewerkingen behandelt. Elke lijn die de agent leest, komt terug met een content-hash:

11#VK| function hello() {
22#XJ|   return "world";
33#MB| }

Wanneer de agent bewerkt door die tags te refereren, zal de hash niet overeenkomen als het bestand sinds de laatste lezing is veranderd en de bewerking wordt verworpen voordat corruptie optreedt. Dit elimineert de hele klasse van “stale line”-fouten waar agents zelfverzekerd lijnen bewerken die niet meer bestaan. Het succespercentage van Grok Code Fast op bewerkingstaken steeg van 6,7% naar 68,3% alleen al door deze verandering.

/init-deep — hiërarchische contextinjectie

Voer /init-deep uit en Oh My Opencode genereert AGENTS.md-bestanden op elk relevant niveau van je projectboom:

project/
├── AGENTS.md              ← projectwijde context
├── src/
│   ├── AGENTS.md          ← src-specifieke context
│   └── components/
│       └── AGENTS.md      ← component-specifieke context

Agents lezen automatisch relevante context binnen hun scope. In plaats van het hele repo in context te laden aan het begin van elke run, haalt elke agent alleen wat relevant is voor waar het werkt.

Prometheus planning-modus — /start-work

Voor complexe taken, typ niet gewoon een prompt en hoop. Druk op Tab om Prometheus-modus te betreden of gebruik /start-work. Prometheus interviewt je als een echte ingenieur: identificeert scope, brengt ambiguïteiten naar boven en bouwt een geverifieerd plan voordat een uitvoeringsagent loopt. De “Decision Complete”-standaard betekent dat het plan nul beslissingen achterlaat voor de implementator.

Ralph Loop — /ulw-loop

Een zelf-referentiële uitvoeringslus die niet stopt totdat de taak 100% voltooid is. Gebruik dit voor grote, meervoudige taken waarbij je wilt dat het systeem zichzelf verifieert en doorgaat zonder jouw betrokkenheid. Het is agressief — zorg ervoor dat je concurrentielimieten zijn ingesteld voordat je het op een dure cloud-provider uitvoert.

Ingebouwde MCP’s

Drie MCP-servers zijn vooraf geconfigureerd en altijd aan:

• Exa — webzoeken
• Context7 — officiële documentatie lookup
• Grep.app — GitHub code-zoeken over openbare repositories

Je hoeft deze niet te configureren. Ze zijn standaard beschikbaar voor alle agents.

Voor praktische resultaten en community-benchmarks over hoe deze agents in de praktijk presteren, zie het Oh My Opencode experience artikel. Om de plugin vanaf nul te installeren, begin met de Oh My Opencode quickstart.