# GitHub Copilot jako agent kodujący: cloud agent, aplikacja, CLI i rozliczenia

URL: https://developertoolkit.ai/pl/comparison/github-copilot/
Description: Cloud agent, aplikacja i CLI GitHub Copilot: skille, hooki, MCP, rozliczenia w AI Credits od 1 czerwca 2026, agenci Claude i Codex oraz polityki organizacji.

GitHub Copilot to pełna platforma agentów kodujących, nie samo autouzupełnianie: cloud agent, który w GitHub Actions bada kod, planuje, wprowadza zmiany na gałęzi i otwiera pull request, desktopowa aplikacja i CLI Copilota do pracy lokalnej, Agent Skills, hooki i MCP oraz zewnętrzni agenci Claude i Codex. Od 1 czerwca 2026 agenci i czat zużywają GitHub AI Credits.

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

  Zweryfikowane 2026-09-26 w źródłach dokumentacji GitHuba (`github/docs`, gałąź main) i na lokalnej instalacji Copilot CLI **1.0.88** (`copilot --help`). 2026-10-12 wiersze o modelach, planach, wycofaniach, wersji i nowych funkcjach sprawdzono ponownie w `github/docs`, w changelogu GitHuba i w rejestrze npm (`@github/copilot` **1.0.96**); tabela flag CLI nie była czytana ponownie i zostaje przy 1.0.88. Agenci zewnętrzni, `gh skill`, limity AI Credits na sesję i computer use są w public preview, HydraFusion jest w research preview, a wszystko to często się zmienia. Ceny modeli znajdziesz w [hubie modeli](/pl/ecosystem/models/); ta strona linkuje tam, zamiast je powtarzać.

Twoja firma już płaci za Copilot Business. Jeden developer chce Claude Code, tech lead chce przypisywać agentowi zgłoszenia z backlogu, a dział finansów pyta, czemu czerwcowa faktura wygląda inaczej. Zanim kupisz kolejną licencję, musisz wiedzieć, co dziś potrafią agenci Copilota, ile kosztuje jedno zadanie i jakie ustawienia trzeba włączyć, zanim trafi do was pierwszy pull request od agenta.

## Co zyskujesz z tego przewodnika po GitHub Copilot

- Mapę pięciu trybów pracy agentów Copilota i zadań, do których każdy pasuje.
- Działający `copilot-setup-steps.yml`, hook `preToolUse` i trzy prompty do wklejenia dla cloud agenta i CLI.
- Wyjaśnienie rozliczeń w AI Credits, ustawień, które ograniczają koszt sesji, i tego, co cloud agent kosztuje poza kredytami.
- Checklistę administratora dla Copilot Business i Enterprise oraz luki w politykach, które łatwo przeoczyć.
- Tabelę decyzyjną: kiedy Copilot wystarcza, a kiedy dołożyć [Claude Code, Codex albo Cursor](/pl/comparison/vs-github-copilot/).

Badanie JetBrains z sierpnia 2026 (źródło wtórne, fragmenty z wyszukiwarki) umieszcza Copilota wśród najczęściej używanych w pracy narzędzi AI do kodowania, za Claude Code. Dla wielu zespołów to pierwszy agent; pytanie brzmi, jak daleko z nim zajdziesz.

## Który tryb pracy GitHub Copilot do jakiego zadania?

Pięć trybów pracy łączy jedno konto, jedna pula AI Credits i w większości te same pliki konfiguracyjne. Różni je miejsce, w którym działa agent, i to, kto go pilnuje.

| Tryb pracy | Gdzie działa agent | Jak go uruchamiasz | Do czego pasuje |
| --- | --- | --- | --- |
| **Copilot cloud agent** | Ulotne środowisko GitHub Actions | Przypisanie zgłoszenia do Copilota, zakładka **Agents**, `@copilot` w pull requeście, Slack lub Teams, albo automation | Dobrze opisane zgłoszenia z backlogu, luki w testach, zależności i dokumentacja |
| **Aplikacja GitHub Copilot** | Twój komputer (macOS, Linux, Windows), osobny git worktree i gałąź na sesję; sandbox w chmurze lub lokalny | Wybierasz zgłoszenie albo pusty workspace i tryb Interactive, Plan lub Autopilot | Kilka równoległych zadań, którymi sterujesz i które przeglądasz z jednego okna |
| **Copilot CLI** (`@github/copilot` 1.0.96) | Twój terminal albo tryb bez interfejsu z `-p` | `copilot`, `copilot --plan`, `copilot -p "…"` | Praca w terminalu i zadania skryptowe w CI |
| **Tryb agenta w VS Code i JetBrains** | Twój edytor, na lokalnych plikach | Wybór agenta w widoku czatu | Interaktywne zmiany, gdy chcesz widzieć każdą edycję |
| **Agenci zewnętrzni** (public preview) | To samo środowisko na GitHubie co cloud agent | Przypisanie zgłoszenia agentowi Claude lub Codex albo wzmianka w pull requeście | Porównanie agentów na tym samym zgłoszeniu bez osobnych subskrypcji |

