# OpenCode: agent open source dla dowolnego modelu

URL: https://developertoolkit.ai/pl/comparison/opencode/
Description: OpenCode 1.19.0 w npm (2026-10-12), działanie sprawdzone na 1.18.32: instalacja, routing modeli hostowanych i open-weight oraz porównanie z Claude Code, Codex i Cursorem.

OpenCode to agent kodujący na licencji MIT (npm `opencode-ai` 1.19.0, 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.

**Sprawdzone 26 września i 12 października 2026**

  2026-09-26 strona została zweryfikowana w README `anomalyco/opencode` i w źródłach jego dokumentacji na GitHubie (`packages/web/src/content/docs/`: providers, config, agents, permissions, CLI, rules, skills, MCP, plugins, share, GitHub), w npm (`opencode-ai` 1.18.32), w katalogu models.dev na GitHubie i na stronie integracji Ollamy z OpenCode. Samej witryny opencode.ai nie pobieraliśmy; każde stwierdzenie o OpenCode poniżej pochodzi z tych źródeł. 2026-10-12 npm pokazywał `opencode-ai` 1.19.0 (opublikowany 2026-10-11), a odczytano też oficjalną tablicę Terminal-Bench 4.0, dokumentację Cursora, tabelę planów Copilota z GitHuba, licencje modeli open-weight i ogłoszenie Amp. Działania OpenCode nie uruchamiano ponownie na 1.19.0.

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, o ile wiersz nie mówi inaczej) |
| --- | --- |
| Aktywne repozytorium | [`anomalyco/opencode`](https://github.com/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.19.0 w npm, opublikowany 2026-10-11 (sprawdzone 2026-10-12); reszta tej strony była sprawdzana na 1.18.32, opublikowanej 2026-09-21 |
| 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](/pl/comparison/agent-landscape/). 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ć.

1. Zainstaluj CLI w terminalu:

   ```bash
   curl -fsSL https://opencode.ai/install | bash
   # or one of:
   npm i -g opencode-ai@latest
   brew install anomalyco/tap/opencode
   mise use -g opencode
   ```

2. 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`.

3. 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.

4. 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.

5. 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](https://github.com/anomalyco/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:

```jsonc title="opencode.json"
{
  "$schema": "https://opencode.ai/config.json",
  // Build and plan: your strongest model.
  "model": "anthropic/claude-opus-5-5",
  // Light internal tasks: a cheap, fast model.
  "small_model": "anthropic/claude-haiku-4-5",
  "agent": {
    // A reviewer from a different vendor catches what the author's model misses.
    "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" } }
    },
    // An open-weight model for bulk, low-risk work such as test scaffolding.
    "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. Dwa z nich nie są już aktualnym modelem: Claude Haiku 5.5 zastąpił Claude Haiku 4.5 jako aktualny Haiku 2026-10-07, a GPT-6.1 Sol (2026-09-29) zastąpił GPT-6 Sol jako podstawowy model OpenAI do codziennej pracy ([centrum modeli](/pl/ecosystem/models/)). Październikowa kontrola nie sprawdzała ich identyfikatorów w models.dev. 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](/pl/ecosystem/models/); 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.1 Sol u OpenAI, domyślny model w Codeksie), 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+ (dokumentacja OpenCode); GPT-6.1 Sol nie jest dostępny w Copilot Pro (dokumentacja GitHuba, sprawdzone 2026-10-12) | `/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** |

Inny zewnętrzny agent poszedł w przeciwną stronę: Amp ogłosił 2026-10-10, że „You can now use your Claude Pro/Max subscription in Amp”, przez tryb **Claude Code**, który „uses the Claude Agent SDK” (ampcode.com/news/use-your-claude-plan, własne oświadczenie Amp). To twierdzenie Amp o Amp. Nie zmienia ono wiersza OpenCode powyżej, który pochodzi z dokumentacji OpenCode z odczytu 2026-09-26.

## 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:

```json title="opencode.json"
{
  "$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 jego wagi mają własną licencję „GLM-5.3 License” (wagi GLM-5.3-Flash są na MIT), Kimi K3 ma własną licencję „Kimi K3 License”, która nie jest licencją open source w rozumieniu OSI, a Mistral Medium 3.5 korzysta ze zmodyfikowanej licencji MIT, która nie daje żadnych praw firmom o miesięcznym przychodzie powyżej 20 mln USD (pliki LICENSE na Hugging Face, odczyt 2026-10-12). 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](/pl/ecosystem/models/open-weight/).

**Co publiczne dane mówią o różnicy jakości.** GLM-5.3 to najwyżej oceniony wpis z otwartymi wagami na oficjalnej tablicy Terminal-Bench 4.0 (odczyt 2026-10-12): 41,8% ± 3,2 w harnessie Claude Code, przed GLM-5.3-Flash z wynikiem 35,8% ± 3,5; GPT-5.6 Sol w Codex ma 37,3% ± 3,8, a przedziały się nakładają, więc tablica nie rozdziela tych wyników (dane Harbor Hub, odczyt 2026-10-12). Na tej tablicy nie ma żadnego przebiegu OpenCode (stan na 2026-10-12), 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: komórki o modelach, pliku instrukcji, uprawnieniach i trybie headless sprawdzono 2026-10-12 (wpis „GitHub Actions” w komórce headless: 2026-10-13, na stronie CLI Cursora), pozostałe 28.08.2026; komórek oznaczonych „nie zweryfikowano” nie dało się ponownie sprawdzić 2026-10-12.

| 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` | Pula Cursor Models plus modele zewnętrzne po stawkach API, wśród nich GLM 5.3 i Kimi K3; serwery lokalne nie zweryfikowane |
| Plik instrukcji | `AGENTS.md`, zapasowo `CLAUDE.md` | `CLAUDE.md`; `AGENTS.md`, gdy brak `CLAUDE.md` (od v2.1.277) | `AGENTS.md` | Rules (reguły); czyta `AGENTS.md` i `CLAUDE.md` |
| 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` | Run modes (Auto-review, Allowlist, Run Everything), `.cursor/permissions.json` |
| 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 `agent -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 1.19.0 w dniu 2026-10-11), a jego dokumentacja używała w przykładach starszych identyfikatorów modeli przy sprawdzeniu 2026-09-26. 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**

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

    ```bash
    ollama launch claude
    # or manually:
    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**

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

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

    Zamiast tego `ollama launch codex` tworzy osobny profil.

**Cursor**

    Cursor wymienia hostowane modele open-weight, wśród nich GLM 5.3, GLM 5.3 Flash i Kimi K3, jako modele zewnętrzne rozliczane po stawkach API i oznaczone „Hidden by default” (cursor.com, sprawdzone 2026-10-12). Tego, czy Cursor potrafi użyć modelu serwowanego z twojego komputera, nie dało się zweryfikować 2026-10-12. Zanim zaplanujesz wokół tego 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`.

```jsonc title="opencode.json (team baseline)"
{
  "$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](/pl/ecosystem/mcp/) i [skille](/pl/ecosystem/skills/).

Szerszy model zatwierdzeń, sandboxów i ograniczeń sieci opisuje artykuł o [uprawnieniach i sandboxingu](/pl/workflows/harness/permissions-and-sandboxing/).

## Prompty do skopiowania dla OpenCode

**Prompt do skopiowania: przeniesienie konfiguracji Claude Code do OpenCode**

```text
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".
```

**Prompt do skopiowania: subagent review na drugim modelu**

```text
@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.
```

**Prompt do skopiowania: porównanie dwóch modeli na tym samym zamkniętym zgłoszeniu**

```text
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](/pl/comparison/agent-landscape/).

## 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.

1. **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.
2. **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.
3. **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.
4. **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](/pl/workflows/ship/evidence-bundle/). Bez identyfikatora modelu nie powiążesz regresji ze zmianą modelu.
5. **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:

```yaml title=".github/workflows/opencode.yml (job condition)"
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](/pl/ecosystem/agent-tools/headless-agents-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](/pl/ecosystem/agent-tools/gateways-local-models/) |
| 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ść](/pl/org/lock-in-and-portability/) |

## Dokąd dalej po OpenCode

- [Modele open-weight i hostowane samodzielnie](/pl/ecosystem/models/open-weight/) — 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ą](/pl/comparison/agent-landscape/) — Miejsce OpenCode obok Copilota, Gemini CLI, Kiro i innych oraz protokół porównawczy do ich oceny.
- [Centrum modeli](/pl/ecosystem/models/) — Aktualne nazwy modeli, ceny, okna kontekstu i ustawienia domyślne w jednym miejscu.
- [Bramki i modele lokalne](/pl/ecosystem/agent-tools/gateways-local-models/) — Ollama, LM Studio, llama.cpp, LiteLLM i routery dla dowolnego agenta, z pułapkami dotyczącymi kontekstu i danych.
