CodeBurn — lokalne CLI, które liczy wydatki na narzędzia AI

Rachunek za narzędzia AI w agencji ma jedną wspólną cechę niezależnie od dostawcy: mówi, ile. Nigdy nie mówi, na co. Nie dowiesz się z niego, że połowa kwoty poszła na rozmowę zamiast na kod, że drogi model spalił budżet na zadaniu, które tańszy zamknąłby w jednym podejściu, ani — co w naszej pracy najważniejsze — który klient i który projekt faktycznie wygenerował te koszty.

CodeBurn (github.com/getagentseal/codeburn) rozwiązuje to w sposób, który po zastanowieniu jest oczywisty, a jednak nikt tego wcześniej porządnie nie zrobił: nie pośredniczy w niczym, tylko czyta pliki sesji, które Twoje narzędzia i tak zapisują na dysku. Żadnego wrappera, proxy ani klucza API. Rozbija każdy token i każdego dolara na zadanie, model, narzędzie i projekt, dla 41 integracji.

To wpis o narzędziu, którego sam używam, żeby wiedzieć, ile kosztuje pisanie tej serii.

Stan projektu

Dane z API GitHuba i npm na 27 września 2026:

10 922 gwiazdki i 816 forków przy repozytorium założonym 13 kwietnia 2026 — pięć miesięcy. To jedno z najszybszych wejść, jakie widzieliśmy w tej serii,
38 728 pobrań z npm w ostatnim miesiącu — realne użycie, nie tylko gwiazdki,
TypeScript, licencja MIT, wersja 0.9.24 wydana 4 września, wydania średnio raz na tydzień,
ostatni push dzień przed napisaniem tego wpisu, 47 otwartych zgłoszeń — projekt jest w fazie intensywnego rozwoju i widać to po liście spraw,
wymaga Node.js 22.13+, a do dwóch dostawców (Zed, harness DeepSeeka) 22.15+ ze względu na wbudowaną obsługę zstd,
zaledwie dziesięć zależności produkcyjnych, wśród nich ink na interfejs terminalowy i @modelcontextprotocol/sdk na serwer MCP.

Uwaga porządkowa: repozytorium przeniosło się z AgentSeal/codeburn na getagentseal/codeburn, stary adres przekierowuje. Za projektem stoi AgentSeal, kod jest na MIT, a utrzymanie finansowane przez GitHub Sponsors — nie ma tu wersji płatnej ani funkcji za paywallem.

Jest natomiast jedna rzecz, o której warto wiedzieć, zanim wyślesz pull request. Projekt trzyma w CI workflow block-claude-coauthor.yml, który odrzuca PR-y zawierające w commitach trailer Co-authored-by: wskazujący na Claude'a albo Anthropic. Korzystanie z narzędzi AI przy pisaniu kodu jest dozwolone — sama atrybucja współautorstwa nie. Wspominam o tym, bo my w tym repozytorium takiego trailera używamy, więc kontrybucja do CodeBurna wymagałaby jego usunięcia przed zgłoszeniem.

Trzydzieści sekund do pierwszej liczby

Nie ma tu instalacji, konfiguracji ani logowania:

npx codeburn

Otwiera się interaktywny pulpit — domyślnie dzisiejszy dzień, a jeśli dziś nic jeszcze nie ma, ostatnie siedem dni. Strzałki przełączają okresy, q wychodzi. Dostępne są też trwała instalacja (npm install -g codeburn, brew install codeburn), aplikacja w pasku menu macOS i w zasobniku Windows (codeburn menubar), pulpit w przeglądarce (codeburn web na porcie 4747) oraz aplikacja desktopowa. Wszystkie czytają te same pliki z dysku — README ujmuje to jednym zdaniem: jedno źródło prawdy, każda powierzchnia czyta pliki sesji leżące już na Twoim dysku.

Najbardziej użyteczna komenda na start jest jednak nieinteraktywna:

codeburn overview                                    # ten miesiąc
codeburn overview --no-color                          # czysty tekst do wklejenia
codeburn overview --from 2026-06-01 --to 2026-06-15   # dowolny zakres
codeburn overview -p lifetime                         # cała historia

Wypisuje podsumowanie gotowe do wklejenia: sumy kosztu i tokenów, trafienia w cache, rozbicie po narzędziach i modelach, najdroższe dni, największe projekty i tabelę dzień po dniu. Kolory znikają automatycznie, gdy wyjście nie jest terminalem — więc codeburn overview | pbcopy daje tekst, który można wysłać zarządowi bez czyszczenia znaków sterujących.

