OpenCode: agent open source dla dowolnego modelu

OpenCode to agent kodujący na licencji MIT (npm opencode-ai 1.18.32, repozytorium anomalyco/opencode), który działa z niemal każdym modelem: z dostawcami hostowanymi z katalogu models.dev, z endpointami zgodnymi z OpenAI i z lokalnymi serwerami, takimi jak Ollama. Dorównuje Claude Code i Codex w agentach, uprawnieniach, MCP, skillach i trybie headless. Ceną za wybór modelu jest brak dostrojonej pary model–harness jednego dostawcy.

Dział bezpieczeństwa mówi, że kod jednego klienta nie może opuścić firmy, finanse pytają, po co płacicie za trzech agentów, a jeden z programistów chce porównać GLM-5.3 z modelem, którego już używacie. Claude Code i Codex da się skierować na lokalny serwer, ale każdy z nich jest zbudowany wokół modeli jednego dostawcy. OpenCode to harness zbudowany dla odwrotnego przypadku, a ta strona pokazuje, gdzie to pomaga i ile kosztuje.

Co dostajesz z tego przewodnika po OpenCode

Datowaną kartę faktów, pierwsze uruchomienie i jeden plik opencode.json, który kieruje każdy typ zadania do innego modelu.
Dwie zweryfikowane drogi do modeli open-weight, hostowaną i lokalną, wraz z ich pułapkami.
Tabele możliwości i decyzji w porównaniu z Claude Code, Codex i Cursorem.
Zabezpieczoną konfigurację zespołową, trzy prompty i pętlę weryfikacji, która nie wymaga czytania każdego diffa.

Czym jest OpenCode we wrześniu 2026?

OpenCode opisuje się jako „The open source AI coding agent” (opis repozytorium, odczyt 26.09.2026). Fakty, które warto znać przed instalacją:

Fakt	Wartość (stan na 26.09.2026)
Aktywne repozytorium	`anomalyco/opencode`, MIT, domyślna gałąź `dev`
To nie jest aktywne repozytorium	`opencode-ai/opencode`, pierwotny projekt w Go, jest zarchiwizowany. CLI Kilo Code to fork OpenCode (README Kilo)
Pakiet	`opencode-ai` 1.18.32 w npm, opublikowany 21.09.2026
Powierzchnie	Interfejs terminalowy (`opencode`), uruchomienia headless (`opencode run`), serwer (`opencode serve`) i interfejs webowy (`opencode web`), aplikacja desktopowa w wersji beta (macOS, Windows, Linux) oraz agent GitHuba (`opencode github`)
Wbudowani agenci	Główni: build (wszystkie narzędzia) i plan (edycje plików i bash ustawione na `ask`). Subagenci: general, explore i scout (dwaj ostatni tylko do odczytu)
Plik instrukcji	`AGENTS.md`; gdy go brak, `CLAUDE.md`
Punkty rozszerzeń	Serwery MCP, Agent Skills, własni agenci, wtyczki w JavaScripcie lub TypeScripcie z hookami zdarzeń, własne narzędzia, serwery LSP

Popularność, z datą. 210 085 gwiazdek na GitHubie (GitHub, anomalyco/opencode, 26.09.2026) — najwięcej gwiazdek spośród agentów spoza wielkiej trójki na stronie z przeglądem rynku. Gwiazdki mierzą uwagę, nie dopasowanie do twojego kodu.

Jak zainstalować OpenCode i uruchomić go w repozytorium?

README podaje ponad dziesięć instalatorów. Użyj jednego z czterech poniżej, a potem pracuj w repozytorium, które agent ma zmieniać.

Zainstaluj CLI w terminalu:

curl -fsSL https://opencode.ai/install | bash
# albo jedno z:
npm i -g opencode-ai@latest
brew install anomalyco/tap/opencode
mise use -g opencode

