Oh My Opencode Snabbstart för OpenCode: Installera, Konfigurera och Kör

Installera Oh My Opencode och leverera snabbare.

Sidinnehåll

Oh My Opencode gör OpenCode till en multi-agent kodningsplattform: en orkestrator delegerar arbete till specialiserade agenter som kör parallellt.

oh my opencode agents med bärbara datorer och gpu

Den kortaste mentala modellen du behöver: installa pluginet, använd sedan nyckelordet ultrawork (eller ulw) när du behöver full kraft multi-agent-exekvering.

Denna snabbstart täcker installation och konfiguration för första dagen. När du är igång:

För den bredare AI-kodningsverktygskedjan, se översikt över AI-utvecklarverktyg. Om du föredrar ett sandboxat, webbläsarkompatibelt alternativ till OpenCode, tar OpenHands en annan arkitektonisk väg till agentbaserad kodning.

Varför Oh My Opencode finns

OpenCode är en öppen källkod AI-kodningsagent som kör som en terminalanvändargränssnitt och hanterar icke-interaktiva CLI-körningar för skriptning och automatisering.

Oh My Opencode sänker taket mycket högre. Det lägger till ett fullständigt orkestreringsskikt byggt kring “Sisyphus”-agenten, samarbete mellan flera specialister och tätare verktygsintegration. Resultatet är ett system där komplexa ingenjörsuppgifter — den typ som normalt skulle kräva att du håller koll på flera prompts — planeras, delegeras och verifieras i ett enda flöde.

Två koncept dyker upp ständigt, så nita dessa innan något annat:

  • Ultrawork-läge: ett nyckelord-aktiverat flödesskift. Att lägga till ultrawork eller ulw till din prompt aktiverar parallell bakgrundsexekvering, LSP-integration, kontexthantering och automatisk uppgiftsdekomposition — det är inte bara ett stilval.
  • Specialiserade agenter: namngivna roller som @oracle för arkitektur och @librarian för forskning och dokumentation. Du kan anropa dem explicit, eller låta orkestratorn routa till dem automatiskt.

Denna artikel använder Oh My Opencode, oh-my-opencode och Oh My OpenCode interchangeably — de syftar alla på samma plugin i OpenCode-ekosystemet.

Förutsättningar och terminologi

Du behöver ha OpenCode installerat och fungerande först. Se vår OpenCode Snabbstart för att lära dig hur du installerar, konfigurerar och startar den.

Som standard startar opencode terminalanvändargränssnittet när den körs utan argument, och du kan också använda opencode run ... för icke-interaktiv exekvering.

Oh My Opencode kräver minst en konfigurerad leverantör. OpenCode laddar leverantörer från inloggningsuppgifter, miljövariabler eller ett projekt .env. Det snabbaste sättet att få det löst:

opencode auth login
opencode auth list

Inloggningsuppgifterna finns i ~/.local/share/opencode/auth.json.

En namngivningskuriositet som är värd att veta i förväg: det upstream GitHub-repositoriet är nu varumärkesmärkt som oh-my-openagent (“tidigare oh-my-opencode”), men plugin- och paketnamnet i konfigurationer är fortfarande oh-my-opencode. Båda namnen cirkulerar i community-poster — det är samma sak.

Installation snabbstart

Det finns flera vägar (CLI-installatör, manuell repo-kloning eller “låta en agent installera det”). Det rätt val beror på om du vill ha ett upprepbar installationsflöde eller full manuell kontroll.

Om du har Bun installerad, är bunx Bun:ets npx-ekvivalent, utformad för att köra npm-paket snabbt utan ett separat globalt installationssteg.

För att installera bunx på linux:

curl -fsSL https://bun.com/install | bash

Automatisk installation med OpenCode

Du kan utföra en prompt i OpenCode och den kommer att installera OmO automatiskt

Installera och konfigurerar oh-my-opencode genom att följa instruktionerna här:
https://raw.githubusercontent.com/code-yeongyu/oh-my-openagent/refs/heads/dev/docs/guide/installation.md

Den kommer att ställa några frågor om dina LLM-prenumerationer och registrera Oh My Opencode i OpenCode-plugins.