Skąd biorą się liczby i gdzie są niepewne

Tu jest sedno konstrukcji i jednocześnie miejsce, w którym projekt zachowuje się uczciwiej niż większość narzędzi analitycznych. Każdy dostawca to jeden plik w src/providers/ — w repozytorium jest ich 46, co przy 41 integracjach oznacza kilka wspólnych parserów. Dokumentacja podaje dla każdego dokładną lokalizację danych, format i znane dziwactwa:

Claude Code — ~/.claude/projects/<ścieżka>/<sesja>.jsonl, gdzie każdy wpis asystenta nosi nazwę modelu, liczniki tokenów (wejście, wyjście, odczyt i zapis cache), bloki tool_use i znaczniki czasu. Obsługiwane jest też CLAUDE_CONFIG_DIRS, czyli kilka katalogów konfiguracyjnych scalanych w jeden wiersz na projekt — praktyczne, gdy oddzielasz konto firmowe od prywatnego,
Codex — ~/.codex/sessions/, zdarzenia token_count, koszt przypisywany po katalogu roboczym projektu,
Cursor — baza SQLite state.vscdb, czytana z własnego licznika kontekstu Cursora,
Zed — threads.db, gdzie blob jest skompresowanym zstd JSON-em z licznikami na żądanie; wątki są dociągane do dokładnego licznika kumulatywnego, żeby sumy zgadzały się z magazynem,
GitHub Copilot — pięć różnych źródeł, w tym magazyn OpenTelemetry agent-traces.db (preferowany, bo ma prawdziwe liczniki) oraz bazy Nitrite dla IDE JetBrains.

A teraz rzecz najważniejsza. Tam, gdzie liczników nie ma, CodeBurn mówi to wprost, zamiast udawać precyzję. Przy Cursorze dokumentacja pisze bez ogródek, że wyjście jest szacowane z długości odpowiedzi, tokeny cache są tylko serwerowe, więc liczby są oznaczone jako szacowane i zaniżają konsolę administracyjną Cursora przy długich rozmowach. Przy Kiro model nie jest w ogóle ujawniany, więc sesje są etykietowane kiro-auto i wyceniane po stawkach Sonneta. Przy Copilocie w części źródeł tokeny są szacowane z długości treści.

Do rozstrzygania takich wątpliwości są dwie komendy, które warto poznać zaraz po pierwszym uruchomieniu:

codeburn doctor                     # co zostało sprawdzone i czy się sparsowało
codeburn doctor --provider opencode # jeden dostawca
codeburn audit                      # skąd bierze się każda liczba, per model

doctor działa w pełni offline i tylko do odczytu — nie zapisuje nawet cache'u. Dla każdego dostawcy pokazuje sondowane katalogi wraz z ewentualnym nadpisaniem zmienną środowiskową, liczbę znalezionych sesji, ile z próbki sparsowało się czysto, i jednolinijkowy werdykt: OK, NOTHING FOUND z prawdopodobną przyczyną albo ERRORS z liczbą błędów parsowania. Dostawca, który wysypie się z wyjątkiem, jest raportowany jako własny wiersz błędu i nie wywraca reszty raportu.

Ceny pochodzą z LiteLLM, są odświeżane co 24 godziny i cache'owane w ~/.cache/codeburn/, ze wpisanymi na stałe wartościami awaryjnymi dla modeli Claude'a i GPT-5, żeby dopasowanie rozmyte nie wyceniło czegoś błędnie.

Kategorie zadań bez ani jednego wywołania modelu

Detal, który zasługuje na osobny akapit, bo idzie wbrew modzie. CodeBurn klasyfikuje każdą turę do jednej z 13 kategorii — kodowanie, debugowanie, rozwój funkcji, refaktoryzacja, testy, eksploracja, planowanie, delegowanie, operacje gitowe, build i wdrożenie, burza mózgów, rozmowa, ogólne — i robi to ze wzorców użycia narzędzi oraz słów kluczowych, całkowicie deterministycznie, bez ani jednego wywołania LLM-a.

Zasady są jawne i banalnie proste: narzędzia Edit i Write to kodowanie, pytest/vitest/jest w powłoce to testy, Read i Grep bez edycji to eksploracja, git push i git commit to operacje gitowe, brak narzędzi i czysta wymiana tekstu to rozmowa. Narzędzie liczące koszty AI, które samo nie generuje kosztów AI — to nie jest oczywiste, a powinno być.