Strona planów GitHuba mówi wprost: „All plans include Copilot CLI and GitHub Copilot app”. Cloud agent wymaga płatnego planu: w Pro, Pro+ i Max jest domyślnie włączony, w Business i Enterprise domyślnie wyłączony, dopóki nie włączy go administrator.

## Jak przekazać zgłoszenie cloud agentowi Copilota?

Cloud agent pracuje najlepiej, gdy środowisko jest deterministyczne, a „gotowe” jest zapisane. Wykonaj kroki w tej kolejności; każdy usuwa błąd, na który trafiłby następny.

1. **Włącz agenta.** W Business lub Enterprise właściciel organizacji włącza politykę cloud agenta (zobacz checklistę administratora niżej). Właściciele repozytoriów mogą wyłączyć pojedyncze repozytoria.

2. **Daj mu instrukcje, które przeczyta.** Cloud agent czyta `.github/copilot-instructions.md`, instrukcje dla ścieżek `.github/instructions/**/*.instructions.md`, instrukcje organizacji oraz pliki agentowe: `AGENTS.md`, `CLAUDE.md` lub `GEMINI.md`. Jeśli repozytorium ma już `AGENTS.md` dla Codexa albo `CLAUDE.md` dla Claude Code, cloud agent z nich korzysta; trzymaj tam polecenia budowania, testów i „definicję ukończenia”. Zobacz [jak przygotować kod pod agentów](/pl/workflows/harness/agent-ready-codebase/).

3. **Zainstaluj toolchain z góry w `copilot-setup-steps.yml`.** Bez tego agent odkrywa zależności metodą prób i błędów, co jest wolne i zawodzi przy prywatnych paczkach. Plik musi leżeć w `.github/workflows/copilot-setup-steps.yml`, zawierać jeden job o nazwie `copilot-setup-steps` i być na domyślnej gałęzi, zanim zacznie działać:

   ```yaml title=".github/workflows/copilot-setup-steps.yml"
   name: "Copilot Setup Steps"
   on:
     workflow_dispatch:
     push:
       paths:
         - .github/workflows/copilot-setup-steps.yml
   jobs:
     copilot-setup-steps:          # the job name is mandatory
       runs-on: ubuntu-latest
       timeout-minutes: 40         # hard ceiling is 59
       permissions:
         contents: read            # Copilot gets its own token for its work
       steps:
         - uses: actions/checkout@v7
           with:
             persist-credentials: false   # Copilot uses its own token; do not leave the job token in .git/config
         - uses: actions/setup-node@v7
           with:
             node-version-file: .node-version
             cache: npm
         - run: npm ci
         - run: npx playwright install --with-deps chromium
   ```

   Uwzględniane są tylko `steps`, `permissions`, `runs-on`, `services`, `snapshot` i `timeout-minutes`; pozostałe ustawienia joba są ignorowane. Uruchom workflow raz z zakładki **Actions**, żeby sprawdzić, że przechodzi.

   Dane dostępowe do prywatnego rejestru pakietów trafiają do **Settings → Secrets and variables → Agents**, na poziomie repozytorium albo organizacji. Sekrety trzymane wcześniej w środowisku Actions `copilot` zostały tam przeniesione automatycznie, a agent nie widzi sekretów Actions, Codespaces ani Dependabota. Sekrety Agents trafiają do kroków konfiguracji i do samego agenta jako zmienne środowiskowe, więc przechowuj w nich tylko tokeny tylko do odczytu, o wąskim zakresie. Jedynie nazwy z prefiksem `COPILOT_MCP_` są ukryte przed agentem i trafiają wyłącznie do serwerów MCP.

4. **Napisz zgłoszenie jak specyfikację.** W treści zgłoszenia umieść kryteria akceptacji, pliki w zakresie i polecenie, które potwierdza wykonanie pracy. Prompt poniżej pokazuje działający kształt. Dyscyplinę, która za tym stoi, opisuje strona o [kryteriach akceptacji, które agent potrafi sprawdzić](/pl/workflows/plan/acceptance-criteria/).

5. **Przypisz zgłoszenie do Copilota** albo poproś go w zakładce **Agents**, żeby najpierw zbadał kod i przygotował plan, a potem iterował przed otwarciem pull requesta. Planowanie przed pull requestem działa tylko na github.com (i w preview w Slacku i Teams); integracje takie jak Jira, Linear i Azure Boards od razu otwierają pull request.

6. **Przeglądaj i iteruj komentarzami `@copilot`** w pull requeście. Wzmiankuj `@copilot` z opisem zmiany, a agent dopisze nowe commity do tego samego pull requesta.

**Prompt do wklejenia: treść zgłoszenia, którą cloud agent domknie**

