# Agenci kodujący w sieci korporacyjnej

URL: https://developertoolkit.ai/pl/org/corporate-environment/
Description: Claude Code, Codex i Cursor za proxy korporacyjnym, inspekcją TLS, SSO i listą dozwolonych hostów, wdrożone przez MDM i sprawdzone testem dymnym.

Uruchomienie Claude Code, Codeksa lub Cursora w sieci korporacyjnej wymaga czterech ustawień nadawanych raz dla organizacji: trasy przez proxy, której narzędzia ufają mimo inspekcji TLS, listy dozwolonych hostów wyjściowych, logowania przypiętego do firmowego tenanta oraz połączeń MCP z systemami wewnętrznymi uwierzytelnianych jako użytkownik. Dostarcza się je przez ustawienia zarządzane lub MDM; działanie potwierdza skryptowy smoke test.

Ta strona jest dla CTO, lidera platformy lub właściciela IT, który zatwierdził pilotaż i ma teraz 30 zarządzanych laptopów, na których nic się nie łączy. Agent kończy się błędem `self-signed certificate in certificate chain`, serwer MCP dla Jiry nigdy nie kończy logowania OAuth, a dział bezpieczeństwa chce wiedzieć, z jakimi hostami rozmawiają narzędzia, zanim otworzy firewall. Poniżej znajdziesz kolejność naprawiania tych problemów, osobno dla każdego narzędzia, i sposób, by udowodnić, że każda poprawka działa na każdej maszynie.

## Co daje działająca konfiguracja korporacyjna

- Plik ustawień zarządzanych i `requirements.toml` dla Codeksa, które ustawiają proxy, firmowy główny certyfikat CA i dozwolone logowanie, dostarczane przez MDM zamiast ręcznych zmian w powłoce każdego programisty.
- Listę dozwolonych hostów wyjściowych zbudowaną z logów twojego proxy, z listą Anthropic jako punktem wyjścia.
- Połączenia MCP z Jirą i Confluence logujące się jako użytkownik przez OAuth oraz z GitHubem przez osobny, zawężony token każdego użytkownika, dzięki czemu agent sięga tylko tam, gdzie sięga użytkownik.
- Skrypt testu dymnego, który dla każdego elementu konfiguracji na świeżo zarejestrowanym laptopie wypisuje PASS albo FAIL, więc nikt nie czyta plików konfiguracyjnych ręcznie.
- Tabelę awarii, na które pilotaż faktycznie trafi, z naprawą dla każdej.

Co dopuścić (modele, narzędzia, serwery MCP, minimalne uprawnienia), to pytanie o politykę, opisane w [jednej polityce dla wszystkich agentów kodujących](/pl/org/managed-policy/). Gdzie działa model (Bedrock, Google Cloud, bramka, zero retencji danych), opisuje strona [gdzie działa model](/pl/org/model-hosting/). Ta strona sprawia, że narzędzia działają w twojej sieci, gdy te decyzje już zapadły.

## Czego agent kodujący potrzebuje od sieci korporacyjnej?

Cztery elementy konfiguracji w kolejności, w jakiej psują się pierwszego dnia:

| Element | Objaw, gdy go brakuje | Właściciel | Gdzie się go ustawia |
| --- | --- | --- | --- |
| **Trasa przez proxy i zaufanie TLS** | Przekroczenia czasu; `ECONNREFUSED`; Claude Code zatrzymuje się przy starcie, gdy adres proxy nie ma schematu. Potem `UNABLE_TO_GET_ISSUER_CERT_LOCALLY`, `self-signed certificate in certificate chain`, w Codeksie „Failed to read CA certificate file” | Zespół sieci, bezpieczeństwo / PKI | Zmienne proxy plus magazyn certyfikatów systemu i zmienna CA w każdym narzędziu, dostarczane przez ustawienia zarządzane lub MDM |
| **Lista dozwolonych hostów** | Jedna funkcja nie działa, reszta tak (pluginy, konektory, aktualizator) | Zespół sieci | Polityka proxy lub firewalla |
| **Logowanie** | Programiści logują się na prywatne konta | Zespół tożsamości | Zarządzane ustawienia logowania |
| **Tożsamość MCP** | Callback OAuth dla MCP nigdy się nie kończy; serwer łączy się wspólnym tokenem | Zespół tożsamości | Rejestracja klienta OAuth; tokeny osobne dla każdego użytkownika |

