# Jedna polityka dla wszystkich agentów kodujących

URL: https://developertoolkit.ai/pl/org/managed-policy/
Description: Ustawienia zarządzane w Claude Code, Codeksie, Cursorze i GitHub Copilot: jedna wersjonowana polityka dla modeli, serwerów MCP, pluginów i uprawnień.

Zarządzana polityka agentów to jeden zestaw reguł organizacji (logowanie, modele, uprawnienia, serwery MCP, pluginy, hooki, wersje) spisany raz i przełożony na plik egzekwujący każdego narzędzia: `managed-settings.json` w Claude Code i GitHub Copilot, `requirements.toml` w Codeksie oraz ustawienia administracyjne w Cursorze. Programista nie może nadpisać kontroli, które te pliki egzekwują; kontrole, których narzędzie nie potrafi wyrazić (wymienione niżej), wymagają kontroli zastępczej.

Dział bezpieczeństwa zatwierdził Claude Code w marcu, z listą dozwolonych serwerów MCP. Od tego czasu zespół platformowy przeszedł na Codeksa, frontend pracuje w Cursorze, a Copilot włączył swoich agentów Claude i Codex. Cztery narzędzia czytają cztery pliki konfiguracyjne i nikt nie wie, które serwery MCP dopuszcza dziś konkretny laptop.

Ta strona jest dla CTO, który odpowiada za politykę agentów, i dla tech leada, który ją wdraża. To krok 11 ścieżki CTO. Poprzedza go strona o [tożsamości, poświadczeniach i sekretach agentów](/pl/org/agent-identity-and-secrets/), której reguły deny i zakresy MCP stają się tutaj ustawieniami zarządzanymi. Kolejny krok to [zespół platformowy agentów](/pl/org/platform-team/), który prowadzi tę politykę jak produkt.

## Co daje jedna zarządzana polityka dla wielu dostawców

- Bazę dziesięciu kontroli zapisaną jako intencja, a nie jako klucze jednego dostawcy.
- Jak Claude Code, Codex, Cursor i GitHub Copilot dostarczają i weryfikują politykę zarządzaną oraz jak kontrolować agentów chmurowych.
- Pliki polityki sprawdzone 2026-09-26 w Claude Code 2.1.283, Codeksie 0.157.1 i w dokumentacji Copilota od GitHuba.
- Repozytorium polityki, test parytetu list MCP w CI, wdrożenie kanarkowe, weryfikację i typowe awarie.

## Co powinna mówić polityka, zanim dotkniesz konfiguracji?

Najpierw zapisz intencję, w jednym pliku podpisanym przez szefa bezpieczeństwa. Klucze dostawców zmieniają się z wydania na wydanie, intencja tylko wtedy, gdy zmienia się twój apetyt na ryzyko. Ta baza jest umiarkowana: blokuje drogi, którymi agent na laptopie wynosi dane albo omija review, a codzienne pytania o uprawnienia zostawia zespołom, jak opisuje strona o [uprawnieniach i sandboksach dla agentów](/pl/workflows/harness/permissions-and-sandboxing/).

| # | Kontrola | Reguła bazowa | Dlaczego to poziom organizacji, a nie zespołu |
| --- | --- | --- | --- |
| 1 | Logowanie | Agenci logują się wyłącznie kontem firmowym, w organizacji firmy | Konto prywatne omija warunki danych i audyt |
| 2 | Modele | Tylko modele objęte twoją umową; domyślny ustalany centralnie | Inny model to naruszenie zasad przetwarzania danych |
| 3 | Minimalny poziom uprawnień | Tryby bypass i „allow all” są wyłączone na maszynach programistów | Jedna flaga wyłącza wszystkie pozostałe kontrole |
| 4 | Odczyt sekretów | Agent nie czyta `.env*` ani `secrets/**` | [Model zagrożeń](/pl/org/agent-threat-model/) wymaga sekretów poza kontekstem |
| 5 | Serwery MCP | Tylko zatwierdzone serwery, dopasowane po URL lub dokładnym poleceniu | Niezweryfikowany serwer to cudzy kod z twoimi tokenami |
| 6 | Pluginy i marketplace'y | Tylko oficjalny marketplace i wasz własny | Jeden plugin to hooki, serwery MCP i skille |
| 7 | Reguły poleceń | Polecenia destrukcyjne, np. force-push, są zakazane | Tanie do egzekwowania, drogie do odkręcenia |
| 8 | Minimalna wersja | Klient starszy niż zatwierdzona wersja nie startuje | Poprawki bezpieczeństwa i nowe klucze polityki przychodzą w nowych wersjach |
| 9 | Telemetria | Zdarzenia użycia trafiają do waszego kolektora | Audyt i raporty kosztów potrzebują jednego źródła danych |
| 10 | Agenci chmurowi | PR-y agentów przechodzą te same wymagane kontrole co PR-y ludzi | Ich polityka żyje na hostingu Git |