```text
Add rate limiting to POST /api/auth/login.

Acceptance criteria:
- More than 5 failed attempts per email within 15 minutes returns HTTP 429
  with a Retry-After header; the 6th attempt must not reach the password check.
- A successful login resets the counter for that email.
- Limits are stored in the existing Redis client in src/lib/redis.ts; do not add a new dependency.

Scope: src/routes/auth/login.ts, src/lib/rate-limit.ts (new), tests/auth/login.rate-limit.test.ts (new).
Out of scope: signup, password reset, any UI change.

Done means:
- npm test -- tests/auth passes, including new tests for the 429 path, the reset path,
  and the Retry-After value.
- npm run lint and npm run typecheck pass.
- The pull request description lists each acceptance criterion with the test name that proves it.
Stop when these pass. Do not refactor unrelated code.
```

Cloud agent ma cztery twarde ograniczenia, które wyznaczają sposób dzielenia pracy (stan na 2026-09-26): jedno repozytorium na zadanie, jedna gałąź i najwyżej jeden pull request na zadanie, maksymalny czas sesji 59 minut bez możliwości wydłużenia oraz wyłącznie repozytoria hostowane na GitHubie. Jeśli zgłoszenie nie zmieści się w godzinie, podziel je według kryteriów akceptacji przed przypisaniem.

## Jak uruchomić agentów Claude i Codex wewnątrz Copilota?

GitHub uruchamia dwóch agentów zewnętrznych, Anthropic Claude (zbudowanego na Claude Agent SDK) i OpenAI Codex, w public preview. Mają te same punkty wejścia co cloud agent, te same zabezpieczenia i ograniczenia oraz korzystają z twoich AI Credits i minut Actions w Copilot. Przepływ pracy jest identyczny; różni się tylko tym, kto pisze kod i jakie modele możesz wybrać.

**Copilot cloud agent**

    Przypisz zgłoszenie do **Copilota** albo wzmiankuj `@copilot` w pull requeście. Ma pełną listę modeli Copilota dla twojego planu (w Pro+, Max, Business i Enterprise obejmuje ona Claude Opus 5.5, GPT-6.1 Sol, GPT-6 Astra i GPT-6 Sol), a także własnych agentów (custom agents), hooki, skille i ustawienia MCP repozytorium. Po 2026-09-26 doszły trzy modele (github/docs, sprawdzone 2026-10-12): Claude Sonnet 5.5 (2026-09-28) i Claude Haiku 5.5 (2026-10-07), oba we wszystkich pięciu płatnych planach, oraz GPT-6.1 Sol (2026-09-29) w Pro+, Max, Business i Enterprise, ale nie w Pro. Wybieraj tego agenta domyślnie: ma najwięcej opcji konfiguracji.

**Anthropic Claude**

    Włącz **Allow Claude coding agent**; to instaluje GitHub App o nazwie `anthropic code agent`, a jego działania trafiają do audit logu. Potem przypisz zgłoszenie agentowi Claude albo wzmiankuj go w pull requeście. Na 2026-09-26 dokumentacja GitHuba wymieniała dla tego agenta **Auto**, Claude Opus 4.7 i Claude Sonnet 4.6. Claude Opus 4.7 zniknął z Copilota 2026-10-02, changelog GitHuba wskazuje Claude Opus 5.5 jako jego następcę, a tabela w dokumentacji mówi teraz tylko „Latest Claude Opus model” (sprawdzone 2026-10-12). Aktualną listę modeli tego agenta przeczytaj w dokumentacji GitHuba, zanim na niej polegasz. Żeby puścić Claude Opus 5.5 na zgłoszenie, użyj cloud agenta Copilota z tym modelem albo uruchom [Claude Code w CI](/pl/claude-code/ship/ci-cd-integration/).

**OpenAI Codex**

    Włącz **Allow Codex coding agent**; to instaluje GitHub App o nazwie `openai code agent`. Na 2026-09-26 dokumentacja GitHuba wymienia dla tego agenta **Auto**, GPT-5.3-Codex, GPT-5.4 i GPT-5.4 nano, podczas gdy sam Codex domyślnie używa GPT-6.1 Sol (od CLI 0.159.1, 2026-09-29). Jeśli chcesz aktualnych modeli OpenAI na zgłoszeniu, wybierz GPT-6.1 Sol (niedostępny w Pro) albo GPT-6 Astra w cloud agencie Copilota albo użyj [własnej GitHub Action Codexa](/pl/codex/ship/ci-cd/). GPT-6 Sol, który katalog samego Codexa opisuje jako „Previous generation workhorse model”, też jest na tej liście.

**Auto** u agentów zewnętrznych wybiera jeden z modeli danego agenta; to nie jest automatyczny wybór modelu Copilota i nie daje jego 10% rabatu. Traktuj agentów w preview jako sposób na porównanie harnessów na tym samym zgłoszeniu. Jeśli zespół standaryzuje się na Claude Code albo Codexie, uruchamiaj je natywnie, gdzie działają ich własne domyślne modele, hooki i narzędzia do review; [porównanie bezpośrednie](/pl/comparison/vs-github-copilot/) zestawia obie drogi.

## Praca lokalna z Copilot CLI i aplikacją Copilot

Zainstaluj CLI jedną z udokumentowanych metod (npm wymaga Node.js; minimalną wersję znajdziesz na stronie instalacji):

