# Zarządzanie kosztami użycia AI

URL: https://developertoolkit.ai/pl/org/cost-governance/
Description: Zarządzaj wydatkami na Claude Code, Codex i Cursor: telemetria per zespół, limity wydatków, polityka modeli i wysiłku oraz miesięczny przegląd kosztów.

Zarządzanie kosztami użycia AI to zestaw właścicieli, budżetów, limitów wydatków i polityk modeli, dzięki którym wydatki na Claude Code, Codex i Cursor są widoczne, przypisane do zespołów i powiązane z zaakceptowaną pracą. Opiera się na telemetrii i panelach administracyjnych samych narzędzi, a wydatki ocenia kosztem zaakceptowanej zmiany, nigdy liczbą tokenów na inżyniera.

Pierwszego dnia miesiąca dział finansów pisze do ciebie: pozycja „narzędzia AI” znowu się podwoiła i chcą wiedzieć dlaczego. Umiesz wymienić trzy narzędzia, ale nie wiesz, które zespoły odpowiadają za wzrost, czy najdroższy model nie pracował na rutynowych zadaniach z maksymalnym wysiłkiem ani czy z tych wydatków powstał jakikolwiek scalony kod. Ta strona jest dla CTO lub dyrektora inżynierii, który odpowiada za tę pozycję budżetu, i dla tech leadów, którzy na co dzień obsługują mechanizmy kontroli.

## Co daje ci ten system zarządzania kosztami

- Źródło danych o wydatkach i limit dla każdej drogi dostępu do modelu: licencji w planie, workspace’ów API, dostawców chmurowych i CI.
- Plik managed settings, który włącza telemetrię Claude Code u każdego developera, taguje wydatki per zespół, ogranicza wysiłek i zawęża listę modeli.
- Politykę modeli i wysiłku zgodną z domyślnymi ustawieniami dostawców, z nazwaną osobą, która zatwierdza eskalację.
- Szablon polityki kosztowej, listę kontrolną miesięcznego przeglądu i cztery prompty do skopiowania: przegląd wydatków, analizę wartości odstających, pełny koszt jednego przepływu pracy i projekt alertu.
- Sposób na udowodnienie, że kontrola działa, bez czytania każdej sesji: uzgodnienie z fakturą, ćwiczenia alarmowe i koszt zestawiony z jakością.

## Skąd biorą się wydatki na agentów kodujących?

Wydatki na agentów to mierzone zużycie, nie opłata za licencję, więc rachunek podąża za zachowaniem. Większość kosztu wyjaśniają trzy czynniki:

- **Model i wysiłek.** Model wyznacza cenę tokena, a poziom wysiłku (effort) decyduje, ile tokenów myślenia zużywa każde zapytanie. Strona kosztów Anthropic zaznacza, że tokeny myślenia są rozliczane jak tokeny wyjściowe i mogą sięgać „tens of thousands of tokens per request”. Ceny poszczególnych modeli są w [przeglądzie modeli](/pl/ecosystem/models/), nie tutaj.
- **Kontekst, którego nikt nie czyści.** Claude Code wysyła całą rozmowę z każdym zapytaniem. Sesja otwarta przez cały dzień albo wznowiona po wygaśnięciu cache’u przy każdej turze od nowa czyta całą historię.
- **Rozgałęzienie pracy.** Każdy subagent, agent workflow i członek zespołu agentów wysyła własne zapytania. Strona kosztów Anthropic (sprawdzona 2026-09-26) podaje, że zespoły agentów zużywają „approximately 7x more tokens than standard sessions when teammates run in plan mode”.

Jako punkt odniesienia: Anthropic podaje, że we wdrożeniach enterprise Claude Code kosztuje średnio „around \$13 per developer per active day and \$150-250 per developer per month”, a 90% użytkowników mieści się poniżej 30 USD na aktywny dzień (Anthropic, dokumentacja kosztów Claude Code, sprawdzone 2026-09-26). To liczba dostawcy dla jednego narzędzia. Zanim ustawisz limit, zmierz własne zespoły przez miesiąc.

Tokeny to tylko część kosztu. Decyzje zarządcze wymagają trzech warstw, każdej z własnym właścicielem i własną decyzją:

| Warstwa | Co obejmuje | Jaką decyzję napędza |
| --- | --- | --- |
| Portfel | Umowy, licencje, prace platformowe i integracyjne | Przedłużyć, skonsolidować lub wycofać narzędzie |
| Workflow | Zużycie modeli, CI i runtime, review, poprawki, nieudane próby, incydenty | Rozszerzyć, zawęzić lub przeprojektować workflow |
| Zmiana | Koszt uruchomienia i weryfikacji jednej zmiany, o ile dane na to pozwalają | Diagnozować wartości odstające; nigdy nie tworzyć rankingów ludzi |

Wzór, który łączy te warstwy, czyli koszt zaakceptowanej zmiany, opisuje strona o [ekonomii oprogramowania budowanego przez agentów](/pl/strategy/economics/). Ta strona obejmuje mechanizmy kontroli, które go zasilają.

## Krok 1: ustal źródło danych i limit dla każdej drogi dostępu

Mechanizmy kontroli kosztów zależą od tego, jak zespół dociera do modelu, a nie tylko od narzędzia. Zespół na licencjach Claude Team, zadanie CI na kluczu API i zespół platformowy na Amazon Bedrock mają różne liczniki. Najpierw spisz wszystkie drogi dostępu; tu przepływy pracy naprawdę różnią się między narzędziami.

**Claude Code**