Kontrole 3 i 4 są obowiązkowe dla każdego narzędzia. Kontrole 5 i 6 rozjeżdżają się najczęściej, bo każde narzędzie konfiguruje MCP i pluginy po swojemu. Weryfikację serwerów opisuje strona o [rejestrach i bramkach MCP](/pl/ecosystem/mcp/registry-and-gateways/).

## Jak każde narzędzie egzekwuje politykę zarządzaną?

Claude Code i GitHub Copilot mówią w dużej mierze tym samym dialektem `managed-settings.json`: `permissions.deny`, `disableBypassPermissionsMode`, `strictKnownMarketplaces` i `allowedMcpServers`. Codex używa osobnego pliku ograniczeń w TOML.

| | Claude Code (2.1.283) | Codex (0.157.1) | Cursor | GitHub Copilot |
| --- | --- | --- | --- | --- |
| Plik polityki | `managed-settings.json` (plus `managed-settings.d/*.json`, `managed-mcp.json`) | `requirements.toml` | Panel administracyjny | `managed-settings.json` w `.github-private/copilot/` |
| Dostarczanie | Konsola administracyjna claude.ai (ustawienia zarządzane z serwera, server-managed), MDM (domena preferencji zarządzanych `com.anthropic.claudecode` na macOS, `HKLM\SOFTWARE\Policies\ClaudeCode` na Windowsie, wg [dokumentacji ustawień zarządzanych Anthropic](https://code.claude.com/docs/en/managed-settings)) lub plik systemowy | Warstwa dostarczana z workspace'u, MDM na macOS lub `/etc/codex/requirements.toml` | Istnieją źródła ustawień `team` i `mdm` (`@cursor/sdk` 1.0.32) | Zarządzane z serwera z `.github-private`, MDM lub plik systemowy (MDM tylko macOS i Windows) |
| Ścieżka pliku (Linux) | `/etc/claude-code/managed-settings.json` | `/etc/codex/requirements.toml` | — | `/etc/github-copilot/managed-settings.json` |
| Kilka źródeł | Domyślnie wygrywa pierwsze źródło z kluczem polityki; `managedSourcesBehavior: "merge"` je łączy | Źródła się składają; `/debug-config` pokazuje, które ustawiło dane ograniczenie | — | MDM > zarządzane z serwera > plik > użytkownik, per klucz; `permissions.deny`/`ask`/`allow` i `sandbox` składają się najbardziej restrykcyjnie; `allowedMcpServers` to część wspólna |
| Logowanie | `forceLoginMethod`, `forceLoginOrgUUID` | `allowed_login_methods` + `allowed_chatgpt_workspaces` | SSO (potwierdź) | `forceLoginOrgs` (MDM lub plik systemowy) |
| Modele | `availableModels` + `enforceAvailableModels`; `deniedModels` (od v2.1.283) | Przypięcie `model_provider`; `[models.new_thread]` ustawia domyślny | Zgłaszane: listy dozwolonych i blokowanych modeli w Routerze; Privacy Mode wymaga zgody na modele z retencją (potwierdź) | AI Controls: włącz, wyłącz lub deleguj każdy model; klucz `model` ustawia tylko domyślny |
| Minimalny poziom uprawnień | `permissions.disableBypassPermissionsMode`, `permissions.disableAutoMode` | `allowed_approval_policies`, `allowed_sandbox_modes` | Zgłaszane: uprawnienia agentów per grupa (potwierdź) | `permissions.disableBypassPermissionsMode` |
| Telemetria | `env` ze zmiennymi `OTEL_*` | Brak klucza w wymaganiach; `[otel]` w rozsyłanym `config.toml` albo MDM | Niezweryfikowane | `telemetry` (CLI, VS Code, JetBrains) |
| Lista dozwolonych MCP | `allowedMcpServers` + `allowManagedMcpServersOnly` | `[mcp_servers.<name>.identity]` | Niezweryfikowane | `allowedMcpServers` / `deniedMcpServers` |
| Pluginy i hooki | `strictKnownMarketplaces`, `blockedMarketplaces`; `allowManagedHooksOnly` | `[marketplaces]` z `restrict_to_allowed_sources`; `allow_managed_hooks_only` | Zgłaszane: marketplace zespołu z pluginami **Default On** lub **Required** (potwierdź) | `strictKnownMarketplaces`, `enabledPlugins`; hooki bez klucza zarządzanego |
| Polityka per grupa | Osobne pliki albo Claude apps gateway per grupa z IdP | Jedna warstwa workspace'u; osobne pliki per grupa urządzeń | Zgłaszane: Organizations › Teams › Groups (potwierdź) | Nadpisania zespołowe przez `overridable` i `team-mappings.json` |
| Sprawdzenie na maszynie | `/status` → `Setting sources`; `claude doctor` | `/debug-config` w TUI | Panel administracyjny | Walidator na karcie **Agents** w **AI Controls** |

**Cursora nie dało się zweryfikować 2026-09-26**

cursor.com był niedostępny podczas sprawdzania tej strony. Pakiet npm `@cursor/sdk` 1.0.32 wymienia źródła ustawień `team` i `mdm`, więc warstwa zespołowa i warstwa MDM istnieją. Komórki „Zgłaszane” pochodzą z fragmentów dokumentacji i changelogu Cursora (źródło wtórne, 2026-09-26); każdą potwierdź w dokumentacji enterprise Cursora, zanim trafi do polityki.

## Napisz plik polityki dla każdego narzędzia

Każda zakładka zawiera jeden plik realizujący każdą kontrolę, którą dane narzędzie potrafi wyrazić; luki są wymienione pod plikiem. Lista MCP jest wszędzie ta sama: zdalne serwery GitHuba i Sentry oraz lokalny Playwright. Przypnij wersję, którą zweryfikowałeś; `@latest` zatwierdza wszystko, co wyjdzie w następnym wydaniu. Podmień UUID organizacji, repozytorium marketplace'u i adres kolektora na własne.

**Claude Code**

Wdróż go przez konsolę administracyjną claude.ai, MDM albo ścieżkę systemową: `/Library/Application Support/ClaudeCode/` na macOS, `/etc/claude-code/` na Linuksie i WSL oraz `C:\Program Files\ClaudeCode\` na Windowsie.

```json
{
  "forceLoginMethod": "claudeai",
  "forceLoginOrgUUID": ["00000000-0000-0000-0000-000000000000"],
  "availableModels": ["opus", "sonnet"],
  "enforceAvailableModels": true,
  "permissions": {
    "deny": ["Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)"],
    "disableBypassPermissionsMode": "disable"
  },
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://mcp.sentry.dev/*" },
    { "serverCommand": ["npx", "@playwright/mcp@0.0.83"] }
  ],
  "allowManagedMcpServersOnly": true,
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "anthropics/claude-plugins-official" },
    { "source": "github", "repo": "acme/agent-plugins" }
  ],
  "disableSideloadFlags": true,
  "requiredMinimumVersion": "2.1.274",
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "grpc",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "https://otel.acme.internal:4317"
  }
}
```

Co robią mniej oczywiste klucze:

- Samo `availableModels` zostawia opcję **Default** na domyślnym modelu konta; `enforceAvailableModels` podporządkowuje liście także Default. Klucz `model` to tylko wybór początkowy.
- `allowManagedMcpServersOnly` nie pozwala użytkownikom poszerzyć listy. Gdy istnieje choć jeden wpis `serverUrl`, każdy zdalny serwer musi pasować do wzorca URL. Wpis `serverName` nigdy nie jest kontrolą bezpieczeństwa, bo nazwę wybiera użytkownik.
- `disableSideloadFlags` odrzuca przy starcie `--plugin-dir`, `--plugin-url`, `--agents` i `--mcp-config` (od v2.1.193), więc runnery CI, które przekazują `--mcp-config`, potrzebują własnego pliku polityki.
- `OTEL_EXPORTER_OTLP_PROTOCOL` jest obowiązkowy: Claude Code nie ma domyślnego protokołu OTLP, więc bez niego nic nie jest eksportowane, a kontrola 9 zawodzi bez żadnego błędu. Port `4317` to gRPC; dla punktu końcowego na `4318` użyj `http/protobuf`.
- `requiredMinimumVersion` to `2.1.274`, kanał `stable` z 2026-09-26. Blokuje starsze binaria tylko przy starcie.
- Stały zestaw MCP, którego użytkownik nie rozszerzy, wdrażasz jako `managed-mcp.json` przez MDM albo ścieżkę systemową; konsola go nie dostarczy.

Wariant ostrzejszy dodaje `allowManagedPermissionRulesOnly` i `allowManagedHooksOnly`. Oba wyłączają reguły i hooki projektu, których zespoły używają jako bramek jakości, więc zostaw je dla danych regulowanych.

**Codex**

Codex czyta ograniczenia administratora z `requirements.toml`, osobnego od domyślnych ustawień w `config.toml`, które edytuje użytkownik. Na Linuksie plik systemowy to `/etc/codex/requirements.toml`. Codex przyjmuje też warstwę enterprise dostarczaną z workspace'u oraz preferencje zarządzane MDM na macOS i składa je razem.

```toml
# /etc/codex/requirements.toml  (agent-policy v1.4)
allowed_login_methods = ["chatgpt"]
allowed_chatgpt_workspaces = ["CHATGPT_WORKSPACE_ID"]
allowed_approval_policies = ["on-request", "untrusted"]
allowed_sandbox_modes = ["read-only", "workspace-write"]