```bash title="Terminal"
npm install -g @github/copilot          # all platforms
brew install --cask copilot-cli         # macOS and Linux
winget install GitHub.Copilot           # Windows
copilot --version                       # GitHub Copilot CLI 1.0.88 on 2026-09-26; @github/copilot was 1.0.96 on npm on 2026-10-12
```

Flagi, które mają znaczenie przy pracy agentowej, wszystkie obecne w `copilot --help` 1.0.88:

| Flaga lub polecenie | Co robi |
| --- | --- |
| `--plan`, `--mode plan\|interactive\|autopilot`, `--autopilot` | Start w trybie planowania albo w pełni autonomicznym; w sesji tryby przełącza Shift+Tab |
| `--max-autopilot-continues <count>` | Limit automatycznych kontynuacji w Autopilot (domyślnie 5) |
| `--max-ai-credits <credits>`, `/limits set max-ai-credits N` | Miękki limit AI Credits na sesję (minimum 30; public preview według poradnika GitHuba „Set an AI Credit limit”) |
| `--allow-tool`, `--deny-tool`, `--allow-all-tools` | Uprawnienia narzędzi; reguła deny zawsze wygrywa, nawet z `--allow-all-tools` |
| `--allow-all` / `--yolo` | Zezwala na wszystkie narzędzia, ścieżki i URL-e; tylko w jednorazowym sandboksie z ograniczoną siecią |
| `/sandbox enable` | Sandbox na poziomie systemu dla poleceń powłoki. W 1.0.88 był eksperymentalny: uruchom z `--experimental` albo najpierw wykonaj `/settings experimental on`; Linux wymaga `bwrap`. Lokalny sandboxing stał się ogólnie dostępny 2026-10-07 (zobacz niżej) |
| `-p`, `-s`, `--output-format json`, `--usage-output-file` | Uruchomienia bez interfejsu dla skryptów i CI, z wyjściem JSONL i raportem zużycia |
| `--model`, `--reasoning-effort` | Model i poziom rozumowania (od `none` do `max`) dla sesji |
| `--fleet` | Uruchamia prompt z równoległą orkiestracją subagentów |
| `copilot app` | Otwiera aplikację GitHub Copilot |

Trzy zmiany pojawiły się po wyniku `--help` 1.0.88 powyżej (changelog GitHuba, sprawdzone 2026-10-12). Od CLI 1.0.94-0 `/model` wykrywa też modele z działającej lokalnej instancji Ollama; modele muszą obsługiwać tool calling i streaming, a to nie jest tryb offline (`COPILOT_OFFLINE=true` to osobne ustawienie). Computer use jest w public preview od 2026-10-01 w CLI i w aplikacji Copilot na macOS i Windows, a włącza się go przez `/computer on`. Dynamic workflows, zapowiedziane 2026-10-01 dla CLI, aplikacji i Copilot SDK, pozwalają definiować orkiestrację w kodzie.

Aplikacja GitHub Copilot jest zbudowana na CLI. Każda sesja dostaje własny git worktree i gałąź, działa w sandboksie w chmurze lub lokalnym i używa jednego z trzech trybów: **Interactive**, **Plan** (zatwierdzasz plan) albo **Autopilot**. GitHub radzi planować w trybie Plan, sterować w Interactive i przechodzić na Autopilot dopiero przy dobrze zdefiniowanym zadaniu. Aplikacja uruchamia też zaplanowane **Automations** i czyta te same instrukcje, serwery MCP i skille co CLI.

Lokalny sandboxing stał się ogólnie dostępny 2026-10-07 w CLI, w aplikacji i w sesjach VS Code Agent Host. Działa na Microsoft eXecution Container (MXC), a enterprise może go egzekwować politykami. 2026-09-30 GitHub dodał też HydraFusion, w research preview, do VS Code (1.140 i nowsze) i do aplikacji, po CLI: pozycję w wyborze modelu, która „orchestrates multiple models” przez przepływy Single, Cascade lub Critique (changelog GitHuba, sprawdzone 2026-10-12).

**Prompt do wklejenia: ograniczone kosztowo uruchomienie Copilot CLI w CI**

```text
Read the failing job log in ci-output.txt. Find the root cause of the failing test,
fix the code (not the test) unless the test contradicts the acceptance criteria in
docs/specs/billing.md, and run npm test -- tests/billing until it passes.
Write a summary to fix-report.md with: root cause, files changed, and the exact
test command and its final output. Do not push, do not open a pull request.
```

Zapisz powyższy prompt jako `.github/prompts/fix-ci.txt`. Uwierzytelniaj się wbudowanym tokenem joba, który GitHub zaleca dla automatyzacji w repozytoriach organizacji: jest krótkotrwały i ograniczony do jednego uruchomienia, więc nie przechowujesz żadnego długowiecznego poświadczenia. Nadaj workflowowi `permissions: contents: read` i `copilot-requests: write`, a w `env` kroku przekaż `GITHUB_TOKEN: ${{ github.token }}`. W repozytorium organizacji zużycie jest rozliczane na organizację, a właściciel musi włączyć politykę **Allow use of Copilot CLI billed to the organization**; wymaga to aktualnej wersji CLI. Fine-grained personal access token wyłącznie z uprawnieniem **Copilot Requests**, zapisany jako sekret repozytorium i przekazany jako `COPILOT_GITHUB_TOKEN`, traktuj jako wyjście awaryjne tam, gdzie wbudowany token nie jest dostępny. Klasyczny token `ghp_` nie jest obsługiwany. Potem uruchom prompt z katalogu głównego repozytorium w jobie CI:

```bash
# env: GITHUB_TOKEN: ${{ github.token }}; workflow permissions: contents: read, copilot-requests: write
copilot -p "$(cat .github/prompts/fix-ci.txt)" \
  --allow-tool='shell(npm:*)' --allow-tool=write --no-ask-user \
  --disable-builtin-mcps --secret-env-vars=GITHUB_TOKEN \
  --max-ai-credits 150 --output-format json --usage-output-file copilot-usage.json
```

Uruchomienie z `-p` nie może wyświetlić prośby o zgodę, więc każde narzędzie spoza listy dozwolonych, łącznie z `git push`, zostaje odrzucone. `--disable-builtin-mcps` wyłącza wbudowany serwer MCP GitHuba, więc agent nie otworzy przez niego pull requesta. `--secret-env-vars` usuwa token ze środowiska powłoki agenta i maskuje go w wyjściu. Mimo to zakładaj, że agent może token odczytać: mając `write` i `npm`, może zmienić `package.json` i uruchomić dowolny kod. Nie używaj tu `--allow-all-tools`. Uruchamiaj job tylko na ulotnym runnerze, bez uprawnień poza `contents: read` i `copilot-requests: write`, z `persist-credentials: false`, i nigdy dla pull requesta z forka ani innego niezaufanego refa, gdzie token (albo awaryjny PAT z sekretu) spotkałby kod atakującego. W większości automatyzacji GitHub zaleca zamiast surowych kroków `copilot -p` GitHub Agentic Workflows, które dodają własne zabezpieczenia.

## Rozszerzanie Copilota: skille, hooki i MCP

Większość plików jest wspólna z innymi agentami, co ma znaczenie, jeśli zespół używa więcej niż jednego narzędzia.

**Agent Skills.** Copilot stosuje otwarty standard Agent Skills w cloud agencie, code review, CLI, aplikacji i trybach agenta w IDE. Skille projektowe ładuje z `.github/skills`, `.claude/skills` lub `.agents/skills`, a osobiste z `~/.copilot/skills` lub `~/.agents/skills`. Skill napisany dla Claude Code w `.claude/skills` działa więc w Copilocie bez zmian. Wspólne skille instalujesz przez GitHub CLI (`gh` 2.90.0 lub nowszy; `gh skill` jest w preview). Przeczytaj skill przed instalacją, bo GitHub skilli nie weryfikuje:

```bash title="Terminal"
gh skill search "release notes"
gh skill preview github/awesome-copilot documentation-writer   # renders SKILL.md, installs nothing
gh skill install github/awesome-copilot documentation-writer --pin v1.2.0
```

**Hooki.** Hooki uruchamiają polecenia powłoki przy zdarzeniach sesji, promptu i narzędzi w cloud agencie i CLI. Hooki repozytorium leżą w `.github/hooks/*.json`; CLI czyta też osobiste hooki z `~/.copilot/hooks/`. Hook `preToolUse` może odmówić wywołania narzędzia, więc to jedyne miejsce na regułę, której agent nie obejdzie argumentacją:

```json title=".github/hooks/guard.json"
{
  "version": 1,
  "hooks": {
    "preToolUse": [
      { "type": "command", "bash": "./.github/hooks/deny-risky.sh", "timeoutSec": 5 }
    ]
  }
}
```

```bash title=".github/hooks/deny-risky.sh"
#!/usr/bin/env bash
payload="$(cat)"
if printf '%s' "$payload" | grep -Eq 'git push --force|rm -rf /|DROP TABLE|terraform apply'; then
  echo '{"permissionDecision":"deny","permissionDecisionReason":"Blocked by repository policy in .github/hooks/deny-risky.sh"}'
fi
```

Awaria albo niezerowy kod wyjścia hooka `preToolUse` typu command blokuje wywołanie, ale **przekroczenie czasu je przepuszcza**. Utrzymuj skrypt szybkim i ustaw `timeoutSec` wyraźnie powyżej jego realnego czasu działania. W cloud agencie decyzja `ask` liczy się jako `deny`, bo nie ma kto odpowiedzieć.

**MCP.** Cloud agent startuje z dwoma włączonymi serwerami MCP: GitHuba, z tokenem tylko do odczytu bieżącego repozytorium, oraz Playwright, ograniczonym do `localhost`. Administratorzy repozytorium dodają kolejne w ustawieniach Copilota w repozytorium jako JSON i te serwery obowiązują zarówno cloud agenta, jak i Copilot code review. Agent używa skonfigurowanych narzędzi bez pytania, więc w `tools` wpisz tylko te, których potrzebuje. Lokalnie CLI czyta `~/.copilot/mcp-config.json` oraz `.mcp.json` lub `.github/mcp.json` w workspace i domyślnie ma serwer MCP GitHuba:

```bash title="Terminal"
copilot mcp add playwright -- npx @playwright/mcp@latest
copilot mcp list
```

## Jak działają rozliczenia Copilota w AI Credits?

Od 1 czerwca 2026 Copilot rozlicza **model i tokeny**, a nie zapytania. Tokeny wejściowe, wyjściowe i z cache każdej interakcji są wyceniane według stawki wybranego modelu i przeliczane na GitHub AI Credits po kursie **1 kredyt = 0,01 USD**. Premium requests i mnożniki modeli przetrwały tylko w starszych rocznych planach Pro i Pro+, do ich wygaśnięcia.

| Plan | Cena | Kredyty bazowe miesięcznie | Pula flex ponad to |
| --- | --- | --- | --- |
| Free · Student | 0 USD | mniejsza pula, tylko automatyczny wybór modelu (Free: 2000 podpowiedzi kodu miesięcznie) | — |
| Pro | 10 USD/mies. | 1000 | +500 |
| Pro+ | 39 USD/mies. | 3900 | +3100 |
| Max | 100 USD/mies. | 10 000 | +10 000 |
| Business | 19 USD/użytkownik/mies. | 1900 na użytkownika | nie podano dla planu |
| Enterprise | 39 USD/użytkownik/mies. | 3900 na użytkownika | nie podano dla planu |

Kredyty bazowe odpowiadają cenie subskrypcji. GitHub opisuje flex jako „a variable part of your included usage”, więc budżetuj wyłącznie na kredytach bazowych. Pula odnawia się o 00:00 UTC pierwszego dnia miesiąca i nie przechodzi na kolejny. Podpowiedzi kodu i next edit suggestions nie zużywają kredytów w płatnych planach. Cloud agent i agenci zewnętrzni **zużywają też minuty GitHub Actions**, o czym zespoły zapominają. Ceny planów i pule kredytów w tabeli sprawdzono ponownie w `github/docs` 2026-10-12 i nie zmieniły się.

Od 2026-10-08 właściciel organizacji może rozliczać Copilot code review dla licencjonowanych członków na organizację, a nie z uprawnienia samego członka. Ustawienie to **Member** (domyślne) albo **Organization**, a enterprise może wybrać **Let organizations decide** (changelog GitHuba, sprawdzone 2026-10-12).

Żeby oszacować jedno zadanie, pomnóż jego tokeny przez stawki za milion tokenów z tabeli modeli Copilota w GitHubie, a wynik w dolarach pomnóż przez 100, żeby dostać kredyty. Posty GitHuba o premierach mówią, że każdy nowy model „is billed at provider list pricing under usage-based billing”, a [hub modeli](/pl/ecosystem/models/) podaje ceny dostawców. Cztery dźwignie obniżają koszt bez utraty jakości, wszystkie z zaleceń samego GitHuba:

- **Wybierz model na zadanie i trzymaj się go.** Zmiana modelu, poziomu rozumowania, rozmiaru kontekstu albo zestawu narzędzi MCP w trakcie sesji unieważnia cache, a cały kontekst jest rozliczany ponownie jako świeże wejście.
- **Ustaw automatyczny wybór modelu jako domyślny.** Płatne plany dostają z nim 10% rabatu na koszt modeli w czacie, CLI, aplikacji i cloud agencie. 2026-10-05 GitHub dodał GPT-6.1 Sol i Claude Sonnet 5.5 do modeli, spośród których wybiera Auto, usunął GPT-5.4 i GPT-5.5, a Gemini 3.7 Flash zastąpił Gemini 3.8 Flash (github/docs, sprawdzone 2026-10-12).
- **Ograniczaj sesje.** Używaj `--max-ai-credits` w CLI, a na sumę miesięczną budżetów na użytkownika lub centrum kosztów (projekt budżetów opisuje strona o [zarządzaniu kosztami](/pl/org/cost-governance/)).
- **Planuj mocnym modelem, implementuj tańszym.** Subagentów uruchamiaj na lżejszych modelach; nie dziedziczą głównej rozmowy, więc lżejszy model nie psuje jej cache.

## Ustaw polityki organizacji przed pierwszym pull requestem agenta

Skopiuj tę checklistę do zgłoszenia wdrożeniowego.

**Checklista administratora dla Copilot Business i Enterprise**