Naprawiaj je w tej kolejności, najpierw trasę, potem zaufanie. Problem z CA wygląda jak problem z proxy, dopóki trasa nie działa, a problem z OAuth wygląda jak problem z CA, dopóki nie działa TLS.

## Skonfiguruj proxy i firmowy certyfikat CA w każdym narzędziu

Każde z trzech narzędzi korzysta z innego magazynu zaufanych certyfikatów, więc jeden `export NODE_EXTRA_CA_CERTS` nie naprawi wszystkich. Claude Code to aplikacja Node, Codex to program binarny napisany w Ruście z własną zmienną CA, a Cursor to aplikacja Electron.

**Claude Code**

    Claude Code czyta `HTTPS_PROXY`, `HTTP_PROXY` i `NO_PROXY` (także w wersji z małych liter). Domyślnie ufa dołączonemu zestawowi Mozilla CA **oraz** magazynowi systemu operacyjnego, więc główny certyfikat inspekcji TLS zainstalowany w magazynie systemu zwykle działa bez dodatkowych ustawień. Odczyt magazynu systemu wymaga natywnego instalatora albo, przy instalacji z npm, Node 22.15 lub nowszego; w innym przypadku dodaj certyfikat przez `NODE_EXTRA_CA_CERTS`.

    Umieść zmienne w bloku `env` ustawień zarządzanych, a nie w profilu powłoki. Agenci w tle (`claude agents`, `--bg`) działają pod osobnym procesem nadzorcy dla każdego użytkownika, który nie dziedziczy twojej powłoki, więc eksport w powłoce dociera do nich tylko przypadkiem. [Dokumentacja konfiguracji sieci](https://code.claude.com/docs/en/network-config) Anthropic mówi, że ustawienia to jedyna konfiguracja docierająca do każdej sesji w tle.

    ```json
    // managed-settings.json
    {
      "forceLoginMethod": "claude-ai",
      "forceLoginOrgUUID": "YOUR_ORG_UUID",
      "env": {
        "HTTPS_PROXY": "http://proxy.corp.example:8080",
        "NO_PROXY": "localhost,127.0.0.1,.corp.example",
        "NODE_EXTRA_CA_CERTS": "/etc/ssl/certs/corp-root-ca.pem"
      }
    }
    ```

    Wdróż plik przez konsolę administracyjną claude.ai, profil MDM albo ścieżkę systemową (`/Library/Application Support/ClaudeCode/` na macOS, `/etc/claude-code/` na Linuksie i WSL, `C:\Program Files\ClaudeCode\` w Windowsie). `YOUR_ORG_UUID` to identyfikator twojej organizacji w claude.ai; `forceLoginOrgUUID` egzekwuje tylko źródło zarządzane. Proxy wymagające certyfikatów klienta obsługujesz przez `CLAUDE_CODE_CLIENT_CERT` i `CLAUDE_CODE_CLIENT_KEY`. Szczegóły dla tego narzędzia są w [konfiguracji proxy i VPN dla Claude Code](/pl/claude-code/team/proxy-configuration/).

**Codex**

    Codex nie czyta `NODE_EXTRA_CA_CERTS`. Pakiet CA bierze z `CODEX_CA_CERTIFICATE`, w drugiej kolejności z `SSL_CERT_FILE`, a gdy żadna nie jest ustawiona, używa certyfikatów systemowych (według `codex-rs/http-client/src/custom_ca.rs`, sprawdzone 2026-09-26). Czyta standardowe zmienne proxy, a w codex-cli 0.157.1 funkcja `system_proxy_fallback` (stabilna, włączona) pozwala mu sięgnąć po ustawienia proxy systemu operacyjnego; obsługa PAC/WPAD pojawiła się w 0.143.0.

    ```bash
    # Delivered by MDM or the managed shell profile, not typed by developers
    export HTTPS_PROXY=http://proxy.corp.example:8080
    export NO_PROXY=localhost,127.0.0.1,.corp.example
    export CODEX_CA_CERTIFICATE=/etc/ssl/certs/corp-root-ca.pem
    ```

    Przypnij logowanie w pliku ograniczeń administracyjnych, którego użytkownik nie nadpisze:

    ```toml
    # /etc/codex/requirements.toml
    allowed_login_methods = ["chatgpt"]
    allowed_chatgpt_workspaces = ["YOUR_WORKSPACE_ID"]
    ```

    `YOUR_WORKSPACE_ID` to identyfikator twojej przestrzeni roboczej ChatGPT Business lub Enterprise. Oba klucze są w `config_requirements.rs` (sprawdzone 2026-09-26); resztę pliku opisują [polityka zarządzana](/pl/org/managed-policy/) i [ład korporacyjny w Codeksie](/pl/codex/team/enterprise-governance/).

**Cursor**

    Cursor to aplikacja Electron z własnym stosem sieciowym, więc skonfiguruj go według dokumentacji sieciowej Cursora, a wynik potwierdź testem dymnym i logami proxy opisanymi niżej, zamiast czytać jego ustawienia. Dwie rzeczy są prawdziwe niezależnie od własnych ustawień Cursora:

    - Serwery MCP, które Cursor uruchamia przez `npx`, to procesy Node. Node czyta `NODE_EXTRA_CA_CERTS` przy starcie, więc ustaw ją w środowisku, z którego startuje Cursor (w środowisku logowania zarządzanym przez MDM, nie w eksporcie w terminalu).
    - To, czy serwer MCP respektuje `HTTPS_PROXY`, zależy od jego klienta HTTP. Przetestuj każdy serwer stdio za proxy, zanim go zatwierdzisz, albo wybierz zdalny serwer HTTP dostawcy, z którym Cursor łączy się bezpośrednio.

    Ponieważ listy hostów Cursora nie dało się zweryfikować, zbuduj ją z logów proxy promptem z następnej sekcji; w filtrze procesów uwzględnij `Cursor` i jego procesy pomocnicze Electrona. Zespołowe ustawienia prywatności i administracji opisuje strona [prywatność i bezpieczeństwo w Cursorze](/pl/cursor-ide/team/privacy-security/).

  Nigdy nie ustawiaj `NODE_TLS_REJECT_UNAUTHORIZED=0`, żeby ominąć błąd certyfikatu. Wyłącza to walidację dla każdego połączenia procesu, także tych, które twoja inspekcja TLS ma obserwować, i oblewa każdy przegląd bezpieczeństwa. Napraw magazyn certyfikatów. Claude Code nie obsługuje proxy SOCKS (sprawdzone w Claude Code 2.1.283), a przy uwierzytelnianiu proxy przez NTLM lub Kerberos Anthropic zaleca bramkę LLM obsługującą tę metodę.

## Które hosty dopuścić na liście?

Zacznij od listy dostawcy, a dokończ na podstawie własnych logów proxy. Anthropic publikuje listę dla Claude Code w [wymaganiach dostępu sieciowego](https://code.claude.com/docs/en/network-config#network-access-requirements); hosty potrzebne w większości pilotaży to:

| Host | Potrzebny do |
| --- | --- |
| `api.anthropic.com` | Zapytań do modelu (nie na trasach Bedrock, Google Cloud i Foundry, poza kontrolą bezpieczeństwa WebFetch) |
| `claude.ai`, `claude.com`, `platform.claude.com` | Logowania i odświeżania tokenów OAuth |
| `mcp-proxy.anthropic.com` | Konektorów MCP skonfigurowanych w claude.ai, które przechodzą przez ten host |
| `downloads.claude.ai` | Natywnego instalatora, aktualizatora, plików wykonywalnych pluginów |
| `registry.npmjs.org` | Serwerów MCP uruchamianych przez `npx` i zależności pluginów, chyba że masz lustro npm |
| `github.com` | Marketplace'ów pluginów hostowanych na GitHubie |

Dla Codeksa i Cursora nie ma listy dostawcy, którą dało się zweryfikować 2026-09-26, więc zbuduj ją tak samo, jak sprawdzasz listę Claude: przepuść maszynę pilotażową przez zwykły dzień pracy z proxy w trybie samego logowania, a potem zamień log w listę dozwolonych hostów. Robi to poniższy prompt.

**Prompt do wklejenia: lista dozwolonych hostów z logów proxy**

```text
Read proxy-export.csv (columns: timestamp, user, process, host, port, bytes, verdict).
It covers one pilot day on laptops running Claude Code, Codex and Cursor.
1. Group by host and by process name: claude, codex, Cursor and every
   process whose name starts with Cursor (its Electron helpers), node, npx, git.
2. For each host, say which tool and which feature most likely needed it
   (model API, sign-in, MCP server, package registry, updater, telemetry).
3. Mark hosts that carry only optional telemetry separately, so we can decide
   whether to block them.
4. Output a table: host, process, feature, first seen, request count, keep/optional/unknown.
Do not guess: if you cannot attribute a host from the data, mark it unknown.
```

## Połącz systemy wewnętrzne przez MCP z tożsamością użytkownika

Serwer MCP uwierzytelniający się poświadczeniami samego użytkownika (logowaniem OAuth albo jego osobistym tokenem) działa jako użytkownik, więc agent sięga tylko do tych projektów w Jirze i repozytoriów, do których ta osoba ma już dostęp, a każdy zapis trafia do logu audytu pod jej nazwiskiem. Wybieraj zdalny serwer dostawcy zamiast lokalnego pakietu stdio: zdalny serwer usuwa pakiet, który inaczej działałby na każdym laptopie. Oba przykłady poniżej to serwery zdalne, ale uwierzytelniają się inaczej. Serwer Atlassiana loguje użytkownika przez OAuth, jego kontem Atlassian. Zdalny serwer GitHuba uwierzytelnia się nagłówkiem z osobistym tokenem dostępu (PAT), a nie przez twojego dostawcę tożsamości; logowanie w przeglądarce bez tokenu ma tylko lokalny serwer GitHuba w Dockerze (według instrukcji instalacji GitHuba, przetestowane w Claude Code 2.1.283).

**Claude Code**

    ```bash
    # Atlassian (Jira, Confluence): /v2/mcp is the recommended endpoint
    claude mcp add --transport http atlassian https://mcp.atlassian.com/v2/mcp
    # GitHub's remote server: PAT header, no OAuth login
    claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
      -H "Authorization: Bearer $GITHUB_PAT"
    ```

    Uruchom `/mcp` w sesji, aby dokończyć logowanie OAuth do Atlassiana; GitHub łączy się samym tokenem. Powłoka rozwija `$GITHUB_PAT` w chwili uruchomienia polecenia, więc w konfiguracji MCP zapisuje się sam token; aby go zrotować, uruchom polecenie ponownie. Aby token nie trafiał na dysk, czego wymaga poniższa rada o PAT, zadeklaruj serwer w `.mcp.json` z odwołaniem do zmiennej. Claude Code rozwija `${VAR}` w `headers` przy wczytywaniu pliku, więc wartość pochodzi ze zmiennej środowiskowej dostarczonej przez MDM:

    ```json
    // .mcp.json
    {
      "mcpServers": {
        "github": {
          "type": "http",
          "url": "https://api.githubcopilot.com/mcp/",
          "headers": { "Authorization": "Bearer ${GITHUB_PAT}" }
        }
      }
    }
    ```

    W tygodniach wdrożenia tylko do odczytu użyj dla GitHuba adresu `https://api.githubcopilot.com/mcp/readonly`. Jeśli twój dostawca tożsamości przyjmuje tylko wcześniej zarejestrowanych klientów OAuth, zarejestruj klienta i podaj `--client-id` oraz stały `--callback-port`, by adres przekierowania się zgadzał.

**Codex**

    ```bash
    codex mcp add atlassian --url https://mcp.atlassian.com/v2/mcp
    codex mcp login atlassian
    codex mcp add github --url https://api.githubcopilot.com/mcp/ --bearer-token-env-var GITHUB_PAT
    ```

    Dla GitHuba `--bearer-token-env-var` wysyła PAT ze wskazanej zmiennej jako token bearer, tak jak robi to instrukcja instalacji GitHuba dla Codeksa. Na zdalnej powłoce lub w VDI, gdzie nie otworzy się przeglądarka, `codex mcp login atlassian --no-browser` wypisuje adres autoryzacji i przyjmuje wklejony adres callbacku. `codex mcp login atlassian --scopes <scope,scope>` prosi tylko o wymienione zakresy OAuth.

**Cursor**

    ```json
    // .cursor/mcp.json
    {
      "mcpServers": {
        "atlassian": { "url": "https://mcp.atlassian.com/v2/mcp" }
      }
    }
    ```

    Atlassian publikuje też plugin w marketplace Cursora. Dla GitHuba instrukcja instalacji GitHuba dla Cursora używa tego samego zdalnego adresu z nagłówkiem osobistego tokenu dostępu.

Cztery szczegóły korporacyjne, które dostawcy rozrzucają po kilku dokumentach:

- **PAT dla GitHuba:** wydaj każdemu użytkownikowi osobny, szczegółowy (fine-grained) PAT, zawężony do repozytoriów pilotażu, ważny od 30 do 90 dni, i dostarcz go przez systemowy pęk kluczy albo sekret zarządzany przez MDM. Nigdy nie dziel jednego tokenu na cały zespół: każdy zapis trafiłby pod jedno nazwisko, a poniższy prompt audytowy oznacza dokładnie taki przypadek.
- **Atlassian:** uwierzytelnianie tokenem API musi włączyć administrator Atlassiana, narzędzia Jira Service Management działają tylko z tokenami API, a lista dozwolonych adresów IP Atlassiana obejmuje też serwer MCP. Stary endpoint `/v1/sse` przestał być obsługiwany po 30 czerwca 2026. Dla wersji Server i Data Center zwykle używa się społecznościowego serwera `sooperset/mcp-atlassian`; zobacz [przewodnik po Atlassian MCP](/pl/ecosystem/mcp/atlassian-mcp/).
- **Konektory claude.ai** docierają do Claude Code przez `mcp-proxy.anthropic.com` i są domyślnie włączone dla użytkowników zalogowanych przez claude.ai. Aby ruch MCP szedł tylko do zatwierdzonych serwerów, ustaw `"disableClaudeAiConnectors": true` w ustawieniach zarządzanych, a serwery dopuszczaj przez `allowedMcpServers`, jak opisuje [polityka zarządzana](/pl/org/managed-policy/).
- **Systemy wewnętrzne bez serwera dostawcy** (ERP, usługa SOAP) wymagają cienkiego serwera MCP, którego jesteś właścicielem. Zbuduj go według [tworzenia własnych serwerów MCP](/pl/ecosystem/mcp/custom-mcp-development/) i utrzymuj tak, jak opisują [wewnętrzne serwery MCP](/pl/cto-scorecard-guide/internal-mcp-servers/). Zawężanie i skanowanie serwerów przed zatwierdzeniem opisuje [bezpieczeństwo MCP](/pl/cto-scorecard-guide/mcp-security/).

## Jak udowodnić, że konfiguracja działa na każdym laptopie?

Nikt nie powinien weryfikować wdrożenia korporacyjnego, czytając pliki konfiguracyjne. Uruchom test dymny na każdej nowo zarejestrowanej maszynie, z MDM albo ze skryptu pierwszego uruchomienia, i zbieraj wyniki. Każda linia to PASS albo FAIL, więc inżynier platformy czyta podsumowanie, a nie konfigurację.

```bash
#!/usr/bin/env bash
# agent-env-smoke.sh: run as the developer on a freshly enrolled laptop.
# Needs CORP_PROXY (the proxy URL) and CORP_CA (a PEM bundle: the corporate root
# concatenated with the OS bundle, so hosts exempt from TLS inspection still verify).
set -u
: "${CORP_PROXY:?set CORP_PROXY}" "${CORP_CA:?set CORP_CA}"
fail=0
check() { if "$@" >/dev/null 2>&1; then echo "PASS  $*"; else echo "FAIL  $*"; fail=1; fi; }

# 1. Proxy route plus TLS-inspection trust, host by host
for host in api.anthropic.com platform.claude.com downloads.claude.ai registry.npmjs.org github.com; do
  check curl -sS --max-time 10 -o /dev/null --proxy "$CORP_PROXY" --cacert "$CORP_CA" "https://$host"
done

# 2. Signed in. `auth status` proves a login, not which tenant; the tenant pin itself is
#    enforced by forceLoginOrgUUID / allowed_chatgpt_workspaces, so prove those files are present.
check claude auth status
check codex login status
# macOS path: /Library/Application Support/ClaudeCode/managed-settings.json.
# Drop this line if managed settings come from the claude.ai admin console instead.
check grep -q forceLoginOrgUUID /etc/claude-code/managed-settings.json
check grep -q allowed_chatgpt_workspaces /etc/codex/requirements.toml

# 3. One real model round trip per tool, read-only
check sh -c 'claude -p "Reply with the single word OK" | grep -q OK'
check sh -c 'codex exec --skip-git-repo-check -s read-only "Reply with the single word OK" | grep -q OK'

# 4. MCP servers connect. claude mcp list health-checks each server; codex mcp list
#    only prints config, so Codex is probed with a real tool call instead.
check sh -c 'claude mcp list | grep -q "^atlassian:.*Connected"'
check sh -c 'codex exec --skip-git-repo-check -s read-only -o codex-mcp.txt "Call the atlassian MCP server and reply with one Jira project key I can see, and nothing else" && grep -qxE "[A-Z][A-Z0-9_]+" codex-mcp.txt'

# 5. Codex self-diagnosis, redacted, kept as evidence
codex doctor --json > "codex-doctor-$(hostname).json" 2>&1 || fail=1

exit $fail
```

Skrypt przekazuje proxy do `curl` jawnie, bo curl, w przeciwieństwie do agentów, nigdy nie czyta ustawień zarządzanych; bez `--proxy` ominąłby proxy tam, gdzie istnieje bezpośredni ruch wyjściowy (fałszywy PASS), albo przekroczyłby czas tam, gdzie go nie ma (fałszywy FAIL). Zbuduj `CORP_CA` poleceniem `cat corp-root-ca.pem /etc/ssl/certs/ca-certificates.crt > corp-bundle.pem` (ścieżka pakietu systemowego zależy od dystrybucji; na Macu wyeksportuj certyfikaty główne z pęku kluczy), żeby hosty wyłączone z inspekcji TLS nadal weryfikowały się względem swojego publicznego łańcucha.

Gdy linia kończy się FAIL, narzędzia mówią dlaczego:

- **Claude Code:** uruchom `claude --debug` i przeczytaj `~/.claude/debug/<session-id>.txt`. `claude --debug-file ./claude-debug.txt` zapisuje log tam, gdzie wskażesz. Załadowany certyfikat CA widać jako `CA certs: Appended extra certificates from NODE_EXTRA_CA_CERTS (…)`; zła ścieżka daje linię `Failed to read`. `/status` w sesji pokazuje aktywne proxy i oznacza nieparsowalny adres proxy jako zignorowany.
- **Codex:** `codex doctor` diagnozuje instalację, konfigurację, uwierzytelnianie i stan działania; zły plik CA daje błąd, który nazywa zmienną, z której go wzięto.
- **Logi proxy:** lista dozwolonych hostów jest udowodniona, gdy tydzień ruchu pilotażowego nie zawiera żadnego odrzuconego żądania od `claude`, `codex`, `Cursor` ani `node`.

Odbiór należy do lidera platformy: test dymny przechodzi na każdej maszynie pilotażowej, liczba odrzuconych żądań przez tydzień wynosi zero, a zespół bezpieczeństwa ma listę hostów i pliki ustawień zarządzanych pod kontrolą wersji.

**Prompt do wklejenia: diagnoza nieudanego testu dymnego**

```text
Here is the output of agent-env-smoke.sh from one laptop, plus
claude-debug.txt (written by claude --debug-file ./claude-debug.txt) and
codex-doctor.json from the same machine.
For each FAIL line:
1. Name the control that failed: proxy route, TLS trust, egress allowlist, sign-in or MCP auth.
2. Quote the log line that proves it.
3. Give the fix as a change to managed-settings.json, requirements.toml or the MDM
   environment profile, never as a per-user shell edit and never by disabling TLS validation.
4. Say which other laptops will have the same problem (same OS image, same MDM group).
Stop after the diagnosis; do not change any file.
```

**Prompt do wklejenia: audyt tożsamości MCP przed rozszerzeniem pilotażu**

```text
List every MCP server configured for this project and for my user in this tool.
For each server report: name, transport (stdio or http), URL or command, how it
authenticates (OAuth as me, a personal access token, a shared API key, none),
and whether it can write (create tickets, push commits, post messages).
Flag any server that authenticates with a shared or long-lived token, any stdio
server installed from a package without a pinned version, and any server that is
not in our approved list in docs/agent-policy/approved-mcp.md.
Output a table, then the three changes that most reduce risk.
```

## Co psuje się przy wdrażaniu agentów za proxy korporacyjnym?

| Objaw | Przyczyna | Naprawa |
| --- | --- | --- |
| `self-signed certificate in certificate chain` w Claude Code tylko na części laptopów | Na tym obrazie systemu brakuje firmowego certyfikatu głównego w magazynie systemu albo stara instalacja z npm na Node poniżej 22.15 nie czyta magazynu systemu | Zainstaluj certyfikat w magazynie systemu przez MDM albo ustaw `NODE_EXTRA_CA_CERTS` w zarządzanym bloku `env`; przenieś instalacje npm na natywny instalator |
| Codex nie przechodzi TLS, choć Claude Code działa | Codex ignoruje `NODE_EXTRA_CA_CERTS` | Ustaw `CODEX_CA_CERTIFICATE` na pakiet PEM w środowisku MDM |
| Agenci w tle zawodzą, sesje interaktywne działają | Proxy ustawione w profilu powłoki; nadzorca w tle wystartował bez niego | Przenieś zmienne do bloku `env` ustawień zarządzanych; uruchom `claude daemon stop --any`, by następna sesja w tle uruchomiła nadzorcę, który je czyta (kończy to działające sesje w tle; `--keep-workers` pozostawia odłączone sesje) |
| `ERR_PROXY_TUNNEL: Proxy refused to open a tunnel: 403 Forbidden` w `claude mcp list` | Proxy odrzuca `CONNECT` do tego hosta MCP | Dodaj host do listy, jeśli serwer jest zatwierdzony; w przeciwnym razie usuń serwer |
| Serwer MCP uruchamiany przez `npx` zawiesza się przy starcie | `registry.npmjs.org` jest zablokowany albo klient HTTP serwera ignoruje `HTTPS_PROXY` | Dopuść rejestr lub skieruj npm na wewnętrzne lustro; przejdź na zdalny serwer dostawcy |
| Logowanie OAuth do MCP nigdy się nie kończy | Dostawca tożsamości odrzuca adres przekierowania albo callback przeglądarki do localhost jest blokowany | Zarejestruj klienta OAuth; użyj `--client-id` i `--callback-port` w Claude Code albo `codex mcp login --no-browser` |
| Claude Code działa, ale rozszerzenie Chrome nie może się połączyć | Lista dozwolonych IP organizacji w Claude widzi adres wyjściowy proxy dla `bridge.claudeusercontent.com` | Kieruj ten host przez to samo wyjście co `claude.ai`, zgodnie z dokumentacją sieciową Anthropic |
| Programiści logują się na prywatne konta | Logowanie nie jest przypięte | `forceLoginMethod` i `forceLoginOrgUUID` ze źródła zarządzanego; `allowed_login_methods` i `allowed_chatgpt_workspaces` w `requirements.toml` |
| Proxy żąda NTLM lub Kerberosa | Claude Code obsługuje tylko podstawowe uwierzytelnianie proxy (sprawdzone w Claude Code 2.1.283) | Postaw przed nim bramkę LLM obsługującą uwierzytelnianie twojego proxy, jak opisuje [hosting modeli](/pl/org/model-hosting/) |

## Wdrażaj w kolejności, która buduje dowody

1. **Tydzień 1: pięciu ochotników, tylko sieć.** Wdrożone ustawienia zarządzane i `requirements.toml`, proxy w trybie samego logowania dla procesów agentów, test dymny na każdej maszynie. Kryterium wyjścia: każda linia daje PASS.
2. **Tygodnie 2–3: MCP tylko do odczytu.** Wyszukiwanie w dokumentacji i zgłoszeniach przez Atlassiana (OAuth jako użytkownik) i GitHuba (osobny PAT każdego użytkownika na adresie `/mcp/readonly`). Kryterium wyjścia: liczba odrzuconych żądań wynosi zero, a lista hostów jest w repozytorium.
3. **Tygodnie 4–6: zapisy pod nadzorem.** Tworzenie zgłoszeń i pull requestów, z trybem uprawnień agenta wymagającym zgody na zapisy (zobacz [uprawnienia i sandboxing](/pl/workflows/harness/permissions-and-sandboxing/)). Kryterium wyjścia: zaakceptowane zmiany i odsetek zmian kończących się awarią (change-fail rate), zdefiniowane jak w [projekcie pilotażu](/pl/org/pilot-design/), mieszczą się w paśmie bazowym zespołu przez dwa kolejne tygodnie.
4. **Potem rozszerzaj zespołami,** z testem dymnym w skrypcie rejestracji, żeby każdy nowy laptop sam się sprawdzał.

Adopcja rozchodzi się przez ludzi, nie przez okólniki. Badanie Microsoftu dotyczące wdrożenia Claude Code i GitHub Copilot CLI na początku 2026 roku u dziesiątek tysięcy inżynierów wykazało, że „first use spread primarily through social networks”, a osoby korzystające „merged roughly 24% more pull requests than they would have otherwise” (Murphy-Hill, Butler i Savelieva, arXiv 2607.01418, lipiec 2026). Autorzy dodają, że „a merged PR is not the same as the value it delivers”, więc mierz pilotaż zaakceptowanymi zmianami, a nie surową liczbą PR-ów; przygotowuje to [projekt pilotażu](/pl/org/pilot-design/). Do budżetu: Anthropic podaje dla Claude Code we wdrożeniach firmowych „around $13 per developer per active day and $150-250 per developer per month” ([dokumentacja kosztów](https://code.claude.com/docs/en/costs), sprawdzone 2026-09-26); śledzenie tych kosztów opisuje [zarządzanie kosztami](/pl/org/cost-governance/).

## Co dalej po wdrożeniu agentów w firmie

- [Jedna polityka dla wszystkich agentów kodujących](/pl/org/managed-policy/): co powinny dopuszczać pliki zarządzane, z wersjonowaniem i audytem.
- [Tożsamość agentów, poświadczenia i sekrety](/pl/org/agent-identity-and-secrets/): krótkotrwałe poświadczenia dla agentów w CI i sekrety trzymane poza kontekstem.
- [Gdzie działa model](/pl/org/model-hosting/): trasy chmurowe, bramki, rezydencja danych i zero retencji.
- [Standardy bezpieczeństwa i zgodność](/pl/org/security-compliance/) oraz [prywatność danych i polityki firmowe](/pl/org/privacy-data-handling/): dowody, o które pytają audytorzy.
- [Integracja korporacyjna Claude Code](/pl/claude-code/team/enterprise-integration/): pełne wdrożenie ustawień zarządzanych dla jednego narzędzia.