[mcp_servers.github.identity]
url = "https://api.githubcopilot.com/mcp/"

[mcp_servers.sentry.identity]
url = "https://mcp.sentry.dev/mcp"

[mcp_servers.playwright.identity]
command = { executable = "npx", args = [{ match = "exact", value = "@playwright/mcp@0.0.83" }] }

[marketplaces]
restrict_to_allowed_sources = true

[marketplaces.allowed_sources.acme]
source = "git"
url = "https://github.com/acme/agent-plugins.git"

[rules]
prefix_rules = [
  { pattern = [{ token = "git" }, { token = "push" }, { token = "--force" }], decision = "forbidden", justification = "Force-push is for humans" },
]
```

Co o tych kluczach mówi kod źródłowy Codeksa (0.157.1):

- `allowed_login_methods = ["chatgpt"]` blokuje logowanie kluczem API, a `allowed_chatgpt_workspaces` ogranicza logowanie przez ChatGPT do identyfikatora waszego workspace'u (kontrola 1).
- Pierwszy wpis `allowed_approval_policies` to wartość zastępcza, której Codex używa, gdy użytkownik lub flaga prosi o niedozwoloną politykę; na pierwszym miejscu stawiaj politykę, na której ludzie mają wylądować. W 0.157.1 użytkownik nie może już wybrać `untrusted` w `config.toml`, ale Codex nadal stosuje ten tryb do projektów oznaczonych jako niezaufane. Zostaw go na liście, na drugim miejscu, żeby te projekty nie zostały poszerzone do wartości zastępczej.
- `allowed_sandbox_modes` musi zawierać `read-only`, inaczej Codex odrzuca wymaganie. Ograniczenie obejmuje też profile uprawnień.
- Wymagania MCP dopasowują **jednocześnie nazwę serwera i jego tożsamość**: serwer GitHuba zarejestrowany jako `gh` zamiast `github` zostanie wyłączony, choć jego URL jest zatwierdzony. Publikuj dokładne nazwy razem z listą.
- `identity.command = "npx"` jako zwykły napis pasuje do każdego serwera uruchamianego przez `npx`. Użyj formy tabeli z `executable` i `args`, jak wyżej; argumenty muszą się zgadzać liczbą i kolejnością.
- Reguły w wymaganiach przyjmują tylko `prompt` albo `forbidden`; Codex zostawia wynik najbardziej restrykcyjny, więc `allow` jest odrzucane.
- `allow_managed_hooks_only = true` ignoruje hooki użytkownika, projektu i sesji i działa wyłącznie w `requirements.toml`.

W 0.157.1 `requirements.toml` nie ma listy w stylu `allowed_models` (sprawdzone w `config_requirements.rs` 2026-09-26). `model_catalog_json` przypina plik katalogu czytany przez Codeksa; przetestuj go, zanim potraktujesz go jak listę dozwolonych. Dostęp do modeli kontroluj w ustawieniach workspace'u ChatGPT albo w bramce, jak opisuje strona o tym, [gdzie działa model](/pl/org/model-hosting/).

Nie ma też klucza dla kontroli 8 ani 9. Wersję Codeksa przypinaj narzędziami do pakietów albo MDM, a sekcję `[otel]` dostarczaj w rozsyłanym `config.toml`; użytkownicy mogą go edytować, więc sprawdzaj w kolektorze, których maszyn brakuje.

**Cursor**

Kontrole zespołowe Cursora są w jego panelu administracyjnym. Ponieważ cursor.com był niedostępny 2026-09-26, ta zakładka zawiera pytania do zamknięcia w panelu zamiast kluczy do wklejenia.

| Kontrola bazowa | Co potwierdzić w ustawieniach administracyjnych Cursora | Dowód do zapisania |
| --- | --- | --- |
| 1 Logowanie | SSO jest wymuszone; żadnych prywatnych kont przy firmowych repozytoriach | Zrzut ekranu SSO z datą |
| 2 Modele | Zgłaszane: listy dozwolonych i blokowanych modeli w ustawieniach administracyjnych Routera, per zespół lub grupa; Privacy Mode wymuszany w całej organizacji, ze zgodą administratora na modele wymagające retencji danych. Potwierdź oba | Lista modeli i ustawienie Privacy Mode |
| 3, 4 Minimalny poziom uprawnień, odczyt sekretów | Zgłaszane: grupy niosą uprawnienia agentów. Potwierdź, który tryb uruchamiania członkowie mogą wybrać, czy da się go zablokować i jak pliki `.env` są wyłączane z kontekstu | Ustawienie plus log sesji testowej |
| 5 Serwery MCP | Czy serwery MCP da się ograniczyć do zatwierdzonej listy na poziomie zespołu | Lista i test zablokowanego serwera |
| 6 Pluginy | Zgłaszane: administratorzy marketplace'u zespołu mogą ustawić pluginy jako **Default On** lub **Required**. Potwierdź, czy inne źródła da się zablokować | Konfiguracja marketplace'u |
| 8 Wersja | Czy da się wymusić minimalną wersję klienta | Ustawienie albo konfiguracja MDM |

„Zgłaszane” oznacza: znalezione we fragmentach dokumentacji lub changelogu Cursora (źródło wtórne, 2026-09-26), nieotwartych tutaj. Zapisz każdą odpowiedź z datą i wersją Cursora w repozytorium polityki. Kwestie przetwarzania danych omawia strona o [prywatności i bezpieczeństwie w Cursorze](/pl/cursor-ide/team/privacy-security/).

**GitHub Copilot**

Zarządzane ustawienia enterprise w Copilocie to `managed-settings.json` w repozytorium `.github-private`, które wskazujesz jako źródło zarządzania klientami w enterprise. GitHub waliduje plik i pokazuje błędy na karcie **Agents** w **AI Controls**. Obsługiwane klienty dostają zmiany w ciągu mniej więcej godziny.

```json
{
  "model": "auto",
  "permissions": {
    "deny": ["Read(./.env)", "Read(./.env.*)", "Read(./secrets/**)"],
    "disableBypassPermissionsMode": "disable"
  },
  "allowedMcpServers": [
    { "serverUrl": "https://api.githubcopilot.com/*" },
    { "serverUrl": "https://mcp.sentry.dev/*" },
    { "serverCommand": ["npx", "@playwright/mcp@0.0.83"] }
  ],
  "strictKnownMarketplaces": [
    { "source": "github", "repo": "acme/agent-plugins" }
  ],
  "telemetry": {
    "enabled": true,
    "endpoint": "https://otel.acme.internal:4318",
    "protocol": "http/protobuf",
    "captureContent": false,
    "lockCaptureContent": true
  }
}
```

Zapisz go jako `copilot/managed-settings.json`. Blok `telemetry` realizuje kontrolę 9 w Copilot CLI, VS Code i JetBrains, ale nie w aplikacji GitHub Copilot ani w Copilot cloud agent; `protocol` przyjmuje `http/json` albo `http/protobuf`. Poza tym plikiem:

- **Logowanie.** Klucz `forceLoginOrgs` w Copilot CLI ogranicza logowanie do waszych organizacji; dostarcz go przez MDM albo plik systemowy, nie przez `.github-private`, bo musi działać przed pierwszym logowaniem. Działa w trybie fail-closed: nieczytelna wartość blokuje każde logowanie.
- **Modele.** Dostępność ustawiasz w **AI Controls**, per model. Sprawdź politykę **Default availability for released models**, która inaczej daje nowe modele wszystkim. Per repozytorium Copilot CLI czyta też `.github/allowed_models.txt` (jeden glob na linię plus jedna linia `fallback:`); nie filtruje on modeli z własnym kluczem.
- **Polityka MCP.** Żaden serwer nie ruszy, dopóki polityka **MCP servers in Copilot** jest wyłączona. Jeśli wcześniej ograniczałeś MCP do rejestru, GitHub zaleca ustawić **Restrict MCP access to registry servers** na **Allow all**, żeby jedynym źródłem prawdy była lista dozwolonych.

Wyjątki dla zespołów robisz przez `{ "overridable": VALUE }` w głównym pliku, plik zespołu w `copilot/teams/` i `copilot/team-mappings.json`. Na macOS i Linuksie Copilot CLI odrzuca plik ustawień zarządzanych, który jest dowiązaniem symbolicznym, nie należy do `root` albo jest zapisywalny dla grupy lub wszystkich.

## Jak kontrolować agentów chmurowych, którzy tylko otwierają pull requesty?

Copilot cloud agent, agenci Claude i Codex w Copilocie, Jules i Devin pracują na zdalnych maszynach, więc nic wdrożonego na laptop do nich nie dociera. Sesja Claude Code w chmurze również czyta tylko ustawienia zarządzane z serwera. Tych agentów kontrolujesz tam, gdzie ląduje ich praca: na hostingu Git.

| Kontrola | Gdzie żyje | Kogo dotyczy |
| --- | --- | --- |
| Którzy agenci mogą działać | Polityki Copilota w **AI Controls**, per agent; repozytoria, do których ma dostęp aplikacja GitHub danego dostawcy | Wszyscy |
| Co może zostać scalone | Rulesety albo ochrona gałęzi: wymagane review, wymagane kontrole stanu (status checks), brak obejścia dla tożsamości botów | Każdy agent otwierający PR |
| Jakie sekrety widzi uruchomienie | Sekrety środowiska i repozytorium ograniczone do workflow; GitHub Action Julesa czyta klucz z sekretu repozytorium `JULES_API_KEY` | Agenci uruchamiani z GitHub Actions |
| Co zostało zrobione | Log audytu enterprise, w tym zdarzenia agentowe w AI Controls; logi CI | Agenci Copilota; każdy agent przez CI |

Dokumentacja administracyjna Julesa i Devina była niedostępna 2026-09-26, więc ta strona nie twierdzi nic o ich ustawieniach w produkcie. Granica na hostingu Git działa dla każdego dostawcy, dlatego kontrola 10 brzmi „PR-y agentów przechodzą te same wymagane kontrole co PR-y ludzi”. [Pakiet dowodów](/pl/workflows/ship/evidence-bundle/) pozwala scalić PR bez człowieka czytającego każdą linię.

## Jak dystrybuować i wersjonować jedną politykę dla wielu dostawców?

Traktuj politykę jak każdą inną konfigurację produkcyjną: jedno repozytorium, zmiany przez review, bramki w CI i wdrożenie etapami.

1. **Załóż repozytorium polityki.** Jeden katalog na narzędzie, wygenerowany z tabeli intencji.

   ```text
   agent-policy/
   ├── POLICY.md                        # tabela intencji dziesięciu kontroli, podpisana przez bezpieczeństwo
   ├── CHANGELOG.md                     # jeden wpis na wersję: co i dlaczego
   ├── CODEOWNERS                       # zatwierdzają bezpieczeństwo + zespół platformowy
   ├── claude-code/managed-settings.json
   ├── claude-code/ci/managed-settings.json   # runnery CI: bez disableSideloadFlags
   ├── codex/requirements.toml
   ├── copilot/managed-settings.json    # synchronizowany do .github-private/copilot/
   ├── cursor/EVIDENCE.md               # datowane odpowiedzi z zakładki Cursor
   └── tests/mcp_parity.py
   ```

2. **Blokuj każdą zmianę w CI.** Sparsuj każdy plik, a potem oznacz kontrolę jako nieudaną, gdy listy dozwolonych MCP się różnią. Ten skrypt, uruchomiony na trzech plikach z tej strony, kończy się kodem `1`, gdy Claude Code i Copilot się różnią albo gdy Codex i Claude Code nie zgadzają się w którąkolwiek stronę.

   ```python
   """Fail CI when the MCP allowlists disagree across tools."""
   import fnmatch
   import json
   import sys
   import tomllib

   claude = json.load(open("claude-code/managed-settings.json"))
   copilot = json.load(open("copilot/managed-settings.json"))
   with open("codex/requirements.toml", "rb") as f:
       codex = tomllib.load(f)

   def allowlist(settings):
       entries = settings.get("allowedMcpServers", [])
       urls = {e["serverUrl"] for e in entries if "serverUrl" in e}
       cmds = {tuple(e["serverCommand"]) for e in entries if "serverCommand" in e}
       return urls, cmds

   problems = []
   if allowlist(claude) != allowlist(copilot):
       problems.append(f"Claude Code and Copilot differ: {allowlist(claude)} vs {allowlist(copilot)}")

   codex_urls, codex_cmds = {}, {}
   for name, req in codex.get("mcp_servers", {}).items():
       ident = req.get("identity", {})
       if isinstance(ident.get("url"), str):
           codex_urls[ident["url"]] = name
       cmd = ident.get("command")
       if isinstance(cmd, dict):
           argv = (cmd["executable"], *(a.get("value", "") for a in cmd.get("args", [])))
           codex_cmds[argv] = name

   claude_urls, claude_cmds = allowlist(claude)
   for url, name in codex_urls.items():
       if not any(fnmatch.fnmatch(url, p) for p in claude_urls):
           problems.append(f"Codex allows {name} at {url}; Claude Code does not")
   for argv, name in codex_cmds.items():
       if argv not in claude_cmds:
           problems.append(f"Codex allows {name} as {' '.join(argv)}; Claude Code does not")
   for pattern in claude_urls:
       if not any(fnmatch.fnmatch(url, pattern) for url in codex_urls):
           problems.append(f"Claude Code allows {pattern}; Codex has no matching server")
   for argv in claude_cmds - codex_cmds.keys():
       problems.append(f"Claude Code allows {' '.join(argv)}; Codex has no matching server")

   print("\n".join(problems) or "MCP allowlists agree across Claude Code, Codex and Copilot")
   sys.exit(1 if problems else 0)
   ```

   Uruchamiaj go jako wymaganą kontrolę CI poleceniem `python3 tests/mcp_parity.py` (Python 3.11 lub nowszy, ze względu na `tomllib`), obok `python3 -m json.tool` na każdym pliku JSON.

3. **Najpierw wdróż na grupę kanarkową.** Dostarcz nową wersję na maszyny zespołu platformowego na dwa dni robocze. Zmiany w ustawieniach zarządzanych z serwera docierają do Claude Code i Copilota w około godzinę; MDM Claude Code sprawdza co 30 minut, a Copilot co godzinę; zmiana pliku wymaga restartu Copilota.

4. **Wypromuj na wszystkich i przypnij wersję.** Otaguj wydanie (`agent-policy v1.4`) i wpisz wersję w komentarzu na górze każdego pliku, żeby zgłoszenie do supportu mogło ją podać.

5. **Najpierw zapowiadaj usunięcia.** Nowa reguła deny albo usunięty serwer MCP psuje komuś pracę; opublikuj wpis w changelogu przed wdrożeniem i podaj zamiennik.

Repozytorium i wdrożenie należą do zespołu platformowego; szef bezpieczeństwa zatwierdza każdą zmianę w `POLICY.md` i podpisuje kwartalny audyt. Pełną macierz RACI zawiera [model operacyjny](/pl/org/operating-model/).

## Jak udowodnić, że polityka obowiązuje?

Plik konfiguracyjny dowodzi tylko tego, że ktoś go napisał. Egzekwowanie udowadniasz na prawdziwych maszynach, według harmonogramu.

1. **Odczytaj efektywne źródło na próbce maszyn.** W Claude Code `/status` musi pokazać `Enterprise managed settings` ze źródłem, które wdrożyłeś, np. `(remote)` albo `(file)`; `Skipped sources` oznacza, że wygrało źródło o wyższym priorytecie, a `claude doctor` wypisuje wpisy odrzucone jako niepoprawne. W Codeksie `/debug-config` pokazuje, które źródło ustawiło każde ograniczenie. W Copilocie walidator na karcie **Agents** nie może pokazywać problemów.
2. **Uruchom testy negatywne.** Dodaj na maszynie kanarkowej serwer MCP spoza listy i potwierdź, że każde narzędzie go odrzuca. Do dwóch kolejnych testów użyj jednorazowej maszyny kanarkowej z ograniczoną siecią i bez poświadczeń produkcyjnych, bo jeśli polityka nie dotarła, flaga obejścia uruchomi sesję bez żadnych kontroli. Uruchom Claude Code z `--dangerously-skip-permissions`, co musi zostać odrzucone, i Codeksa z `-a never`, a potem potwierdź, że wypisał ostrzeżenie startowe i że `/debug-config` pokazuje `on-request`.
3. **Obserwuj strumień audytu.** Claude Code wysyła do twojego kolektora OpenTelemetry zdarzenia `claude_code.plugin_installed` i `claude_code.plugin_loaded`; nazwy pluginów zewnętrznych są zamaskowane, dopóki nie ustawisz `OTEL_LOG_TOOL_DETAILS=1`. Log audytu enterprise w Copilocie zapisuje zdarzenia agentowe. Kieruj oba do potoku opisanego w [obserwowalności agentów](/pl/workflows/operate/agent-observability/).
4. **Audytuj co kwartał.** Porównaj repozytorium, dostarczone ustawienia i testy negatywne; niewyjaśniona różnica to ustalenie z właścicielem i terminem.

## Prompty do zarządzania polityką agentów

**Prompt do skopiowania: przełóż intencję polityki na plik każdego narzędzia**

```text
Read POLICY.md in this repository: a table of ten agent controls with our baseline rules.
Update claude-code/managed-settings.json, codex/requirements.toml and
copilot/managed-settings.json so each implements every control that tool can enforce.
Use only keys documented in the vendor's current docs: Claude Code's settings reference,
openai/codex config_requirements.rs, and GitHub's enterprise managed settings reference.
For each control a tool cannot enforce, add a row to GAPS.md with the tool, the control
and the compensating control. Keep the MCP allowlist identical across the three files,
run python3 tests/mcp_parity.py, and do not invent keys. List every key you were unsure of.
```

**Prompt do skopiowania: audyt polityki obowiązującej na tej maszynie**

```text
Audit which agent policy is actually in force on this machine. Without changing anything:
1. List every managed policy file present at the documented system paths for Claude Code
   (/etc/claude-code or /Library/Application Support/ClaudeCode), Codex (/etc/codex) and
   GitHub Copilot (/etc/github-copilot or /Library/Application Support/GitHubCopilot),
   with owner, permissions and the policy version comment at the top.