Uruchom opencode w katalogu głównym repozytorium, wpisz /connect i wybierz dostawcę. Poświadczenia trafiają do ~/.local/share/opencode/auth.json, poza repozytorium. To samo z powłoki robi opencode auth login.
Wpisz /models, żeby wybrać model. Z powłoki opencode models anthropic wyświetla modele jednego dostawcy w formacie provider/model, a opencode models --refresh przeładowuje katalog z models.dev.
Wpisz /init. Polecenie skanuje repozytorium, może zadać kilka pytań i tworzy lub aktualizuje AGENTS.md. Jeśli repozytorium ma już AGENTS.md dla Codex, OpenCode czyta go bez zmian.
Przed pierwszym zadaniem naciśnij Tab, żeby przełączyć się na agenta plan: agent proponuje zmiany i pyta, zanim zmieni plik lub uruchomi polecenie. Wróć do build, gdy zaakceptujesz plan.

Dwa ustawienia domyślne zaskakują osoby przychodzące z Claude Code. Po pierwsze, w agencie build większość uprawnień ma domyślnie wartość allow; tylko doom_loop i external_directory mają ask, a pliki .env są zablokowane dla read (dokumentacja uprawnień, 26.09.2026). Po drugie, OpenCode wczytuje też ~/.claude/CLAUDE.md jako globalny plik zapasowy. Ustaw OPENCODE_DISABLE_CLAUDE_CODE=1, jeśli twoje prywatne reguły z Claude Code nie powinny trafiać do sesji OpenCode.

Jak OpenCode wybiera modele i kieruje do nich pracę?

Każdy model ma adres provider/model, a identyfikatory pochodzą z katalogu models.dev, który utrzymuje także zespół OpenCode. Bez flagi --model OpenCode ustala model w tej kolejności: flaga -m, klucz model w konfiguracji, ostatnio używany model, a na końcu wewnętrzny priorytet. Nie ma jednego domyślnego modelu dostawcy, więc ustaw go jawnie.

Klucze działają na trzech poziomach: model dla agentów głównych, small_model dla lekkiej pracy wewnętrznej i model w definicji każdego agenta. To wystarczy, żeby rozdzielić pracę według zadania:

{
  "$schema": "https://opencode.ai/config.json",
  // Build i plan: najmocniejszy model.
  "model": "anthropic/claude-opus-5-5",
  // Lekkie zadania wewnętrzne: tani, szybki model.
  "small_model": "anthropic/claude-haiku-4-5",
  "agent": {
    // Recenzent od innego dostawcy wyłapuje to, co przeoczy model autora.
    "review": {
      "description": "Reviews the working-tree diff against AGENTS.md and the tests. Never edits.",
      "mode": "subagent",
      "model": "openai/gpt-6-sol",
      "permission": { "edit": "deny", "bash": { "*": "deny", "git diff*": "allow", "git status*": "allow", "npm test*": "allow", "npm run lint*": "allow" } }
    },
    // Model open-weight do masowej pracy o niskim ryzyku, np. szkieletów testów.
    "bulk": {
      "description": "Mechanical edits and test scaffolding on well-specified tasks.",
      "mode": "subagent",
      "model": "zai/glm-5.3"
    }
  }
}

Cztery identyfikatory powyżej istnieją w katalogu models.dev na 26.09.2026. Po podłączeniu dostawców uruchom opencode models, żeby potwierdzić dokładne identyfikatory dostępne na twoim koncie, bo przykłady w dokumentacji OpenCode wciąż pokazują starsze modele. Ceny i okna kontekstu wszystkich wymienionych modeli są w centrum modeli; ta strona ich nie powtarza.

Wybieraj modele według reguły, której trzyma się cały serwis, dopasowanej do harnessu bez własnego modelu domyślnego: zacznij od domyślnego modelu każdego dostawcy (Claude Opus 5.5 u Anthropic, GPT-6 Astra u OpenAI), najpierw dostrój poziom rozumowania (opencode run --variant przekazuje poziom właściwy dla dostawcy), a model zmieniaj dopiero wtedy, gdy każą ci to twoje własne ewaluacje.