- [ ] **Polityka cloud agenta**: domyślnie wyłączona w Business i Enterprise; włącz na poziomie organizacji albo enterprise, jeśli to enterprise nią zarządza.
- [ ] **Wyłączenia repozytoriów**: wyklucz repozytoria z danymi regulowanymi albo bez testów.
- [ ] **Automations**: domyślnie włączone tam, gdzie działa cloud agent; może je tworzyć każdy z prawem zapisu. Zdecyduj, czy to akceptujesz.
- [ ] **Agenci zewnętrzni** (Claude, Codex): osobne polityki; włączenie instaluje odpowiednią GitHub App.
- [ ] **Polityka aplikacji GitHub Copilot**: domyślnie włączona i niezależna od polityki Copilot CLI.
- [ ] **Lokalny sandboxing**: ogólnie dostępny od 2026-10-07, z politykami, które enterprise może egzekwować; zdecyduj, czy egzekwować go w sesjach CLI i aplikacji.
- [ ] **Rozliczanie code review**: od 2026-10-08 wybierz, czy Copilot code review obciąża uprawnienie członka (domyślnie), czy organizację.
- [ ] **Content exclusion**: aplikacja i CLI respektują wykluczenia na poziomie enterprise, organizacji i repozytorium; sprawdź, czy obejmują sekrety i dane klientów.
- [ ] **Polityka MCP**: CLI nie egzekwuje polityki „MCP servers in Copilot” ani polityki adresu MCP Registry (Copilot CLI 1.0.88, według about-copilot-cli, sprawdzone 2026-09-26). Strona GitHuba dla administratorów enterprise mówi, że polityki allowlisty MCP obowiązują, więc przetestuj politykę na instalacji CLI, zanim na niej polegasz; do tego czasu lokalne MCP ogranicz inaczej, na przykład hookiem `preToolUse`.
- [ ] **Runner i firewall**: ustaw domyślny typ runnera dla cloud agenta i przejrzyj listę dozwolonych adresów firewalla.
- [ ] **Rulesety**: reguły ograniczające autorów commitów blokują agenta; dodaj Copilota jako bypass actor tylko tam, gdzie to bezpieczne.
- [ ] **Budżety**: ustaw limity wydatków przed zamknięciem pierwszego miesiąca, nie po nim.

Wersję tej polityki dla wielu dostawców (managed settings Claude Code, `requirements.toml` Codexa, Cursor i Copilot na jednej stronie) znajdziesz na stronie o [jednej polityce dla wszystkich agentów kodujących](/pl/org/managed-policy/).

## Jak sprawdzić to, co wytwarzają agenci Copilota?

Pull request od agenta to twierdzenie, a nie wynik. Spraw, żeby dało się je sprawdzić, zanim człowiek przeczyta diff.

- **Agent uruchamia twoje bramki.** `copilot-setup-steps.yml` instaluje toolchain, więc agent odpala testy, lint i sprawdzanie typów w swojej sesji, a na jego pull requeście działają zwykłe wymagane status checks. Workflowy Actions na pull requeście agenta czekają, aż zatwierdzi je osoba z prawem zapisu; zatwierdź uruchomienie, zanim ocenisz checki, a sekrety potrzebne w setupie umieść w Settings → Secrets and variables → Agents. Traktuj czerwony check tak samo jak u człowieka.
- **GitHub skanuje kod agentów.** Dla cloud agenta i agentów zewnętrznych GitHub dokumentuje automatyczną walidację bezpieczeństwa przed finalizacją pull requesta: CodeQL code scanning, secret scanning i sprawdzenie nowych zależności w GitHub Advisory Database, bez licencji GitHub Advanced Security.
- **Copilot code review można wywołać z automatyzacji.** Od 2026-10-02 review Copilota zamówisz przez API REST i GraphQL z poziomem wysiłku. Domyślnym poziomem od 2026-09-28 jest **Balanced**, a Lite jest respektowany, gdy ustawisz go jawnie (changelog GitHuba, sprawdzone 2026-10-12).
- **Hooki egzekwują to, czego nie wyegzekwuje prompt.** Deny w `preToolUse` jest deterministyczny; instrukcja w `AGENTS.md` to prośba.
- **Pull request niesie dowody.** Poproś agenta o przypisanie każdego kryterium akceptacji do testu i wklejenie wyniku polecenia. To [pakiet dowodów](/pl/workflows/ship/evidence-bundle/), który recenzenci sprawdzają zamiast czytać każdą linię.
- **Podpisuje konkretny człowiek.** Według dokumentacji GitHuba agent po skończeniu prosi cię o review; kto może zmergować, decydują branch protection i CODEOWNERS. Decyzja o merge'u zostaje u inżyniera, który odpowiada za kryteria akceptacji.
- **Mierz wyniki, nie aktywność.** API metryk użycia Copilota raportuje utworzone i zmergowane pull requesty, liczbę zmergowanych pull requestów cloud agenta i medianę czasu do merge'a. Śledź odsetek merge'ów i poprawek na agenta obok [metryk dostarczania](/pl/org/metrics-frameworks/).

**Prompt do wklejenia: komentarz @copilot, który zamienia pull request w dowód**

```text
@copilot Before I review: update the pull request description with a table that maps
each acceptance criterion in the linked issue to the test that proves it (file and test
name). Run the full test suite, lint and typecheck, and paste the exact commands and
their final output lines. List every file you changed that is outside the scope listed
in the issue and explain why, or revert those changes. Do not change behaviour in this pass.
```

## Co psuje się w agentach Copilota i jak z tego wyjść?