Na tej klasyfikacji stoi metryka, która okazała się dla mnie najbardziej pouczająca w całym pulpicie: one-shot rate. Definicja jest precyzyjna i świadoma plików: ponowną próbą jest ponowna edycja tego samego pliku po komendzie powłoki w międzyczasie (Edit foo.ts, Bash, Edit foo.ts). Edytowanie różnych plików między krokami powłoki ponowną próbą nie jest. Kolumna pokazuje, jaki procent tur edycyjnych udał się bez powtórek — kodowanie na poziomie 90% znaczy, że model trafił od pierwszego razu w dziewięciu przypadkach na dziesięć. Śledzenie na poziomie plików działa dla Claude'a, Codeksa i Goose'a; pozostali dostawcy wracają do wykrywania po nazwach narzędzi.

Skaner marnotrawstwa

codeburn optimize                   # ostatnie 30 dni
codeburn optimize -p week           # ostatnie 7 dni
codeburn optimize --format json     # kondycja konfiguracji i znaleziska jako JSON

codeburn optimize przeszukuje dwie rzeczy: transkrypty sesji z wybranego okresu oraz Twoją konfigurację — ~/.claude.json, pliki settings.json użytkownika i projektu, .mcp.json, CLAUDE.md razem z rozwinięciem importów @, a także katalogi skills/, agents/ i commands/. Skan nic nie zapisuje. Zapisuje wyłącznie --apply.

Wzorce marnotrawstwa, których szuka, brzmią jak lista rzeczy, które każdy z nas robi i nie zauważa:

pliki czytane wielokrotnie między sesjami — ta sama treść, ten sam kontekst, w kółko,
niski stosunek odczytów do edycji — edytowanie bez czytania prowadzi do powtórek i spalonych tokenów,
zmarnowane wyjście powłoki — nieograniczone BASH_MAX_OUTPUT_LENGTH i szum na końcu wyjścia,
nieużywane serwery MCP, które w każdej sesji płacą pełny koszt schematów swoich narzędzi,
widmowi agenci, skille i komendy zdefiniowane w ~/.claude/ i nigdy nie wywołane,
przerośnięte pliki CLAUDE.md, z policzonym rozwinięciem importów,
sesje ciężkie kontekstowo, w których tokeny wejścia i cache'u przytłaczają wyjście, oraz drogie sesje bez ani jednej tury edycyjnej.

Znaleziska trafiają do trzech klas i to podział, który sam w sobie jest dobrym pomysłem projektowym: Fix now (CodeBurn może to zmienić za Ciebie), Habits (nie ma czego edytować — zmienia się sposób, w jaki prowadzisz następną sesję) i FYI (informacyjne, koszt może być uzasadniony, decyzja Twoja). Detektor może zresztą raz zwrócić klasę pierwszą, a raz drugą: nadpisanie ENABLE_TOOL_SEARCH w pliku ustawień da się poprawić automatycznie, to samo nadpisanie w profilu powłoki — już nie.

Do tego każde znalezisko nosi basis, czyli informację, skąd wzięła się liczba oszczędności: measured znaczy zsumowane z liczników dostawcy na Twoich własnych wywołaniach, estimated — wyliczone z modelu, na przykład z rozmiaru schematu narzędzia albo kosztu linii CLAUDE.md. Nagłówek podaje wprost proporcję: „N measured · M estimated". Detektor mieszający liczniki z modelem liczy się jako szacowany. Całość rolowana jest do oceny kondycji konfiguracji w skali od A do F.

Naprawa, która sama się rozlicza

Ta część jest w moim odczuciu najlepszym elementem projektu i wzorcem dla każdego narzędzia obiecującego oszczędności.

codeburn optimize --apply             # przejrzyj i zastosuj interaktywnie
codeburn optimize --apply --dry-run   # wypisz plan, nie zmieniaj nic
codeburn act list                     # każda zmiana, jaką CodeBurn wprowadził
codeburn act undo --last              # cofnij ostatnią
codeburn act report                   # zrealizowane kontra obiecane oszczędności

--apply buduje plan dla każdego znaleziska, pokazuje dokładne pliki, których dotknie, i pyta przed zapisem. Każdy zapis jest wcześniej zbackupowany i zapisany w dzienniku, a codeburn act undo <id> przywraca oryginały — i odmawia, jeśli pliki zmieniły się po zastosowaniu, chyba że wymusisz to flagą --force.