To, jakie subskrypcje możesz podłączyć, wpływa na koszty:

Płacisz za	Działa w OpenCode?	Jak
ChatGPT Plus lub Pro	Tak, „with zero setup”	`/connect` → OpenAI → ChatGPT Plus/Pro
GitHub Copilot	Tak; niektóre modele wymagają Copilot Pro+	`/connect` → GitHub Copilot, logowanie kodem urządzenia
GitLab Duo	Tak, eksperymentalnie; wymaga GitLab Premium lub Ultimate z Duo Agent Platform	`/connect`
Claude Pro lub Max	Nie. „Anthropic explicitly prohibits this”; OpenCode od 1.3.0 nie dołącza wtyczek obchodzących ten zakaz	Użyj klucza API Anthropic
Dowolny klucz API	Tak, według dokumentacji ponad 75 dostawców	`/connect` → Manually enter API Key

Jak uruchomić modele open-weight w OpenCode?

Są dwie drogi i odpowiadają na różne pytania. Dostawca hostowany tanio odpowiada na pytanie „czy ten model wystarczy do naszej pracy?”. Lokalny serwer odpowiada na pytanie „czy da się go uruchomić tam, gdzie wolno nam trzymać kod?”.

Hostowane modele open-weight. Podłącz dostawcę i wybierz model. Dla GLM-5.3 w Z.AI wpisz /connect, wyszukaj Z.AI, zaznacz Z.AI Coding Plan, jeśli masz subskrypcję GLM Coding Plan, wklej klucz i wpisz /models. OpenRouter, DeepSeek, Together AI, Groq i Hugging Face to również pełnoprawni dostawcy. Zespół OpenCode oferuje dwie własne listy modeli: Zen („tested and verified to work well with OpenCode”) i Go („a low cost subscription plan” z „popular open coding models”). Obie są opcjonalne.

Modele hostowane samodzielnie. Każdy serwer zgodny z OpenAI działa przez adapter @ai-sdk/openai-compatible. Ollamę uruchamia jedno polecenie, ollama launch opencode, które stosuje konfigurację inline i nie nadpisuje twojej. Ręczny odpowiednik z przewodnika Ollamy dla OpenCode:

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

qwen3.5 to tag z przewodnika Ollamy; zastąp go tagiem, który pobrałeś. LM Studio używa w tym samym bloku http://127.0.0.1:1234/v1, a serwer llama.cpp (llama serve, wcześniej llama-server) domyślnie nasłuchuje na http://127.0.0.1:8080/v1.

O tym, czy lokalny model w ogóle zadziała, decydują trzy wymagania:

Kontekst co najmniej 64K tokenów. Strona Ollamy o OpenCode wymaga „a context length of 64k or higher”. Domyślny kontekst Ollamy zależy od VRAM i poniżej 24 GiB wynosi 4K, co po cichu obcina prompt systemowy agenta. Uruchom serwer poleceniem OLLAMA_CONTEXT_LENGTH=64000 ollama serve i sprawdź kolumnę CONTEXT w ollama ps.
Wywołania narzędzi. Bez nich agent jest bezużyteczny. Dokumentacja OpenCode: „If tool calls aren’t working, try increasing num_ctx in Ollama.”
Wyłącznie lokalne tagi. Tagi Ollamy kończące się na :cloud działają w chmurze Ollamy, więc kod opuszcza maszynę. Przypnij tagi lokalne, jeśli powodem wdrożenia jest rezydencja danych.