Manuell väg: kör Oh My Opencode-installatören med bunx eller npx

Interaktiv installatör som frågar om dina leverantörer och genererar en “optimal” konfiguration automatiskt, samt ett icke-interaktivt läge för automatisering och agenter.

Interaktiv installation:

bunx oh-my-opencode install
# eller om du föredrar npm-verktyg
npx oh-my-opencode install

Icke-interaktiv installation (nyttig för provisionskript, CI-bilder eller “agent-installationer”):

bunx oh-my-opencode install --no-tui \
  --claude=<yes|no|max20> \
  --openai=<yes|no> \
  --gemini=<yes|no> \
  --copilot=<yes|no>

Vad installatören gör, på hög nivå:

  • registrerar pluginet i OpenCode-konfigurationen
  • genererar modelltilldelningar baserat på leverantörtillgänglighet och fallback-regler
  • skriver oh-my-opencode-konfigurationen bredvid OpenCode-konfigurationsfiler

Manuell väg: klonar repositoriet och kör installationskriptet

Det finns också ett “mänskligt” manuellt flöde: klonar repositoriet, installerar beroenden, kör sedan ett installationskript som detekterar din OpenCode-konfigurationsplats, gör en säkerhetskopiering och sammanför inställningar.

git clone https://github.com/code-yeongyu/oh-my-opencode.git ~/.oh-my-opencode
cd ~/.oh-my-opencode
npm install
npm run install

Om skriptet inte kan hitta din OpenCode-konfiguration automatiskt, sätt konfigurationsvägens miljövariabel explicit innan du kör installatören igen.

Snabb verifieringschecklista

Efter installationen, validera tre saker:

  • din Oh My Opencode-konfigurationsfil finns på en erkänd plats
  • specialiserade agenter kan anropas
  • ultrawork-nyckelordstrigger fungerar som förväntat

Exempel att kopiera:

# Visa plugin-konfigurationsfilen (pröva platsen som matchar din konfiguration)
cat .opencode/oh-my-opencode.json
cat ~/.config/opencode/oh-my-opencode.json

# Snabb agenttest
opencode run "Använd @oracle för att analysera arkitekturen för det nuvarande projektet"

# Snabb ultrawork-trigger-test
opencode run "ulw lista alla konfigurationsfiler i detta projekt"

Om alla tre klarar, är du verkligen redo — inte bara installerad.

Konfiguration och finjustering

Var konfigurationen finns och hur prioritet fungerar

Oh My Opencode letar efter konfigurationsfiler i en prioriteringsordning, där projekt-nivåns konfiguration får företräde framför användarnivåns konfiguration. Den dokumenterade sökordningen är:

  • .opencode/oh-my-opencode.json (projekt-nivå, högsta prioritet)
  • ~/.config/opencode/oh-my-opencode.json (användarnivå på macOS och Linux)
  • %APPDATA%\opencode\oh-my-opencode.json (användarnivå på Windows)

OpenCode själv stöder också flera konfigurationskällor och sammanfogar dem istället för att ersätta dem, där senare källor skriver över tidigare endast när nycklar krockar. Detta är viktigt eftersom du vanligtvis vill ha en stabil global baslinje plus per-repo-överföringar.

JSONC-stöd för förnuftiga konfigurationer

Både OpenCode och Oh My Opencode stöder JSONC, vilket innebär att du kan behålla kommentarer och påföljande kommatecken i konfigurationsfiler utan att bryta tolkningen. Detta är särskilt hjälpsamt för att dokumentera varför vissa gränser eller modeller valdes.

Nyckelordet “ultrawork” och vad det aktiverar

ultrawork (eller ulw) är lägesbytet du kommer att nå efter oftast. Släpp det i din uppgiftsbeskrivning och systemet aktiverar bakgrundsparallell exekvering, LSP-integration, kontexthantering och automatisk uppgiftsdekomposition. Det är inte en hint till modellen — det är en hård trigger som ändrar hur hela körningen struktureras.

Konkurrens och bakgrundsuppgifter

Oh My Opencode exponerar konkurrenskontroller för bakgrundsexekvering via sisyphus.max_concurrent_tasks.