2. List every MCP server configured in ~/.claude.json, .mcp.json, ~/.codex/config.toml,
   .codex/config.toml and .vscode/mcp.json, and mark each one allowed or blocked by the
   policy files you found, quoting the matching entry.
3. Flag any server whose Codex config name differs from the name in requirements.toml.
Report a table, then the three highest-risk findings. Never print a token value.
```

**Prompt do skopiowania: review zmiany polityki przed wdrożeniem**

```text
Review the diff in this pull request to our agent-policy repository as the security lead.
For every changed key, explain in one line what a developer will notice after rollout,
which teams or CI jobs it could break (search this organization's repositories for the
affected MCP server names, CLI flags and hook files), and whether the change widens or
narrows the policy. Flag any widening that CHANGELOG.md does not justify. End with the
canary checks I should run before promoting it to everyone.
```

## Co się psuje, gdy egzekwujesz jedną politykę u wielu dostawców?

**Plik polityki Claude Code jest po cichu ignorowany.** Wdrożyłeś plik przez MDM, a ktoś ustawił jeden klucz w konsoli administracyjnej. Domyślnie Claude Code używa tylko źródła o najwyższym priorytecie, które dostarcza klucz polityki. Naprawa: przeczytaj `Skipped sources` w `/status`, a potem użyj jednego źródła albo ustaw `managedSourcesBehavior` na `"merge"` (od v2.1.242).

**Uszkodzony plik blokuje ludzi.** Claude Code nie startuje, gdy plik zarządzany nie jest poprawnym JSON-em; Copilot traktuje uszkodzoną listę dozwolonych jak pustą, co blokuje każdy serwer MCP poza wbudowanymi. Naprawa: wróć do poprzedniego tagu; parsowanie w CI zapobiega powtórce.

**Codex wyłącza zatwierdzony serwer.** Jego nazwa różni się od klucza w wymaganiach albo zarejestrowano go z `npx -y` wobec tożsamości bez `-y`. Naprawa: publikuj dokładne polecenie `codex mcp add` dla każdego zatwierdzonego serwera, z nazwami i argv z `requirements.toml` (sprawdzone z `codex mcp add --help`, 0.157.1):

```bash
codex mcp add github --url https://api.githubcopilot.com/mcp/
codex mcp add sentry --url https://mcp.sentry.dev/mcp
codex mcp add playwright -- npx @playwright/mcp@0.0.83
```

**Zadania CI przestają działać po wdrożeniu.** `disableSideloadFlags` odrzuca `--mcp-config`. `codex exec` prosi o politykę zatwierdzania `never`; jeśli lista jej nie zawiera, Codex startuje z ostrzeżeniem i wraca do pierwszej dozwolonej polityki, więc uruchomienie bez nadzoru dostaje prośby o zatwierdzenie, na które nikt nie odpowie (sprawdzone w codex-cli 0.157.1). Naprawa: daj runnerom CI własny plik polityki, którego `allowed_approval_policies` zawiera `never`, i utrzymuj je na [utwardzonych workflow](/pl/org/agent-identity-and-secrets/) z poprzedniego kroku.

**Agenci Copilota ignorują listę dozwolonych MCP.** GitHub oznacza `allowedMcpServers`, `deniedMcpServers` i `permissions.deny` jako nieobsługiwane w Copilot cloud agent, a agenci Claude i Codex w Copilocie mają własne polityki. Naprawa: skonfiguruj serwery MCP cloud agenta per repozytorium albo w profilach agentów niestandardowych enterprise i przejrzyj wiersz polityki każdego agenta w **AI Controls**.

**Nowe modele pojawiają się u wszystkich.** Polityka **Default availability** w Copilocie i `availableModels` w Claude Code bez `enforceAvailableModels` przepuszczają modele spoza listy. Naprawa: ustaw oba świadomie i sprawdzaj listę modeli w kwartalnym audycie; aktualne modele wymienia [przegląd modeli](/pl/ecosystem/models/).

**Długo działające sesje nie nadążają za wdrożeniem.** `requiredMinimumVersion` blokuje tylko nowe starty. Naprawa: ogłoś okno restartu, a potem sprawdź wersje w telemetrii.

## Dokąd dalej z zarządzaną polityką agentów

- [Tożsamość, poświadczenia i sekrety agentów](/pl/org/agent-identity-and-secrets/): poprzedni krok ścieżki CTO, źródło reguł deny i zakresów MCP.
- [Zespół platformowy agentów](/pl/org/platform-team/): kolejny krok, w którym to repozytorium staje się produktem z właścicielem.
- [Rejestry i bramki MCP](/pl/ecosystem/mcp/registry-and-gateways/): weryfikacja i hosting serwerów z listy.
- [Marketplace pluginów dla zespołu](/pl/ecosystem/plugins/team-marketplace/): marketplace, na który wskazuje polityka.
- [Uprawnienia i sandboksy dla agentów](/pl/workflows/harness/permissions-and-sandboxing/): ustawienia repozytorium pod tym minimum.
- [Polityka użycia AI, której inżynierowie będą przestrzegać](/pl/org/usage-policy/): czytelna dla ludzi polityka stojąca za tą konfiguracją.
- Szczegóły wdrożenia per narzędzie: [Claude Code dla zespołów](/pl/claude-code/team/), [zarządzanie Codeksem w enterprise](/pl/codex/team/enterprise-governance/) i [porównanie z GitHub Copilot](/pl/comparison/github-copilot/).