Zanim model trafi na produkcję, sprawdź licencję: kod w repozytorium GLM-5.3 jest na Apache-2.0, ale licencja wag jest na karcie modelu, Kimi K3 ma własną licencję, która nie jest licencją open source w rozumieniu OSI, a Mistral Medium 3.5 korzysta ze zmodyfikowanej licencji MIT (fakty na 26.09.2026). Pełne porównanie GLM, Qwen, Kimi, DeepSeek i modeli Mistral dla agentów kodujących znajdziesz w artykule o modelach open-weight i hostowanych samodzielnie.

Co publiczne dane mówią o różnicy jakości. GLM-5.3 to jedyny wpis z otwartymi wagami na oficjalnej tablicy Terminal-Bench 4.0: 41,8% ± 3,2 w harnessie Claude Code wobec 37,3% ± 3,8 dla GPT-5.6 Sol w Codex; przedziały się nakładają, więc tablica nie rozdziela tych wyników (zgłoszenia harbor-framework, sprawdzone 26.09.2026). Na tej tablicy nie ma żadnego przebiegu OpenCode (stan na 26.09.2026), więc wpływ harnessu OpenCode na wynik dowolnego modelu pozostaje niezmierzony. Rozstrzygnie to wyłącznie benchmark na twoich własnych zamkniętych zgłoszeniach.

Gdzie OpenCode dorównuje Claude Code, Codex i Cursorowi, a gdzie nie?

OpenCode pokrywa funkcje harnessu, na których zespół się standaryzuje. Różni się tym, kto odpowiada za model, środowisko chmurowe i wsparcie. Komórki Cursora pochodzą z jego dokumentacji sprawdzonej 28.08.2026; komórek oznaczonych „nie zweryfikowano” nie dało się ponownie sprawdzić 26.09.2026.

Możliwość	OpenCode 1.18.32	Claude Code 2.1.283	Codex 0.157.1	Cursor
Modele	Każdy dostawca z models.dev, każdy endpoint zgodny z OpenAI	Modele Anthropic; inne przez bramkę zgodną z API Anthropic	Modele OpenAI; lokalne przez `--oss`	Nie zweryfikowano
Plik instrukcji	`AGENTS.md`, zapasowo `CLAUDE.md`	`CLAUDE.md`; `AGENTS.md`, gdy brak `CLAUDE.md` (od v2.1.277, kanał `latest`)	`AGENTS.md`	Rules (reguły)
Planowanie tylko do odczytu	Agent plan (edycje i bash pytają)	Plan mode	`/plan`	Plan Mode
Subagenci	general, explore, scout, własni (`mode: subagent`)	Explore, Plan, general-purpose, własni	`/subagents`	Subagents
Reguły uprawnień	Per narzędzie, wzorce glob, wygrywa ostatnia pasująca reguła	Reguły allow i deny, tryby uprawnień	Tryby sandboxa, `.rules`	Nie zweryfikowano
Hooki	Zdarzenia wtyczek (`tool.execute.before`, `session.idle`, `file.edited`, …) w JS lub TS	33 zdarzenia hooków	12 zdarzeń hooków	Hooks (JSON przez stdio)
MCP i skille	Oba; czyta `.claude/skills/` i `.agents/skills/`	Oba	Oba	Oba
Headless i CI	`opencode run --format json`, `opencode serve`, agent GitHuba	`claude -p`, GitHub Action	`codex exec`, `codex review`	Tryb print CLI `-p`, GitHub Actions, Cloud Agents
Agent w chmurze dostawcy	Brak w dokumentacji sprawdzonej 26.09.2026; agent GitHuba działa na twoich runnerach Actions	Tak	Tak	Tak
Raport kosztów	`opencode stats`	`/usage`	`/usage`	Nie zweryfikowano

Z czego rezygnujesz, wybierając OpenCode:

Z dostrojonej pary. Każdy wpis Anthropic i OpenAI na oficjalnej tablicy Terminal-Bench 4.0 uruchamia model dostawcy w jego własnym harnessie. W OpenCode kombinacji modelu i harnessu, której używasz, nikt publicznie nie zmierzył.
Z bezpiecznych ustawień domyślnych. Agent build od razu pozwala na większość narzędzi. Zabezpieczenia piszesz sam.
Z jednego odpowiedzialnego dostawcy. Zły wynik może wynikać z modelu, z adaptera dostawcy albo z harnessu. Zarezerwuj czas na taką diagnozę.
Ze stabilności wydań. OpenCode wydaje nowe wersje często (1.18.32 opublikowano 21.09.2026), a jego dokumentacja wciąż używa w przykładach starszych identyfikatorów modeli. Przypnij wersję, którą zespół przetestował.

Jeśli przed decyzją chcesz sprawdzić ten sam model open-weight w agencie, którego już używasz, droga zależy od narzędzia:

Claude Code korzysta z Anthropic Messages API, które implementuje Ollama. Przewodnik Ollamy dla Claude Code:

ollama launch claude
# albo ręcznie:
export ANTHROPIC_AUTH_TOKEN=ollama
export ANTHROPIC_API_KEY=""
export ANTHROPIC_BASE_URL=http://localhost:11434
claude --model qwen3.5

Przy bazowym URL innym niż Anthropic nie działają Remote Control i /voice. Sprawdź w /status, że używana jest właściwa bramka.

Codex ma wbudowany przełącznik dla Ollamy i LM Studio (codex --help, 0.157.1):

codex --oss --local-provider ollama -m qwen3.5

Zamiast tego ollama launch codex tworzy osobny profil.

Obsługi modeli lokalnych lub open-weight w Cursorze nie dało się zweryfikować 26.09.2026. Zanim zaplanujesz wokół niej pracę, sprawdź dokumentację ustawień modeli Cursora albo przeprowadź porównanie w OpenCode, który korzysta z tego samego AGENTS.md i tych samych skilli w repozytorium.

Jak zabezpieczyć OpenCode dla zespołu?

Zacommituj do repozytorium jeden plik opencode.json, żeby każdy programista i każde uruchomienie w CI startowało z tymi samymi regułami. Konfiguracja projektu nadpisuje globalną konfigurację użytkownika klucz po kluczu, a organizacja może publikować ustawienia domyślne pod .well-known/opencode.

{
  "$schema": "https://opencode.ai/config.json",
  "share": "disabled",
  "autoupdate": false,
  "instructions": ["CONTRIBUTING.md"],
  "permission": {
    "edit": "ask",
    "external_directory": "deny",
    "bash": {
      "*": "ask",
      "git status*": "allow",
      "git diff*": "allow",
      "npm test*": "allow",
      "npm run lint*": "allow",
      "git push*": "deny",
      "rm *": "deny"
    }
  }
}

Reguły są dopasowywane wzorcem i wygrywa ostatnia pasująca reguła, więc ogólne "*" umieść na początku, a wyjątki po nim. share: "disabled" ma znaczenie, bo udostępniona sesja wysyła całą rozmowę na serwery OpenCode pod linkiem opncd.ai/s/<id>. autoupdate: false trzyma wszystkich na przetestowanej wersji; aktualizuj świadomie poleceniem opencode upgrade. Serwery MCP trafiają do klucza mcp w tym samym pliku, a dokumentacja ostrzega, że niektóre, na przykład serwer MCP GitHuba, „can easily exceed the context limit”. Włączaj tylko serwery potrzebne do zadania; zobacz serwery MCP i skille.

Szerszy model zatwierdzeń, sandboxów i ograniczeń sieci opisuje artykuł o uprawnieniach i sandboxingu.

Prompty do skopiowania dla OpenCode

Read CLAUDE.md, .claude/settings.json, .claude/agents/ and .mcp.json in this repository.
Produce two files and nothing else:
1. AGENTS.md: the project rules from CLAUDE.md, rewritten tool-neutrally (no Claude-specific
   commands or slash commands). Keep every build, test and lint command exactly as written.