Najciekawsze jest jednak zamknięcie pętli. Zastosowanie poprawki jest obietnicą, więc CodeBurn ją weryfikuje. Kiedy poprawka ma co najmniej trzy dni, każdy kolejny przebieg optimize wypisuje ją w sekcji „Applied fixes" z jednolinijkowym werdyktem:

zadziałało — w Twoich sesjach pojawiło się co najmniej 70% obiecanej redukcji,
częściowo — pomogło, ale poniżej szacunku, z podaną różnicą procentową,
nie pomogło — żadnej mierzalnej redukcji, razem z gotową komendą cofnięcia,
mierzę — za młode albo zmiana nie zadziałała jeszcze w żadnej sesji.

Szacunek jest przy tym przeskalowany do zmierzonego okna, żeby obie liczby były porównywalne, i pochodzi z tej samej rekoncyliacji, którą wypisuje codeburn act report — jest jeden zestaw liczb, nie dwa. Czego nie da się zmierzyć, zostaje na linii „mierzę" z podaną przyczyną, nigdy jako deklarowana oszczędność. Flaga --auto-revert cofa dokładnie te poprawki, których werdykt to „nie pomogło".

Narzędzie, które po trzech dniach samo przychodzi i mówi „ta moja rada nic nie dała, oto komenda cofnięcia", jest rzadkością wartą naśladowania. Standardem w tej kategorii jest pokazanie szacunku oszczędności raz, na wejściu, i nigdy więcej.

Jest tu też jedna bardzo przytomna barierka. --apply --yes pomija pytanie dla każdego planu z wyjątkiem bloków reguł w CLAUDE.md — bo te lądują w pliku katalogu, w którym akurat stoisz, więc hurtowe --yes z przypadkowego miejsca wpisałoby porady do niewłaściwego projektu. Żeby zastosować taką poprawkę, trzeba wskazać ją jawnie: codeburn optimize --apply --only read-edit-ratio.

Limity budżetu wpięte w hooki

codeburn guard install            # do .claude/settings.json tego projektu
codeburn guard install --global    # albo do ~/.claude/settings.json
codeburn guard status             # limity, miejsca instalacji, oflagowane projekty
codeburn guard uninstall          # usuwa czysto, Twoich hooków nie rusza

guard instaluje w Claude Code opcjonalne hooki pilnujące kosztu sesji w trakcie pracy: miękki limit (domyślnie 5 USD) daje jednorazowe ostrzeżenie w sesji, twardy limit (15 USD) zatrzymuje sesję, a codeburn guard allow podnosi go tylko dla niej. Punkt kontrolny (3 USD) działa inaczej i ciekawiej: jeśli sesja kończy się powyżej tej kwoty bez edycji i bez commitów, dostajesz sugestię, żeby zacząć od nowa z nazwanym rezultatem.

Limity edytuje się w ~/.config/codeburn/guard.json, ustawienie wartości na null wyłącza dany próg, a --statusline dorzuca koszt sesji do linii statusu Claude Code. Instalacje przechodzą przez ten sam dziennik co wszystko inne, więc codeburn act undo usuwa i je. I detal, który decyduje o tym, czy to się da wdrożyć w zespole: hooki zawodzą otwarcie — zepsuty guard nigdy nie blokuje sesji.

Czy te wydatki cokolwiek dowiozły

codeburn yield                  # ostatnie 7 dni
codeburn yield -p month         # ten miesiąc kalendarzowy
codeburn yield --format json    # rozbicie jako JSON

codeburn yield koreluje sesje AI z commitami w gicie po znacznikach czasu i dzieli wydatki na cztery kategorie: produktywne (commity z tej sesji weszły do głównej gałęzi), wycofane (commity zostały później zrewertowane), zarzucone (brak commitów w okolicy sesji albo commity nigdy nie zmergowane) i niejednoznaczne (sesja biegła równolegle do innej, a commity z jej okna przypisano tej z ciaśniejszym oknem).

I znowu uczciwość metodologiczna: przypisanie jest heurystyką po oknie czasowym, każdy commit trafia do najwyżej jednej sesji — tej z najciaśniejszym oknem go obejmującym — a raport JSON nosi pole methodology: "timestamp-window". Nie „AI ROI", nie „attribution engine". Heurystyka nazwana heurystyką, z metodologią wpisaną w dane wyjściowe.