- **Agent nie startuje albo nie może pushować.** Ruleset ograniczający autorów commitów blokuje cloud agenta. Sprawdź log sesji, a potem dodaj Copilota jako bypass actor w tym rulesecie albo złagodź regułę dla gałęzi agenta.
- **Kroki setupu padają po cichu.** Gdy krok setupu zwróci niezerowy kod, Copilot pomija resztę i startuje w niedokończonym środowisku, a potem spala kredyty na ponowne instalacje. Uruchom workflow ręcznie z zakładki **Actions**, popraw go do zielonego i trzymaj na domyślnej gałęzi.
- **Kredyty kończą się w połowie miesiąca.** W planie indywidualnym możesz przejść na wyższy plan (płacisz tylko różnicę), ustawić budżet na dodatkowe zużycie albo poczekać na odnowienie pierwszego dnia miesiąca; w Business i Enterprise dźwignią jest budżet. Dodawaj `--max-ai-credits` do każdego skryptowego uruchomienia i sprawdzaj `/usage` w sesjach.
- **Model znika.** Claude Opus 4.7, Kimi K2.7 Code, Gemini 3.5 Flash i Gemini 3.6 Flash zniknęły z Copilota 2026-10-02 (github/docs, sprawdzone 2026-10-12). Changelog GitHuba wskazuje w zamian Claude Opus 5.5, Kimi K3 i Gemini 3.8 Flash, a tabela w dokumentacji mówi teraz tylko „Latest Claude Opus model”, „Latest Kimi model” i „Latest Gemini Flash model”. Tabela wycofań nie wymienia kolejnego wycofania. Claude Sonnet 4.6 wycofano 2026-09-01, ale „remains available to individual Copilot subscribers on annual plans”. Automations i skrypty przypięte do wycofanego modelu potrzebują nowego `--model`; zanim przypniesz model, sprawdź [hub modeli](/pl/ecosystem/models/).
- **Hook z przekroczonym czasem przepuszcza zablokowane polecenie.** Zobacz uwagę o timeoutach w sekcji o [hookach](#rozszerzanie-copilota-skille-hooki-i-mcp).
- **Zainstalowany skill zawiera prompt injection.** Przed każdą instalacją uruchom `gh skill preview` i przypinaj wersje przez `--pin`.
- **`--allow-all-tools` albo `--yolo` na stacji roboczej.** Agent ma wtedy pełny dostęp do twoich plików i powłoki. Uruchamiaj takie sesje wyłącznie w jednorazowym sandboksie lub kontenerze z ograniczoną siecią, bez poświadczeń poza tokenem o wąskim zakresie. Zobacz [uprawnienia i sandboksy](/pl/workflows/harness/permissions-and-sandboxing/).

## Kiedy Copilot wystarcza, a kiedy dołożyć Claude Code albo Codex?

| Twoja sytuacja | Rekomendacja |
| --- | --- |
| Kod jest na GitHubie, praca przychodzi jako zgłoszenia i chcesz pull requestów z backlogu | Zacznij od cloud agenta Copilota; już za niego płacisz |
| Inżynierowie chcą agenta w terminalu z rozbudowanym ekosystemem hooków, subagentów i pluginów | Dołóż [Claude Code](/pl/claude-code/) tym inżynierom, a Copilota zostaw do pracy ze zgłoszeń |
| Potrzebujesz aktualnego domyślnego modelu OpenAI w jego własnym harnessie albo zadań w chmurze uruchamianych z wielu miejsc pracy | Dołóż [Codex](/pl/codex/); 2026-09-26 agent Codex wewnątrz Copilota wymieniał starsze modele |
| Kod nie jest na GitHubie | Cloud agent odpada; porównaj [innych agentów kodujących](/pl/comparison/agent-landscape/) |
| Musisz mieć jeden rachunek i jedną konsolę administracyjną | Zostań na Copilocie i korzystaj z jego wyboru modeli, w tym Claude Opus 5.5, GPT-6.1 Sol i GPT-6 Astra w planach Pro+, Max, Business i Enterprise (nie w Pro) oraz Claude Sonnet 5.5 i Claude Haiku 5.5 we wszystkich pięciu płatnych planach |

## Co dalej z GitHub Copilot

- [Cursor, Claude Code i Codex kontra GitHub Copilot](/pl/comparison/vs-github-copilot/): porównanie bezpośrednie.
- [Claude Code albo Codex obok Copilota](/pl/teams/adopt/from-copilot/): ścieżka migracji zespołu.
- [Od zgłoszenia do pull requesta bez rąk na klawiaturze](/pl/workflows/automate/issue-to-pr-pipeline/): pipeline dla wielu narzędzi, do którego pasują kroki cloud agenta z tej strony.
- [Agenci w tle i w chmurze: porównanie](/pl/workflows/automate/background-agents/): cloud agent Copilota obok Claude Code w przeglądarce, Codex cloud i Cursor Cloud Agents.
- [Serwer MCP GitHuba](/pl/ecosystem/mcp/github-mcp/): serwer, który Copilot ma domyślnie, dla pozostałych agentów.
- [Rynek agentów kodujących poza wielką trójką](/pl/comparison/agent-landscape/): miejsce Copilota obok Gemini CLI, Kiro, OpenCode i reszty.