2. opencode.json: MCP servers from .mcp.json under "mcp" (type "local" with a command array,
   or type "remote" with a url; secrets as {env:VAR}, never literal values), and a "permission"
   block that mirrors the allow and deny rules in .claude/settings.json. Put "*": "ask" first in
   each pattern map, because the last matching rule wins. Set "share": "disabled".
Then list every Claude Code feature you could not map (hooks, output styles, plugins) with the
OpenCode equivalent if one exists, or "none".

@review Review the uncommitted changes in this repository (git diff HEAD). You may not edit files.
1. Run the test and lint commands listed in AGENTS.md and report pass or fail for each.
2. For each changed function, name the test that exercises it, or write "UNTESTED".
3. Flag any change that touches authentication, payments, migrations or public API signatures.
4. Flag any new dependency and check that it exists in the lockfile.
Answer as a table: file, finding, severity (block / fix before merge / note), evidence.
End with one line: MERGEABLE or NOT MERGEABLE, and the reason.

You are reproducing a fix that was already merged, to compare models fairly.
Task: <paste the text of closed issue #NNN here, without the linked pull request>.
Rules: change only the files needed; run the full test suite before you finish; do not edit
or delete existing tests. When done, print: files changed, tests added, the final test
command and its exit code, and anything you were unsure about.

Uruchom go w trybie headless raz dla każdego modelu, za każdym razem w świeżym checkoucie commita sprzed poprawki: opencode run -m anthropic/claude-opus-5-5 --format json "$(cat task.txt)" > opus.jsonl, a potem z -m zai/glm-5.3. Oceń oba przebiegi według protokołu porównawczego.

Jak weryfikować wyniki OpenCode bez czytania każdej linijki?

Swoboda wyboru modelu dodaje zmienną, więc pętla weryfikacji musi być mocniejsza niż w narzędziu jednego dostawcy, a nie słabsza.

Deterministyczne bramki decydują o merge’u. Testy, sprawdzanie typów i lint działają w CI przy każdej zmianie, niezależnie od modelu, który ją napisał. Zapewnienie agenta, że testy przechodzą, nie jest dowodem; dowodem jest log z CI.
Recenzent na innym modelu. Subagent review z konfiguracji powyżej działa na modelu innego dostawcy, z zablokowanymi edycjami i większością poleceń powłoki. Ryzykiem, gdy ten sam model pisze i recenzuje, są wspólne martwe pola.
Ewaluacja modelu, zanim dostanie nowe zadanie. Przepuść 10–20 własnych zamkniętych zgłoszeń przez każdy kandydujący model, używając trzeciego promptu, i oceń je protokołem ze strony o przeglądzie rynku. Awansuj model (na przykład do agenta bulk) wyłącznie na podstawie tych dowodów i powtarzaj zestaw przy każdej zmianie modelu lub wersji OpenCode.
Pakiet dowodów przy każdym pull requeście. Zapisz w pull requeście identyfikator modelu, wersję OpenCode, wyniki testów i werdykt recenzenta, tak jak opisuje to pakiet dowodów. Bez identyfikatora modelu nie powiążesz regresji ze zmianą modelu.
Widoczny koszt. opencode stats --models raportuje zużycie tokenów i koszt dla każdego modelu (filtry --days i --project), więc tani model, który potrzebuje trzech podejść, okaże się drogi.

Za routing modeli do agentów w opencode.json odpowiada tech lead, a zmiany w nim przechodzą review jak kod. O merge’u decydują bramki w CI, a nie lektura recenzenta.