Sprawdzone 2026-09-26 w [dokumentacji kosztów](https://code.claude.com/docs/en/costs) Anthropic:

| Droga dostępu | Gdzie widzisz wydatki | Gdzie je ograniczasz |
| --- | --- | --- |
| Licencje Claude Team lub Enterprise | Raport wydatków w analityce organizacji: szacowane wydatki per użytkownik i per model, CSV, aktualizacja raz dziennie. Obejmuje tylko wydatki z usage credits | Domyślnym sufitem jest limit licencji. Po włączeniu usage credits ustaw limity wydatków na poziomie organizacji, grupy lub członka w **Admin settings > Usage** |
| Claude Console (API) | Strona usage w Console i panel Claude Code, per członek | Limity wydatków workspace’u. Przy pierwszym logowaniu przez Console Claude Code tworzy workspace o nazwie „Claude Code” |
| Amazon Bedrock, Google Cloud Agent Platform (dawniej Vertex AI), Microsoft Foundry | Konsola rozliczeń twojej chmury | Budżety w chmurze albo limity per użytkownik w samodzielnie hostowanym Claude apps gateway |
| CI i skrypty (`claude -p`) | OpenTelemetry albo wyjście JSON każdego uruchomienia | `--max-budget-usd` na uruchomienie (działa tylko z `--print`) |

Eksport OpenTelemetry działa na każdej drodze dostępu i przesyła metryki tokenów i kosztu per użytkownik do twojego stosu niemal w czasie rzeczywistym (u dostawców chmurowych może je emitować także Claude apps gateway). Konfiguruje go krok 2. Jak wybrać drogę przez chmurę lub gateway i zaplanować jej budżet, opisuje strona [hosting modeli](/pl/org/model-hosting/).

**Codex**

Codex korzysta z limitów planu ChatGPT (okna pięciogodzinne i tygodniowe oraz kredyty) albo z klucza API, a te dwie drogi rozlicza się inaczej:

- **W sesji:** `/status` pokazuje szacowane kredyty lub koszt wątku dla uprawnionych workspace’ów (Codex CLI 0.148.0 lub nowszy), a `/usage` pokazuje zużycie konta (0.156.0 lub nowszy).
- **Zużycie w planie:** administratorzy workspace’u odczytują je w panelu administracyjnym ChatGPT. Strona cennika Codeksu OpenAI wymienia analitykę, Compliance API i kontrolę dostępu opartą na rolach (RBAC) jako funkcje Enterprise (sprawdzone 2026-10-12); strony pomocy OpenAI opisują panel analityki Codex i Analytics API dla Enterprise (źródło wtórne: fragmenty dokumentacji OpenAI z wyszukiwarki, 2026-09-26).
- **Zużycie przez klucz API:** uruchomienia CLI lub CI uwierzytelnione kluczem API obciążają ten projekt API, nie plan ChatGPT. Zanim na nich polegasz, sprawdź, jakie mechanizmy budżetowe oferuje twoja organizacja w OpenAI.
- **CI:** `codex exec --json` wypisuje każde zdarzenie jako JSONL. Zapisuj wyjście z numerem PR, żeby każde automatyczne uruchomienie miało ślad kosztowy.

Dla każdego zespołu zdecyduj, czy Codex działa na limitach planu, czy na rozliczeniu API, i zapisz tę decyzję. Mieszanie obu w jednym zespole rozbija jego wydatki na dwa rachunki.

**Cursor**

Plany i rozliczenia Cursora odczytaliśmy na cursor.com 2026-10-12. Po wyczerpaniu zużycia wliczonego w plan Cursor rozlicza dalej „at the same API rates with pay-as-you-go billing”; w planach Teams i Enterprise zapytania do modeli zewnętrznych (w tym trasy Auto i BYOK) podlegają też opłacie Cursor Token Rate, a Auto rozlicza się po cenie katalogowej modelu, do którego trafia zapytanie (strony Cursora o modelach i cenach oraz o Token Rate). Według Cursora Bugbot jest rozliczany za użycie w planach Teams i Individual, a nie jako subskrypcja za stanowisko (strona Cursora o rozliczeniach Bugbota). Stawkę i średni koszt przebiegu podaje strona o [zarządzaniu tokenami w Cursorze](/pl/cursor-ide/operate/token-management/), a ceny planów [analiza cen](/pl/comparison/pricing-analysis/). Fragmenty dokumentacji Cursora z wyszukiwarki (źródło wtórne, 2026-09-26) opisują panel analityki zespołu i Analytics API w planach Teams i Enterprise; tej strony nie sprawdzaliśmy ponownie.

Niezależnie od planu: znajdź w panelu administracyjnym widok wydatków i ewentualny limit, zapisz plan i tryb rozliczeń każdego zespołu oraz porównaj wydatki na Bugbota z jego średnim kosztem przebiegu. Wszystko, co jest rozliczane za użycie, należy do warstwy workflow, nawet w ramach planu.

Ceny planów narzędzi porównuje [analiza cen](/pl/comparison/pricing-analysis/). Warunki umów, własność licencji i offboarding opisuje strona o [kontach zespołowych](/pl/cto-scorecard-guide/team-billing/).

## Krok 2: przypisuj wydatki zespołom, nie ludziom

Łączna kwota to liczba, która niepokoi; kwota przypisana do zespołów to liczba, na podstawie której można działać. W Claude Code dostarczaj telemetrię i atrybucję przez [managed settings](/pl/org/managed-policy/), żeby każdy developer raportował tak samo. Claude Code ignoruje zmienne eksportera OpenTelemetry w pliku `.claude/settings.json` repozytorium, więc repozytorium nie może włączyć telemetrii ani jej przekierować.

```json
{
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_PROTOCOL": "grpc",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "http://collector.internal.example:4317",
    "OTEL_RESOURCE_ATTRIBUTES": "department=engineering,team.id=payments,cost_center=eng-142",
    "OTEL_METRICS_INCLUDE_ACCOUNT_UUID": "false",
    "OTEL_METRICS_INCLUDE_SESSION_ID": "false"
  }
}
```

Wdrażaj jeden plik na zespół, różniący się tylko wartościami `team.id` i `cost_center`. Dla wydatków liczy się metryka `claude_code.cost.usage` (USD, z etykietą `model`); `claude_code.token.usage` dzieli tokeny według typu (wejściowe, wyjściowe, odczyt z cache’u, zapis do cache’u). Zsumuj koszt po `team.id` i `model`, a masz wydatki per zespół bez budowania czegokolwiek. Konfigurację kolektora i dashboardów opisuje strona o [obserwowalności agentów](/pl/workflows/operate/agent-observability/).

O użyteczności liczb decydują trzy szczegóły:

- **Żadnych spacji w wartościach atrybutów.** `OTEL_RESOURCE_ATTRIBUTES` odrzuca białe znaki, cudzysłowy, przecinki, średniki i ukośniki wsteczne. Pisz `cost_center=eng_platform`, nigdy `cost_center=Eng Platform`.
- **Raportuj po stawkach z umowy.** Claude Code liczy koszt po cenie katalogowej. Ustaw managed setting `modelPricing` (Claude Code v2.1.242 lub nowszy) na stawki z umowy, inaczej `claude_code.cost.usage` nie zgodzi się z fakturą.
- **Proporcjonalna identyfikacja.** Dwie linie `INCLUDE_*` usuwają z metryk `user.account_uuid`, `user.account_id` i `session.id`. `user.email` (po zalogowaniu kontem Claude) i anonimowy `user.id` są dołączane zawsze; jeśli polityka przewiduje tylko poziom zespołu, usuń lub zahaszuj `user.email` w kolektorze (na przykład procesorem atrybutów OpenTelemetry). Domyślnie przypisuj koszty do zespołów, a dane na poziomie developera zbieraj tylko w uzasadnionym i przejrzanym celu, na przykład gdy developer sam zgodzi się na osobiste wskazówki optymalizacyjne. Telemetrię identyfikującą osoby najpierw skonsultuj z działem ochrony danych lub radą pracowników.

W Codex tabela `[otel]` w `~/.codex/config.toml` eksportuje logi, ślady i metryki do tego samego kolektora. Nazwy pól poniżej pochodzą ze źródeł Codex (`OtelConfigToml`, Codex CLI 0.157.1, sprawdzone 2026-09-26):

```toml
# ~/.codex/config.toml — Codex CLI 0.157.1
[otel]
environment = "prod"
log_user_prompt = false
exporter = { otlp-http = { endpoint = "http://collector.internal.example:4318/v1/logs", protocol = "binary" } }
```

`metrics_exporter` i `trace_exporter` przyjmują te same wartości `otlp-http` lub `otlp-grpc`. Atrybucja zespołów w Codex zwykle wynika z osobnych workspace’ów ChatGPT lub projektów API dla każdego zespołu. W Cursorze korzystaj z widoku per zespół w panelu administracyjnym. Lokalne narzędzia, takie jak ccusage, odpowiadają na pytanie „ile wydałem na tym laptopie?” i opisuje je strona o [śledzeniu kosztów agentów](/pl/ecosystem/observability/agent-cost-tracking/).

## Krok 3: ustal politykę modeli i wysiłku

Routing to dźwignia, którą kontrolujesz bezpośrednio, ale ważny jest kierunek: dostawcy domyślnie ustawiają dziś mocne modele przy umiarkowanym wysiłku. Zasada, której trzyma się ten serwis: **zacznij od domyślnego modelu narzędzia, dostrój wysiłek, zanim zmienisz model, a model zmieniaj dopiero wtedy, gdy wskażą to twoje własne ewaluacje.** Stan na 2026-10-12:

| Praca | Zacznij od | Gdy decyduje koszt | Eskaluj świadomie do |
| --- | --- | --- | --- |
| Trudne zadania agentowe | Claude Opus 5.5 (domyślny w Claude Code, wysiłek `medium`); GPT-6.1 Sol (domyślny w Codex, wysiłek `low`) | Podnoś wysiłek tylko po porażce, nie z przyzwyczajenia | Claude Fable 5.1, wybierany ręcznie przez `/model fable`; nigdy domyślnie. GPT-6 Astra, wybierany ręcznie w Codex |
| Codzienne funkcje i review | Opus 5.5 z domyślnym wysiłkiem; GPT-6.1 Sol w Codex | Claude Sonnet 5.5 | Opus 5.5 z wysiłkiem `high` |
| Duży wolumen, proste edycje, rozgałęzienie na subagenty | Claude Haiku 5.5; GPT-6 Luna | To samo | Domyślny model sesji |

Oba kanały wydań Claude Code mają 2026-10-17 domyślny Opus 5.5 (`stable` v2.1.292, `latest` v2.1.302). Claude Haiku 5.5 wymaga Claude Code v2.1.293 lub nowszego, czyli w tym dniu tylko kanału `latest`. Ceny i okna kontekstu wszystkich modeli są w [przeglądzie modeli](/pl/ecosystem/models/).

Polityka, której nikt nie może znaleźć, nie jest polityką. Zapisz ją tam, gdzie narzędzie ją egzekwuje lub czyta:

**Claude Code**

Dodaj klucze modeli i wysiłku do tego samego pliku managed settings co w kroku 2:

```json
{
  "availableModels": ["opus", "sonnet", "haiku"],
  "enforceAvailableModels": true,
  "maxEffortLevel": "high"
}
```

- `availableModels` ogranicza każde miejsce, w którym użytkownik wybiera model, łącznie z frontmatterem subagentów i `CLAUDE_CODE_SUBAGENT_MODEL`. Pominięcie `fable` blokuje Claude Fable 5.1 dla wszystkich, którzy dostają ten plik; zespołowi, który go potrzebuje, daj osobny plik.
- `enforceAvailableModels` (v2.1.175 lub nowszy) rozszerza listę dozwolonych modeli na opcję **Default**. Bez tego użytkownik, który wybierze Default, dostanie domyślny model konta, nawet jeśli nie ma go na liście.
- `maxEffortLevel` (v2.1.267 lub nowszy) ogranicza wysiłek ze wszystkich źródeł, w tym z `/effort`, `--effort` oraz frontmattera skilli i subagentów. Obowiązuje najniższy limit spośród wszystkich zakresów ustawień. Zespół zatwierdzony do `xhigh` lub `max` dostaje własny plik managed settings z wyższym limitem, tak samo jak w przypadku Fable.

Subagenty dziedziczą model sesji, chyba że ich frontmatter ustawia inny, więc zmiana przez `/model` na droższy model podnosi też cenę każdego dziedziczącego subagenta. Subagentom, które przeszukują kod, czytają logi lub uruchamiają testy, ustaw `model: haiku`.

**Codex**

Ustaw domyślny model i wysiłek zespołu w `config.toml`, a drogą konfigurację trzymaj jako profil o jedną flagę dalej:

```toml
# ~/.codex/config.toml — the team's everyday default, once evals support it
model = "gpt-6.1-sol"
model_reasoning_effort = "medium"
```

```toml
# ~/.codex/deep.config.toml — run with: codex --profile deep
model = "gpt-6-astra"
model_reasoning_effort = "high"
service_tier = "default"   # standard routing, not Fast
```

`--profile deep` nakłada `$CODEX_HOME/deep.config.toml` na konfigurację bazową (Codex CLI 0.157.1). Ograniczenia administracyjne trafiają do `requirements.toml`. W źródłach 0.157.1 nie ma w nim klucza listy dozwolonych modeli (można w nim wskazać własny `model_catalog_json`, czego nie testowaliśmy), więc traktuj wybór modelu jako ustawienie domyślne, a nie egzekwowaną regułę. GPT-6 Sol i Luna domyślnie działają w warstwie Fast („1.5x speed”, bez adnotacji o większym zużyciu w katalogu 0.162.1), ale brak adnotacji nie oznacza braku kosztu: Fast zużywa limity wliczone w plan w 2,5x względem Standard, a kredyty w 2x (cennik Codex OpenAI, odczyt 2026-10-12). Warstwa Fast modeli GPT-6.1 Sol i GPT-6 Astra ma adnotację „2x speed, increased usage”, więc nie włączaj jej w profilu deep; `service_tier = "default"` jawnie wybiera standardowe kierowanie zapytań (w źródłach 0.157.1 klucz przyjmuje `default`, `priority` lub `flex`).

**Cursor**

Cursor nie wskazuje jednego modelu domyślnego, a jego pula własnych modeli Cursor Models to Grok 4.7, Grok 4.6, Grok 4.5 i Composer 2.5 (strona modeli i cen, sprawdzone 2026-10-12), więc egzekwuj politykę przez ustawienia modeli w panelu administracyjnym, jeśli twój plan je oferuje, a domyślne zachowanie pokaż w regule projektu (zobacz dokumentację Rules Cursora):

```markdown
Cost policy for agents in this repository:
- Stay on the team default model for feature work and review.
- Use the cheapest listed model for renames, formatting and single-file edits.
- Before switching to a more expensive model or a long-running cloud agent,
  state the reason in one sentence in the chat and link the task.
```

## Krok 4: ustaw budżety i alerty, które zawodzą bezpiecznie

Twarde blokady, które zadziałają w środku incydentu, uczą zespoły je omijać. Stawiaj na widoczność i alerty, a twarde limity ustawiaj tylko tam, gdzie niekontrolowany wydatek naprawdę zaszkodzi.

1. **Wyznaczaj budżety per zespół, nie per osobę.** Miesięczny budżet zespołu wyznacz na podstawie jednego miesiąca zmierzonych wydatków i bieżącego obciążenia zespołu. Rozdziel trzy pozycje: eksperymenty, utrzymanie produkcji i reagowanie na incydenty. Incydent nigdy nie może trafić na limit.

2. **Alarmuj przed każdym limitem.** Powiadom tech leada przy 75% budżetu i engineering managera przy 90%. W Claude Code ustaw alert na `claude_code.cost.usage` zsumowanym po `team.id` w kroczącym oknie w twoim backendzie metryk.

3. **Twarde limity ustaw jako zabezpieczenie.** Limit organizacji lub workspace’u ustaw na 150–200% normalnego miesiąca, żeby zadziałał tylko przy anomalii, na przykład zapętlonej automatyzacji. Limity per członek w **Admin settings > Usage** stosuj dla podwykonawców i kont próbnych.

4. **Ogranicz każde uruchomienie bez nadzoru.** Każde zadanie CI powinno mieć własny sufit, na przykład `claude -p --max-budget-usd 5 "Review this diff for injection risks"`. Uruchomienie z limitem zatrzymuje się; upewnij się, że zadanie zgłasza zatrzymanie i zachowuje częściowe wyniki jako artefakt.

5. **Alarmuj o koszcie bez efektu.** Oznaczaj sesje i pipeline’y z powtarzanymi nieudanymi próbami oraz wydatki bez żadnej scalonej zmiany w tym samym tygodniu. To sygnały zepsutego przepływu pracy, a nie intensywnego użytkownika.

Spisz politykę, żeby mechanizmy kontroli miały właściciela. Przyjmij ten szablon bez zmian i uzupełnij nawiasy:

```text
AI usage cost policy — [ORGANIZATION], version [N], owner: [NAME, ROLE]

1. Unit of decision: cost per accepted change (merged, not reverted within 30 days).
2. Budgets: per team, per month, in three lines — experimentation, production
   operation, incident response. Incident response has no hard cap.
3. Alerts: team lead at 75%, engineering manager at 90%. Org cap at 175% of the
   trailing three-month average, reviewed quarterly.
4. Models: tool defaults apply. Escalation to Claude Fable 5.1 or maximum effort
   needs a named task and is reviewed monthly. Subagents doing search, logs or
   tests run on the cheapest allowed model.
5. Attribution: team and cost center only; user.email is dropped or hashed in
   the collector. Developer-level data requires opt-in or a documented,
   reviewed purpose. Spend is never used to rate individuals.
6. Review: monthly spend review with finance; quarterly budget reallocation.
7. Evidence kept: allocation logic, currency, taxes, time window, and every
   estimated or missing data source, marked as such.
```

Szablon jest po angielsku, bo zwykle trafia do dokumentów współdzielonych z działem finansów i dostawcami; przetłumacz go, jeśli twoja organizacja prowadzi polityki po polsku.

## Prompty do przeglądu kosztów

Uruchamiaj je w Claude Code, Codex lub Cursorze, dołączając eksport raportu wydatków lub wynik zapytania do telemetrii. We wszystkich trzech narzędziach działają tak samo.

**Prompt do skopiowania: miesięczny przegląd wydatków i routingu**

```text
Attached: last month's AI usage export (cost by team, model and day) and the
list of merged pull requests per team. Act as a FinOps reviewer.
1. Rank teams by cost per merged pull request, not by total spend.
2. Find spend on the most expensive model tier or maximum effort for work that
   the team's default model handles (renames, formatting, small fixes).
   Quantify it.
3. Find sessions where cache-read tokens are low relative to input tokens,
   which suggests context was reloaded instead of reused.
4. Recommend three routing or effort changes, each with its estimated monthly
   saving, the quality risk, and how we would detect that risk.
Show your arithmetic. Mark every figure that is an estimate. Do not recommend
changes that would slow incident response.
```

**Prompt do skopiowania: analiza kosztów odstających**

```text
Attached: per-team and per-workflow AI cost for the last 90 days, with task
class (bug fix, feature, migration, review, incident) and outcome (merged,
reverted, abandoned).
Analyze the outliers. For each one, classify it as: useful expensive work,
repeated failure, waiting cost, or allocation error, and name the evidence.
Do not infer any individual's productivity from spend. Finish with the two
workflow changes that would remove the most repeated-failure spend.
```

**Prompt do skopiowania: pełny koszt jednego przepływu pracy**

```text
Define the total incremental cost of our "agent opens a pull request from a
ticket" workflow for last month. Include licenses, model usage, CI minutes,
platform and integration work, human review time, rework, failed attempts and
incidents. For each line, name the data source, the allocation rule and the
confidence. List the data gaps explicitly instead of filling them with zero or
false per-person precision.
```

**Prompt do skopiowania: projekt alertu budżetowego**

```text
Propose a budget alert for the payments team's Claude Code usage. Specify the
owner, the metric and query (claude_code.cost.usage by team.id), the
threshold, what happens when it fires, how a hard cap fails safely without
losing in-progress work, what evidence is retained, and who decides after it
fires. Explain how pairing cost with accepted changes and reverts prevents
cost-only optimization.
```

Developerzy mogą stosować tę samą dyscyplinę w każdej sesji. Czyszczenie kontekstu między niepowiązanymi zadaniami, delegowanie rozwlekłej pracy do subagentów i zawężanie zestawu plików opisuje strona o [koszcie kontekstu](/pl/workflows/context/cost-per-context/).

## Jak udowodnić, że kontrola kosztów działa?

Wydatków nie weryfikujesz, czytając sesje. Weryfikujesz je testami, które głośno zawodzą, gdy mechanizm kontroli się psuje, i każdy z nich ma właściciela:

- **Co miesiąc uzgadniaj dane z fakturą.** Porównaj sumę `claude_code.cost.usage` i raporty wydatków dostawców z fakturą. Gdy działa `modelPricing`, `/usage` oznacza sumę sesji dopiskiem „at your organization's configured rates”; każda różnica ponad uzgodnioną tolerancję to błąd danych do poprawienia przed przeglądem. Właściciel: partner FinOps.
- **Co kwartał przeprowadź ćwiczenie alarmowe.** Obniż próg jednego zespołu poniżej bieżących wydatków i potwierdź, że wiadomość dociera na kanał. Alert, który nigdy nie zadziałał, jest nieprzetestowany. Właściciel: zespół platformowy.
- **Sprawdzaj pokrycie telemetrią.** Policz unikalne (anonimowe) wartości `user.id` raportujące `claude_code.session.count` i porównaj je z liczbą licencji; ta kontrola działa bez identyfikacji po adresie e-mail. `user.id` jest przypisany do instalacji, więc traktuj to porównanie jako przybliżone: mniej identyfikatorów niż aktywnych licencji to sygnał do sprawdzenia, bo oznacza, że ktoś pracuje bez managed settings.
- **Zestawiaj każdy widok kosztów z jakością.** Przeglądaj koszt obok czasu realizacji zaakceptowanych zmian, revertów, defektów, które uciekły na produkcję, i obciążenia review z [panelu metryk AI](/pl/cto-scorecard-guide/ai-metrics-panel/). Oszczędność, która zwiększa liczbę revertów, nie jest oszczędnością.
- **Każdą sumę da się prześledzić do źródła.** Dashboard musi prowadzić od sumy zespołu do eksportu źródłowego i decyzji, którą uzasadnił. Brakujące i szacowane dane pozostają widoczne, nigdy nie są po cichu zerami.

Comiesięczny przegląd przeprowadzaj w tej kolejności:

1. Pobierz eksport za miesiąc: sumy OpenTelemetry per zespół i raporty wydatków każdego dostawcy.
2. Uzgodnij sumy z fakturą i zapisz każdą różnicę ponad tolerancję jako błąd danych.
3. Uruchom prompt miesięcznego przeglądu wydatków i routingu na uzgodnionych danych.
4. Uruchom prompt analizy wartości odstających na najdroższych sesjach i przepływach pracy.
5. Sprawdź każdą zmianę kosztów względem metryk jakości tych samych zespołów.
6. Zapisz decyzje (zmiany ustawień domyślnych, przesunięcia budżetu, poprawki) z właścicielem i datą.

Engineering manager zatwierdza miesięczne liczby swojego zespołu; CTO zatwierdza z działem finansów kwartalny podział budżetu.

## Co się psuje przy zarządzaniu wydatkami na AI?

- **Dashboardy są puste, a wydatki rosną.** Telemetrię ustawiono w `.claude/settings.json` repozytorium, które Claude Code ignoruje dla zmiennych eksportera, albo brakuje `CLAUDE_CODE_ENABLE_TELEMETRY`. Naprawa: dostarcz zmienne przez managed settings, a potem przetestuj na jednej maszynie z `OTEL_METRICS_EXPORTER=console` i `OTEL_METRIC_EXPORT_INTERVAL=10000`; punkt danych `claude_code.session.count` pojawi się po około dziesięciu sekundach.
- **Metryki nie docierają do kolektora.** Endpoint i protokół się nie zgadzają: gRPC zwykle nasłuchuje na porcie 4317, a HTTP na 4318. Naprawa: dopasuj `OTEL_EXPORTER_OTLP_PROTOCOL` do portu i przeszukaj wynik `claude --debug-file <path>` pod kątem `[3P telemetry]`.
- **Atrybucja zespołu wraca pusta.** Spacja lub cudzysłów w `OTEL_RESOURCE_ATTRIBUTES` unieważnia wartość. Naprawa: użyj podkreślników lub camelCase i wdróż ponownie.
- **Koszt z telemetrii nie zgadza się z fakturą.** Claude Code domyślnie raportuje ceny katalogowe, a zużycie w ramach limitu licencji nie jest wyceniane w dolarach. Naprawa: ustaw `modelPricing`, a zużycie limitu licencji zapisuj jako osobną pozycję.
- **Lista dozwolonych modeli przecieka przez Default.** Samo `availableModels` zostawia opcję Default na domyślnym modelu konta. Naprawa: dodaj `enforceAvailableModels: true` w tym samym źródle managed settings.
- **Rozgałęzienie na subagenty po cichu kosztuje stawki najdroższego modelu.** Subagenty dziedziczą model sesji. Naprawa: subagentom, które głównie czytają, ustaw `model: haiku`, a w planach subskrypcyjnych przeglądaj udział subagentów w zestawieniu `/usage`.
- **Uruchomienia Codex w CI nie pokazują metryk.** Naprawa: jeśli uruchomienia `codex exec` nie pokazują metryk w twoim kolektorze, traktuj wyjście `codex exec --json` z każdego uruchomienia jako zapis kosztu, dopóki metryki nie zaczną docierać.
- **Twardy limit zatrzymuje obsługę incydentu.** Naprawa: przenieś pracę incydentową do osobnej pozycji budżetu bez limitu i przeglądaj ją po incydencie, nie w jego trakcie.
- **Wydatki stają się miarą wydajności.** Wysokie wydatki mogą oznaczać wartościową trudną pracę albo powtarzane porażki; niskie mogą oznaczać efektywność albo brak adopcji. Naprawa: usuń rankingi osób ze wszystkich dashboardów i diagnozuj przepływy pracy.
- **Polityka wymienia modele z poprzedniego kwartału.** W samym wrześniu 2026 nowe modele wypuściły Anthropic (Fable 5.1, Opus 5.5), OpenAI (GPT-6), Google (Gemini 3.8 Flash) i xAI (Grok 4.7) (Gemini 3.8 Flash osiągnął ogólną dostępność 2026-09-02 według dziennika zmian Gemini API; xAI wymienia Grok 4.7 pod wrześniem w swoich notatkach o wydaniach; oba odczytane 2026-10-12). Naprawa: opatrz tabelę modeli datą, co miesiąc porównuj ją z [przeglądem modeli](/pl/ecosystem/models/) i przed zmianą ustawienia domyślnego ponownie uruchom ewaluacje.

**Zacznij od 30-dniowego pilotażu.** Wdróż plik managed settings w jednym zespole, ustaw alerty na 75% i 90%, raz uzgodnij dane z fakturą i uruchom prompt miesięcznego przeglądu. Dzięki temu masz prawdziwe liczby per zespół, zanim ustawisz budżety dla wszystkich. Jak zaprojektować pilotaż, który czegoś dowodzi, opisuje strona o [projektowaniu pilotażu](/pl/org/pilot-design/).

## Dokąd dalej w zarządzaniu kosztami

- [Koszt zaakceptowanej zmiany](/pl/strategy/economics/) — Metoda ROI i arkusz, które zasilają te mechanizmy kontroli.
- [Obserwowalność agentów](/pl/workflows/operate/agent-observability/) — Kolektor, dashboardy i retencja telemetrii z kroku 2.
- [Śledzenie kosztów agentów](/pl/ecosystem/observability/agent-cost-tracking/) — ccusage, /usage i budżety w bramkach LiteLLM i Claude apps gateway.
- [Polityka zarządzana](/pl/org/managed-policy/) — Jeden plik ustawień dystrybuowany i wersjonowany dla każdego agenta.
- [Panel metryk AI](/pl/cto-scorecard-guide/ai-metrics-panel/) — Zestaw koszt z zaakceptowanymi wynikami, przepływem i jakością.
- [Przegląd modeli](/pl/ecosystem/models/) — Aktualne ceny, okna kontekstu i modele domyślne.