Pytanie o koszty w środku rozmowy

claude mcp add codeburn -- npx -y codeburn mcp

codeburn mcp uruchamia lokalny serwer MCP po stdio, więc Claude Code, Cursor albo dowolny klient MCP może w trakcie pracy zapytać, gdzie poszły tokeny w tym tygodniu. Wystawia dwa narzędzia: get_usage (wydatki i użycie z rozbiciem po narzędziach, modelach, projektach i zadaniach — szybkie) oraz get_savings (redukcje kosztów: znaleziska marnotrawstwa, podatek od powtórek, marnotrawstwo routingu — głębsza i wolniejsza analiza).

Dobra decyzja domyślna: nazwy projektów są pseudonimizowane, a agent widzi prawdziwe tylko wtedy, gdy jawnie poprosi parametrem include_project_names: true. Wszystko czytane z lokalnego dysku, tak samo jak w CLI.

Pułapki

Wersja 0.9.x, 47 otwartych zgłoszeń i wydania co tydzień. Narzędzie diagnostyczne, nie fundament procesu rozliczeń,
Liczby dla Cursora są zaniżone względem jego konsoli administracyjnej przy długich rozmowach, a dla Kiro model nie jest znany i wszystko wycenia się po stawkach Sonneta. Oznaczenia „estimated" trzeba czytać, a nie pomijać,
Modele pokazujące 0,00 USD to zwykle nazwa nierozpoznana przez LiteLLM. Rozwiązania są trzy i łatwo je pomylić: model-alias mapuje nazwę na znaną, price-override ustawia własne stawki, a model-flat-rate oznacza SKU rozliczane abonamentowo, dla którego zero jest poprawne — aliasowanie takich identyfikatorów wymyśla wydatki, których nie było,
CLI nie wysyła nic — ale aplikacja desktopowa i zasobnik Windows mogą wysłać anonimowy raport, po decyzji na ekranie zgody przy pierwszym uruchomieniu. Domyślnie wyłączony w UE, EOG, Wielkiej Brytanii i Szwajcarii oraz gdy region jest nieznany, włączony poza nimi. Każda wielkość w raporcie jest przedziałem, nigdy dokładną liczbą, a wyłączenie czyści kolejkę i generuje nowy identyfikator instalacji, żeby dawnych i przyszłych raportów nie dało się powiązać. Nazwy używanych modeli, narzędzi, skilli i serwerów MCP są zbierane — prompty, kod, nazwy plików i projektów, dokładne kwoty i godziny nie,
codeburn sync (telemetria zespołowa) jest w wersji zapoznawczej i protokół może się zmienić między wydaniami. Wysyła liczniki tokenów, koszty, modele i projekty — nigdy promptów ani kodu,
Instalatory na Windows i desktopowy .exe to podglądy deweloperskie, niepodpisane, więc SmartScreen protestuje przy pierwszym uruchomieniu i same się nie aktualizują. Zalecana droga to Microsoft Store, gdzie paczka jest podpisywana przy zgłoszeniu,
Zed i harness DeepSeeka wymagają Node 22.15+ ze względu na wbudowane zstd,
Cursor i OpenCode dociągają better-sqlite3, a pierwszy przebieg na dużej bazie Cursora może zająć minutę,
yield wymaga repozytorium gita i uruchomienia z katalogu projektu,
i pułapka wpisana w samą konstrukcję: CodeBurn czyta prywatne formaty cudzych narzędzi. Kiedy Cursor przebuduje bazę albo Claude przeniesie ścieżkę konfiguracji, liczby przestają się zgadzać do momentu wydania łatki. README mówi to zresztą wprost, uzasadniając prośbę o sponsoring: utrzymanie 41 integracji w zgodzie z rzeczywistością to stała praca.

Gdzie to ma sens w naszej pracy

Cztery zastosowania, które sprawdziły się u nas:

Przypisanie kosztów do projektu i klienta. Rozbicie po projektach plus --project i --exclude na każdej komendzie daje liczbę, którą można wstawić do rozliczenia albo do decyzji o wycenie następnego zlecenia. Faktura dostawcy takiej liczby nie da nigdy,
Decyzja o domyślnym modelu. codeburn compare zestawia modele na Twojej pracy: one-shot rate, odsetek powtórek, samokorekta, koszt na wywołanie i na turę edycyjną, trafienia w cache. To jest odpowiedź na pytanie „czy tańszy model wystarczy do naszych zadań" oparta na naszych zadaniach, nie na benchmarkach,
Sprzątanie konfiguracji. Nieużywane serwery MCP i widmowe skille kosztują w każdej sesji, a nikt ich nie zauważa, bo koszt jest rozsmarowany. Jeden przebieg optimize pokazuje je z liczbami,
Limity dla świeżych osób w zespole. guard install z miękkim limitem i punktem kontrolnym uczy prowadzenia sesji lepiej niż rozmowa o dobrych praktykach — bo mówi w momencie, w którym koszt narasta.

Czego CodeBurn nie zastępuje: konsoli rozliczeniowej dostawcy. To jest narzędzie diagnostyczne mierzone własnymi parserami cudzych plików, a nie źródło prawdy o fakturze. Do rozliczeń bierzemy fakturę; do zrozumienia, co się na niej znalazło i jak zmniejszyć następną — CodeBurna.

Podsumowanie

Rzadko trafia się narzędzie, które w kategorii „pokażę ci, jak oszczędzić" zachowuje się uczciwiej niż trzeba. Co warto zapamiętać:

npx codeburn nie wymaga niczego — ani instalacji, ani klucza, ani zgody. Czyta pliki, które Twoje narzędzia już zapisały,
41 integracji, każda jako jeden plik dostawcy z udokumentowaną lokalizacją danych i znanymi dziwactwami,
Czytaj oznaczenia „measured" i „estimated" — projekt sam wskazuje, gdzie liczy, a gdzie modeluje,
13 kategorii zadań klasyfikowanych deterministycznie, bez ani jednego wywołania LLM-a. Narzędzie do liczenia kosztów AI, które samo ich nie generuje,
One-shot rate jest zdefiniowany świadomie plików, nie zgadywany z liczby narzędzi w turze,
optimize nic nie zapisuje, zapisuje tylko --apply — z backupem, dziennikiem i cofnięciem, które odmawia przy zmienionych plikach,
Po trzech dniach narzędzie samo rozlicza swoje obietnice i przy braku efektu podaje komendę cofnięcia. To wzorzec, nie ozdoba,
guard zawodzi otwarcie — zepsuty limit nigdy nie zablokuje pracy,
yield nazywa swoją heurystykę heurystyką i wpisuje metodologię do JSON-a,
Serwer MCP pseudonimizuje nazwy projektów domyślnie,
CLI nie wysyła nic; aplikacje desktopowe pytają, a w UE domyślnie mają telemetrię wyłączoną,
PR-y z trailerem współautorstwa Claude'a są w tym projekcie odrzucane przez CI — samo używanie AI przy pisaniu kodu jest dozwolone.

Licencja: CodeBurn jest na MIT i to najprostszy możliwy przypadek — wolno używać komercyjnie, modyfikować, wpinać we własne procesy i redystrybuować, przy zachowaniu noty licencyjnej. Nie ma tu wersji płatnej, funkcji za paywallem ani open core: całość CLI, aplikacje desktopowe, aplikacja w pasku menu, rozszerzenie GNOME i serwer MCP są w tym samym repozytorium na tej samej licencji, a utrzymanie finansuje GitHub Sponsors. Warto natomiast rozdzielić dwie rzeczy, które w takich narzędziach zwykle się zlewają: licencja mówi o kodzie, a nie o danych — i tu polityka jest wyłożona osobno oraz precyzyjnie. CLI nie wysyła nic i nie ma czego wyłączać; aplikacje z interfejsem graficznym pytają o zgodę przy pierwszym uruchomieniu, w UE, EOG, Wielkiej Brytanii i Szwajcarii domyślnie z telemetrią wyłączoną, wysyłają wyłącznie przedziały wielkości i nazwy używanych narzędzi, a nigdy promptów, kodu, nazw plików, projektów ani dokładnych kwot. Dla agencji przetwarzającej cudzy kod to rozgraniczenie jest ważniejsze od samej licencji — i dobrze, że nie trzeba go rekonstruować z kodu, bo jest opisane w README wraz z pełną tabelą pól. Osobna uwaga na koniec: codeburn sync, czyli telemetria zespołowa wysyłana pod własny endpoint, jest w wersji zapoznawczej i jej protokół może się zmienić między wydaniami — do wdrożenia w zespole warto poczekać na stabilizację.