Do uruchomień wywoływanych komentarzami opencode github install konfiguruje workflow GitHub Actions, który reaguje na /opencode lub /oc w komentarzach do zgłoszeń i pull requestów. Agent działa tylko dla komentujących z uprawnieniem write lub admin (assertPermissions w github/index.ts repozytorium anomalyco/opencode, sprawdzone w 1.18.32), ale przy pull requeście pobiera jego gałąź, także z forków, i wczytuje z niej opencode.json, wtyczki i AGENTS.md, gdy twój klucz API jest w środowisku. Dlatego nie wywołuj go na pull requestach z forków i przejrzyj każdą zmianę w opencode.json lub .opencode/, zanim napiszesz /oc. Dodatkowo, jako druga linia obrony, dodaj do warunku zadania sprawdzenie autora i zachowaj persist-credentials: false z wygenerowanego pliku:

if: |
  (contains(github.event.comment.body, '/oc') || contains(github.event.comment.body, '/opencode')) &&
  contains(fromJSON('["OWNER","MEMBER","COLLABORATOR"]'), github.event.comment.author_association)

Obsługę sekretów w różnych agentach opisuje artykuł o agentach headless w CI.

Co się psuje, gdy zespół wdraża OpenCode?

Na lokalnym modelu wywołania narzędzi zawodzą albo agent ignoruje instrukcje. Zwykle winny jest domyślny kontekst Ollamy zależny od VRAM, wynoszący 4K, który obcina prompt systemowy. Naprawa: uruchom serwer ponownie z OLLAMA_CONTEXT_LENGTH=64000, sprawdź ollama ps, a jeśli wywołania narzędzi nadal nie działają, zmień model na taki, którego karta deklaruje tool calling.

Kod opuszcza maszynę w konfiguracji „air-gapped”. Tag modelu kończący się na :cloud, udostępniona sesja albo hostowany small_model wysyłają dane na zewnątrz, choć główny model jest lokalny. Naprawa: przypnij lokalne tagi, ustaw share: "disabled", skieruj small_model również na lokalnego dostawcę i ogranicz dostawców kluczem enabled_providers.

Agent build uruchamia destrukcyjne polecenie, którego nikt nie zatwierdził. Większość uprawnień ma domyślnie allow. Naprawa: zacommituj bazę zespołu z tej strony, a to, co zostało uruchomione, sprawdź w git reflog i w eksporcie sesji (opencode export --sanitize).

Uruchomienie headless w CI zawiesza się albo robi za dużo. Dokumentacja (sprawdzona 26.09.2026, wersja 1.18.32) nie mówi, co opencode run robi z regułą ask, gdy nie ma człowieka, a --auto zatwierdza wszystko, czego jawnie nie zablokowano. Naprawa: w CI zapisz jawne reguły allow i deny dla każdego narzędzia potrzebnego w zadaniu, używaj --auto tylko w jednorazowym sandboxie z ograniczoną siecią i nigdy na runnerze z sekretami produkcyjnymi.

Przestaje działać logowanie Claude Pro lub Max. Powód wyjaśnia tabela subskrypcji powyżej. Naprawa: użyj klucza API Anthropic albo podłącz ChatGPT Plus lub Pro czy GitHub Copilot.

Przykład konfiguracji kończy się błędem „model not found”. Przykłady w dokumentacji OpenCode używają starszych identyfikatorów, a katalog się zmienia. Naprawa: uruchom opencode models --refresh, a potem skopiuj identyfikator z opencode models <provider>.

Prywatne reguły z Claude Code pojawiają się w sesjach OpenCode. OpenCode czyta ~/.claude/CLAUDE.md i ~/.claude/skills/ jako pliki zapasowe. Naprawa: ustaw OPENCODE_DISABLE_CLAUDE_CODE=1 albo przenieś wspólne reguły do AGENTS.md.

Model open-weight dobrze wypadł na demo, a zawodzi w prawdziwej pracy. Jedna efektowna sesja to nie ewaluacja. Naprawa: przeprowadź porównanie na zamkniętych zgłoszeniach z tej strony na co najmniej 10 zgłoszeniach i trzymaj model przy agentach niskiego ryzyka, dopóki na twoich bramkach nie dorówna obecnemu domyślnemu modelowi.