Jaga inte hög konkurrens här. Varje leverantörplan har ett tak — Claude Max20 toppar vid 3 parallella uppgifter, till exempel — och att trycka förbi det producerar flakiga slutföranden och svår-debuggade timeout. Börja konservativt och öka bara efter rena körningar.

En minimal konkurrenskonfiguration ser ut så här:

{
  "sisyphus": {
    "enabled": true,
    "max_concurrent_tasks": 2,
    "task_timeout": 300
  }
}

En konkurrens på 2 är en säker startpunkt för de flesta planer.

Modellroutning per agent och per kategori

Oh My Opencode är byggt kring idén att olika uppgifter gynnas av olika modeller, så konfigurationen stöder:

  • modellval, varianter och promptutökningar per agent
  • kategori-baserad routning för “snabbt” vs “djupt” arbete
  • fallback-modeller när din föredragna leverantör är otillgänglig

Djupdykningen i specialiserade agenter täcker hela modellroutningssystemet i detalj — inklusive varför vissa agenter inte får bytas till fel modellfamilj, de fullständiga fallback-kedjorna, och hur man säkert overridear modeller för självvärdshärdade installationer.

Modellupplösning är lagerad: din explicita override vinner, sedan leverantörsfallback, sedan systemstandard. Fallback-kedjan börjar med dina inhemska leverantörer och kan falla ner till alternativ som GitHub Copilot om inget annat är tillgängligt — vilket innebär att en felkonfigurerad agent är osannolik att tyst misslyckas; den kommer bara att använda en svagare modell.

En praktisk startkonfiguration du kan anpassa (JSONC rekommenderas):

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

  // Håll konkurrensen konservativ tills du litar på dina leverantörsgränser
  "sisyphus": {
    "enabled": true,
    "max_concurrent_tasks": 2,
    "task_timeout": 300
  },

  // Agentjustering
  "agents": {
    "oracle": {
      "enabled": true,
      "model": "openai/gpt-5.2",
      "variant": "high",
      "temperature": 0.7,
      "prompt_append": "Ge koncisa avvägningar och en tydlig rekommendation"
    },
    "librarian": {
      "enabled": true,
      "model": "google/gemini-3.1-pro"
    }
  },

  // Kategori-routning för snabba frågor vs djupare arbete
  "categories": {
    "quick": { "model": "opencode/gpt-5-nano" },
    "visual-engineering": { "model": "google/gemini-3.1-pro" }
  }
}

Fältet $schema är värt att behålla — det låser upp autokomplettering i de flesta redigerare och fångar stavfel i agentnamn innan du slösar en körning med en trasig konfiguration.

MCP-integration och hänglar

Oh My Opencode stöder MCP (Model Context Protocol) servrar via en konfigurationsblock där du definierar serverkommandot, argument och miljövariabler.

I praktiken är den enklare vägen att hantera MCP direkt genom OpenCode med kommandogruppen opencode mcp — den hanterar att lägga till, lista och OAuth-autentisering utan att du behöver röra konfigurationsfiler manuellt.

Arbetsflödesexempel du kan kopiera

De två exemplen nedan är medvetet formade som “verkliga repos”: de visar hur man utlöser orkestrering, hur man siktar på specialiserade agenter, och hur man håller resultaten verifierbara.

Exempel: Arkitekturgenomgång med Oracle och en repo-karta

Använd detta när du ansluter till en ny kodbas eller ärvt en tjänst och behöver en snabb, åtgärdsbar vy av arkitekturen. Oracle är en skrivskyddad specialist — den kan inte göra ändringar, bara ge råd.

Kör den från din projektröt:

opencode

OpenCode kommer att starta sitt terminalanvändargränssnitt som standard när det startas utan argument.

Be sedan Oracle att producera en arkitekturanalys och en konkret omstrukturering eller modulariseringsplan:

Använd @oracle för att analysera arkitekturen för detta repositorium.
Identifiera de nyckelbegränsade kontexterna, de stora beroende-kanterna och de komponenter med högst risk.
Avsluta med en omstruktureringsplan som kan utföras i små PR.

För loggning eller skriptning, hoppa över TUI helt och använd opencode run:

opencode run "Använd @oracle för att analysera arkitekturen för detta repositorium och föreslå en etappvis omstruktureringsplan"

opencode run skickar prompten direkt och avslutar när den är klar — exakt vad du vill ha för CI-steg eller automatiseringspipelines.

Exempel: Full implementering av funktion med ultrawork-orkestrering

Använd detta när du behöver en funktion som rör flera filer eller lager, eller när du vill att bakgrundsuppgifter och specialiserade agenter aktiveras automatiskt.

Börja med en ultrawork-prompt:

opencode run "ultrawork implementera en ny /health-endpunkt med readiness- och liveness-kontroller, lägg till tester, uppdatera dokumentation och verifiera att den körs lokalt"

Nyckelordet ultrawork aktiverar alla konfigurerade specialiserade agenter, bakgrundsuppgiftsparallellitet och djupare verktyg i ett enda slag. Du behöver inte separata prompts för planering, implementering och testning.

När du använder ultrawork kan du fortfarande explicit styra agentbeteende. Till exempel kan du tvinga arkitekturdesignen först:

opencode run "ultrawork be @oracle designa endpunktavtalet och beroendena först, implementera sedan med minimala ändringar och lägg till tester"

Att kombinera ultrawork med explicita agentnämnningar som @oracle är den gyllene medelvägen: du får full orkestrering men behåller fortfarande kontroll över vilken specialist som hanterar de kritiska designbesluten.

En sak att få rätt för större ultrawork-uppgifter: håll konkurrensen inom dina leverantörsgränser. Börja på 2, kör några uppgifter rent, och bestäm sedan om du ska öka. Att trycka förbi din plans tak gör inte saker snabbare — det gör dem opålitliga.

Felsökning och bästa praxis

Ultrawork-nyckelordet utlöser inte

Om ulw eller ultrawork ignoreras, behandla det som ett signal för att kontrollera pluginladdning och versionkompatibilitet. Det har rapporterats minst en regression där nyckelordsdetektering inte injicerade den förväntade ultrawork-modellprompten, med undersökning som pekade på den dedikerade nyckelordsdetektor-hängeln.

I praktiken är de snabbaste fixerna:

  • bekräfta att pluginet är registrerat och konfigurationsfiler finns (se verifieringschecklistan tidigare)
  • uppgradera OpenCode eller pluginet om du är på en version känd för att regressera nyckelordsdetektering

Installationsskriptet kan inte hitta din OpenCode-konfiguration

Verifiera att OpenCode är installerad (opencode --version), sätt sedan en explicit konfigurationsvägens miljövariabel innan du kör installatören igen.

För många bakgrundsuppgifter eller throttling-problem

Om du träffar hastighetsgränser, timeout eller flakiga slutföranden, är fixen alltid densamma: minska konkurrensen och kör om. Att jaga högre parallellism när din leverantör redan throttlingar dig är en förlorad strid.

När du inte bör använda ultrawork

Ultrawork är kraftfull, men det är inte gratis — varje parallell agent kostar token och räknas mot dina hastighetsgränser. Reservera det för stora omstrukturerings, fullstack-funktionsarbete och komplexa flerstegsuppgifter. För en liten enfilsredigering eller en snabb fråga är en vanlig prompt snabbare och billigare.

En solid tumregel:

  • använd vanliga prompts för små redigeringar och raka frågor
  • använd ultrawork när du vill att systemet ska dekomponera, delegera, exekvera och verifiera över hela repositoriet

Efterlevnadsanteckning om leverantörsvillkor

Vissa communitydiskussioner kring detta ekosystem rör leverantörsbegränsningar och användarvillkor, särskilt kring tredjeparts OAuth och kompatibilitetsskikt. Dessa är verkliga begränsningar — granska din leverantörs villkor innan du kör automatiserade eller parallella flöden i stor skala, och anta inte att en fungerande integration innebär en tillåten sådan.

Redo att gå djupare? Djupdykningen i specialiserade agenter förklarar varje agents roll, modellkrav och självvärdshärdningsalternativ. För ärliga prestandadata och community-rapporterade faktureringsrisker, se Oh My Opencode-erfarenhetsartikeln.