Kiedy wybrać OpenCode?

Twoja sytuacja	Rekomendacja
Kod nie może opuścić twojej sieci albo umowa z klientem wyklucza harness dostawcy	OpenCode z lokalnym serwerem, po ewaluacji każdego modelu; zobacz bramki i modele lokalne
Płacisz już za ChatGPT Plus lub Pro albo GitHub Copilot i chcesz jednego agenta terminalowego dla wielu modeli	OpenCode z podłączoną subskrypcją; obecnego agenta zachowaj do porównań
Chcesz kierować tanią, dobrze wyspecyfikowaną pracę do modelu open-weight	Pole `model` per agent w OpenCode, awans modelu tylko na podstawie ewaluacji
Twój zespół ma stanowiska Claude Pro lub Max	Zostań przy Claude Code; OpenCode wymaga osobnego rozliczenia API dla modeli Anthropic
Chcesz agentów w chmurze zarządzanych przez dostawcę i jednej umowy wsparcia	Zostań przy Claude Code, Codex lub Cursorze
Chcesz uniknąć vendor lock-in niezależnie od wybranego agenta	Trzymaj reguły w `AGENTS.md` (czytają go OpenCode i Codex, a Claude Code, gdy brak `CLAUDE.md`), a procedury jako Agent Skills; zobacz lock-in i przenośność

Dokąd dalej po OpenCode

Modele open-weight i hostowane samodzielnie GLM, Qwen, Kimi, DeepSeek i modele Mistral do pracy w izolacji, gdy liczy się najniższy koszt lub gdy wymagają tego reguły dotyczące danych, oraz jak zmierzyć różnicę na własnych ewaluacjach.

Rynek agentów kodujących poza wielką trójką Miejsce OpenCode obok Copilota, Gemini CLI, Kiro i innych oraz protokół porównawczy do ich oceny.

Centrum modeli Aktualne nazwy modeli, ceny, okna kontekstu i ustawienia domyślne w jednym miejscu.

Bramki i modele lokalne Ollama, LM Studio, llama.cpp, LiteLLM i routery dla dowolnego agenta, z pułapkami dotyczącymi kontekstu i danych.

Najczęstsze pytania

Czym jest OpenCode?

OpenCode to agent kodujący na licencji MIT, działający w terminalu, z trybem headless, serwerem i aplikacją desktopową w wersji beta. Aktywny projekt to anomalyco/opencode (npm opencode-ai 1.18.32 na 26 września 2026); starsze repozytorium Go opencode-ai/opencode jest zarchiwizowane.

Z jakich modeli może korzystać OpenCode?

Z każdego dostawcy z katalogu models.dev (Anthropic, OpenAI, GitHub Copilot, Amazon Bedrock, OpenRouter, Z.AI, DeepSeek i inni), z dowolnego endpointu zgodnego z OpenAI oraz z lokalnych serwerów, takich jak Ollama, LM Studio i llama.cpp. Modele adresuje się jako provider/model.

Czy mogę używać subskrypcji Claude Pro lub Max w OpenCode?

Nie. Dokumentacja dostawców OpenCode mówi, że Anthropic wprost tego zabrania, a OpenCode od wersji 1.3.0 nie dołącza wtyczek, które to umożliwiały. Użyj klucza API Anthropic. Subskrypcje ChatGPT Plus lub Pro i GitHub Copilot działają; obsługa GitLab Duo jest eksperymentalna i wymaga planu GitLab Premium lub Ultimate z Duo Agent Platform.

Czy zespół powinien zastąpić Claude Code lub Codex OpenCode?

Tylko wtedy, gdy wymaganiem jest wybór modelu: modele hostowane samodzielnie lub open-weight, jeden harness dla kilku dostawców albo reguła dotycząca danych, która wyklucza harness dostawcy. W pozostałych przypadkach agent dostawcy, dostrojony do jego modeli, niesie mniejsze ryzyko.