DEV Community: AgentGuard

Meine Claude-Code-Quota ist zweimal pro Woche gestorben. Ich habe ein Forensik-Tool geschrieben, um herauszufinden, warum.

AgentGuard — Tue, 15 Sep 2026 03:14:05 +0000

Meine Claude-Code-Quota verbrennt schnell — und die Zähler haben es nie erklärt. Sie beantworten wie viel. Nicht wo, nicht
warum.

Also habe ich ein Skript auf meine lokalen Session-Transkripte (~/.claude/projects/**/*.jsonl) losgelassen und angefangen    
zu graben. Daraus ist ein Tool geworden: quota-autopsy.                                                                      

Also habe ich ein Skript auf meine lokalen Session-Transkripte (~/.claude/projects/**/*.jsonl) losgelassen und angefangen    
zu graben. Daraus ist ein Tool geworden: quota-autopsy.                                                                      

Was die Daten wirklich zeigten (46 meiner Sessions)                                                                          

• 1.162 eindeutige API-Calls, 276,58M Tokens ≈ $187,80                                                                       
• ≈ $10,47 waren vermeidbar — genau diese Zahl sagen dir Zähler nie                                                          
• 4 warme Kontexte ungecacht neu gesendet (≈ $3,39), wiederholte Datei-Reads (≈ $2,39), überdimensionierte Tool-Outputs (≈   
$4,69)                                                                                                                       
• Eine Session hat nach 15 Stunden Pause 610,5k frische Tokens neu gesendet — $3,08 fürs reine Nichtstun                     

Die Muster, die es findet                                                                                                    

1. Cache-Re-Creates — das gecachte Präfix wird neu geschrieben, obwohl es noch frisch ist. Ein Cache-Bust kostet das         
12,5-Fache eines Cache-Hits — und Claude Code macht es lautlos.                                                              
2. Warme Re-Sends — ein Call liest null aus dem Cache, Sekunden nach einem Full-Context-Call.                                
3. TTL-Downgrades — Cache-Writes kippen mitten in der Session von 1 h auf 5 min.                                             
4. Bezahlter Bloat — 600KB-Terminal-Dumps, die jede weitere Runde den Kontext aufblähen.                                     
5. Doppelzählung durch Session-Splits — Dedupe per message.id hat 3.600 Duplikat-Zeilen kollabiert; naive Parser lägen ~40    
% daneben.                                                                                                                   

Warum ich den Zahlen vertraue                                                  

• Token-Zahlen exakt (Streaming-Teile per API-Response-ID dedupliziert)                                                      
• Dollar-Schätzungen gegen Claude Codes eigene cost-state-Einträge gegengeprüft                                              
• Unabhängige zweite Implementierung rechnet jede Metrik nach (45/45 Tests grün)                                             
• Zu 100 % lokal — null Dependencies, keine Telemetrie, kein Account                                                         

Ausprobieren                                                                                                                 

  ─ bash                                                                                                                
  npx quota-autopsy                                                                                                          

Kostenloser Überblick für alle. Pro ($24, lebenslang) schaltet die Session-Autopsie frei — jeder Befund mit exaktem Turn     
und Fixes. Model-agnostisch (editierbare Preis-Tabelle für jeden Provider).                                                  

Website: https://quota-autopsy.pro — Fragen beantworte ich gern in den Kommentaren.

My Claude Code quota died twice a week. I wrote a forensics tool to find out why.

AgentGuard — Tue, 15 Sep 2026 03:12:05 +0000

I burn through Claude Code quota fast — and the counters never explained it. They answer how much. Not where, not why.

So I pointed a script at my local session transcripts (~/.claude/projects/**/*.jsonl) and started digging. Then I turned it
into a tool: quota-autopsy.                                                                                                  

What the data actually showed (46 of my sessions)                                                                            

• 1,162 unique API calls, 276.58M tokens ≈ $187.80
• ≈ $10.47 was avoidable — that's the number counters never tell you                                                         
• 4 warm contexts re-sent uncached (≈ $3.39), repeated file reads (≈ $2.39), oversized tool outputs (≈ $4.69)
• One session re-sent 610.5k fresh tokens after a 15h idle gap — $3.08 for doing literally nothing                           

The mechanisms it finds                                                                                                      

1. Cache re-creates — the cached prefix gets rewritten while still fresh. A cache read costs 0.1×, a cache write 1.25×. A  
cache-bust costs 12.5× a cache hit, and Claude Code does it silently.
2. Warm re-sends — a call reading zero from cache, seconds after a full-context call. Two full-context bills back-to-back.   
3. TTL downgrades — cache writes shifting from 1h to 5m mid-session (the documented post-quota penalty).                     
4. Paid bloat — 600KB terminal dumps and screenshots re-inflating context on every later turn.                               
5. Session-split double counting — dedupe by message.id collapsed 3,600 duplicate rows in my corpus. Naive parsers           
over-count by ~40%.                                                                                                          

Why I trust the numbers                                                                                                      

• Token counts exact (streaming partials deduped by API response id)
• Dollar estimates cross-checked against Claude Code's own cost-state rows                                                   
• Independent second implementation recomputes every metric (45/45 tests green)
• 100% local — zero dependencies, no telemetry, no account                                                                   

Try it                                                                                                                       

  ─ bash           
  npx quota-autopsy                                                                                                          

Free overview for everyone. Pro ($24, lifetime) unlocks the per-session autopsy with exact turns and fixes. Model-agnostic
(editable pricing table for any provider/router).                                                                            

Website: https://quota-autopsy.pro — happy to answer questions in the comments.

AgentGuard Update: Open Core, Break-Glass Governance — and the First Real-World Finds

AgentGuard — Wed, 09 Sep 2026 19:54:24 +0000

When I posted the launch here on dev.to, the pitch was simple: I attacked my own repo — and my own PR bot blocked the attack before merge. A lot has moved since then. Here's the honest update, including the uncomfortable parts.

1. Open-Core Split: The Line Is Now Public

AgentGuard has been two clearly separated parts since this week:

Public (MIT): the deterministic engine with 12 rule classes and the free GitHub Action — 59 tests, every one of them publicly traceable.
Private: the Pro components — GitHub App server with check-run gate, multi-tenant, rules editor, re-sharpening, and billing — 26 more tests.

Why the split? Because a CI gate for coding agents is either a hobby or a product. I chose the latter. The community loses nothing: the engine stays MIT, the Action stays free for public repos. The line is documented in LICENSING.md — in plain text, not fine print.

2. Break-Glass Governance: Exceptions That Can't Hide

Every honest security policy needs exceptions. The naive version is the permanent bypass: switch it off once, it stays off forever. Our answer in v0.2.2:

A waiver is an issue — an immutable record of who exempted what, and when.
Mandatory reviewer, max. 30 days lifetime, automatic expiry.
A guardian workflow runs weekly, comments on expired exceptions, and files a warning issue.

And here's the part that matters to me: we don't claim the expiry works — we demonstrate it publicly. A test waiver (#13) runs in our own repo and expires automatically on 16 Sep 2026. The guardian run after that documents it publicly: commented, warned, closed. That's the difference between a policy on paper and one that proves itself. For your own repo: break-glass policy, ADR-002, workflow template.

3. 85 Tests, Self-Scan in Our Own CI

The full suite has grown to 85 tests: 59 in the public engine repo, 26 in the Pro repo. Still deterministic, still no LLM in the scan path. And still dogfooding: the scan of our own repo runs in our own CI — every landing page change has to pass our own gate first. That exact setup has already blocked one of our own PRs. Working as designed; it's all in the changelog.

4. The First Real-World Finds

Two active open-source repos, two invisible characters:

A zero-width space (U+200B) directly before a bash block in an agent-facing spec.
A U+200B in the middle of a skill spec.

Invisible in every diff and every review — but a different file for the model than for the human reading it. That's the documented invisibility trick, not a theoretical scenario. Both finds are byte-verified and were responsibly disclosed to the maintainers — with no public naming. If the maintainers want, there will be an update here.

5. What Pro Does — and What It Costs

App server: PR comment + check-run gate per repo, multi-tenant.
Rules editor: your own rules as a file, fail-closed.
Re-sharpening: generate new rules from real findings.
Billing: Stripe checkout, fully wired.

Prices unchanged: Free, Pro $19/repo/month, Audit $499 (one-time), RedTeam $499/quarter.

Try It

🛒 Free Action on the Marketplace
🔴 Live demo: planted attack, red check, no merge
🌐 Landing page
📝 Free first scan / Pro trial
📦 Code

AgentGuard Update: Open Core, Break-Glass-Governance — und die ersten echten Funde

AgentGuard — Wed, 09 Sep 2026 19:52:54 +0000

Beim Launch hier auf dev.to war der Pitch einfach: Ich habe mein eigenes Repo angegriffen — und mein eigener PR-Bot hat den Angriff vor dem Merge geblockt. Seitdem ist einiges passiert. Das ehrliche Update, inklusive der unbequemen Teile.

1. Open-Core-Split: Die Grenze ist öffentlich sichtbar

AgentGuard besteht seit dieser Woche aus zwei klar getrennten Teilen:

Öffentlich (MIT): die deterministische Engine mit 12 Regelklassen und die Free GitHub Action — 59 Tests, jeder einzelne öffentlich nachvollziehbar.
Privat: die Pro-Komponenten — GitHub-App-Server mit Check-Run-Gate, Multi-Tenant, Regel-Editor, Re-Sharpening und Billing — 26 weitere Tests.

Warum der Split? Weil ein CI-Gate für Coding-Agents entweder ein Hobby ist oder ein Produkt. Ich habe mich für Letzteres entschieden. Die Community verliert dabei nichts: Die Engine bleibt MIT, die Action bleibt kostenlos für öffentliche Repos. Die Trennlinie steht in LICENSING.md — bewusst im Klartext, nicht im Kleingedruckten.

2. Break-Glass-Governance: Ausnahmen, die sich nicht verstecken können

Jede ehrliche Security-Policy braucht Ausnahmen. Die naive Variante ist der Dauer-Bypass: einmal aus, für immer aus. Unsere Antwort in v0.2.2:

Ein Waiver ist ein Issue — ein unveränderlicher Beleg, wer wann was ausgenommen hat.
Pflicht-Reviewer, max. 30 Tage Laufzeit, automatischer Ablauf.
Ein Guardian-Workflow läuft wöchentlich, kommentiert abgelaufene Ausnahmen und erstellt ein Warn-Issue.

Und jetzt der Teil, der mir wichtig ist: Wir behaupten den Ablauf nicht — wir führen ihn öffentlich vor. In unserem eigenen Repo läuft ein Test-Waiver (#13), der am 16.09.2026 automatisch verfällt. Der Guardian-Lauf danach dokumentiert öffentlich: kommentiert, gewarnt, geschlossen. Das ist der Unterschied zwischen einer Policy auf Papier und einer, die sich selbst beweist. Für dein eigenes Repo: Break-Glass-Policy, ADR-002, Workflow-Template.

3. 85 Tests, Self-Scan in der eigenen CI

Die Gesamtsuite ist auf 85 Tests gewachsen: 59 im öffentlichen Engine-Repo, 26 im Pro-Repo. Weiterhin deterministisch, weiterhin kein LLM im Scan-Pfad. Und weiterhin Dogfooding: Der Scan unseres eigenen Repos läuft in unserer eigenen CI — jede Landingpage-Änderung muss zuerst am eigenen Gate vorbei. Genau das hat uns schon einmal den eigenen PR geblockt. Funktioniert wie designed, steht im Changelog.

4. Die ersten echten Funde

Zwei aktive Open-Source-Repos, zwei unsichtbare Zeichen:

Ein Zero-Width Space (U+200B) direkt vor einem Bash-Block in einer agent-gelesenen Spec.
Ein U+200B mitten in einer Skill-Spec.

Unsichtbar in jedem Diff und in jedem Review — aber für das Modell eine andere Datei als für den Menschen. Das ist der dokumentierte Unsichtbarkeits-Trick, kein theoretisches Szenario. Beide Funde sind byte-verifiziert und wurden verantwortungsvoll an die Maintainer gemeldet — ohne öffentliche Namensnennung. Falls die Maintainer es wünschen, gibt es hier ein Update.

5. Was Pro kann — und was es kostet

App-Server: PR-Kommentar + Check-Run-Gate pro Repo, Multi-Tenant.
Regel-Editor: eigene Regeln als Datei, fail-closed.
Re-Sharpening: aus echten Befunden neue Regeln generieren.
Billing: Stripe-Checkout, fertig verdrahtet.

Preise unverändert: Free, Pro $19/Repo/Monat, Audit $499 (einmalig), RedTeam $499/Quartal.

Probier es aus

🛒 Free Action im Marketplace
🔴 Live-Demo: gepflanzter Angriff, roter Check, kein Merge
🌐 Landingpage
📝 Kostenloser Erst-Scan / Pro-Trial
📦 Code

Ich habe mein eigenes Repo angegriffen — mein PR-Bot hat den Angriff selbst blockiert

AgentGuard — Wed, 09 Sep 2026 03:03:26 +0000

Coding-Agents sind die neue Benchmark für Dev-Teams: Claude Code, Cursor, Codex & Co. lesen dein Repo — und vertrauen ihm. Ich habe mich gefragt: Was passiert, wenn jemand eine Anweisung ins Repo schmuggelt, die der Agent bereitwillig ausführt?

Also habe ich AgentGuard gebaut — ein CI-Gate für Agent-Konfigurationen (AGENTS.md, Skills, MCP-Server, Hooks). Und ich habe mein eigenes Repo mit 12 gezielten Angriffen bestückt. Das ehrliche Protokoll:

1. Die Angriffe waren leicht zu verstecken

12 Payloads: eine versteckte Instruction-Override-Anweisung in der AGENTS.md, unsichtbare Zero-Width-Zeichen in einer Skill-Datei, ein typ-squatted MCP-Server-Host, ein Hook, der Netzwerk-Inhalt in eine Shell piped, ein committeter API-Key, ein Agent mit wildem Bash-Zugriff … Jeder davon wirkt in einem PR-Review völlig normal.

AgentGuard erkennt alle 12 — deterministisch, ohne LLM im Scan-Pfad — mit 47 Unit-Tests, die das für immer beweisen (12/12 erkannt, 0 False Positives im sauberen Kontroll-Repo).

2. Der Realitätscheck: 30 Repos, 5 mit kritischen Befunden

Ich habe 30 öffentliche Repos über die GitHub-Code-Suche nach AGENTS.md gescannt — darunter Google, Microsoft und Nextcloud. 5 mit kritischen Befunden. Der spannendste: ein unsichtbares Zeichen direkt vor einem Bash-Block in einer Agenten-Spec. Zufall oder Absicht? Genau dafür ist das Tool da. Jeder Befund wurde manuell byte-genau geprüft und ist öffentlich: Echtwelt-Befunde.

3. Doppeltes Dogfooding

Zwei Dinge passierten, die ich nicht besser hätte inszenieren können:

(a) GitHubs eigene Push-Protection blockierte einen meiner Pushes — ein Fake-Token in meiner eigenen Testdatei löste GH013: Push cannot contain secrets aus. Der größte Code-Host der Welt hat an meinem Repo demonstriert, was AgentGuard bei deinem fängt.

(b) Wochen später, nach dem v0.2.1-Bypass-Schutz, blockierte unser eigenes Gate unseren eigenen Pull-Request beim Selbsttest — die neue Regel ignoriert jede .agentguard-ignore, die in einem PR mitgeliefert wird, und unser Selbsttest-Workflow hatte sich auf das alte Verhalten verlassen. Roter Check. Merge verweigert. Funktioniert wie designed. Die ganze Geschichte steht im Changelog.

Gestern hat mein eigenes Sicherheits-Tool meinen eigenen Pull-Request geblockt. Das ist die beste Demo, die ein Sicherheitsprodukt haben kann.

4. Was in v0.2.1 kam

Fail-closed Gates: Ein Tippfehler in exit-on deaktiviert das Gate nicht mehr still — es bricht laut ab.
PR-Bypass-Schutz: Eine im PR mitgelieferte .agentguard-ignore wird ignoriert; Ausnahmen kommen nur aus dem vertrauenswürdigen Workflow.
Gehärteter Pro-Server: HMAC-Längenprüfung, 1-MB-Webhook-Body-Limit, Installation pro Repo, sicheres Tarball-Entpacken (Größenlimit, Symlink-/Traversal-Abweisung).
Neue Secret-Muster: Private Keys, GitHub-PATs, npm, Stripe, Slack-Webhooks. Details in SECURITY.md.

5. Der Bot blockierte einen Angriff live

Die GitHub-App kommentiert jeden PR mit Note und Befunden und setzt ein Check-Run-Gate. Der Beweis ist ein echter Pull-Request: Ein gepflanzter Angriff bekam Note E, einen roten Check und keinen Merge — live ansehen.

6. Die Landingpage zeigt jetzt den Moment

Die Landingpage hat ein Live-Scan-Terminal im Hero: Es tippt sich durch Dateien, findet die gepflanzte Anweisung und endet im grünen MERGE-GEBLOCKT-Moment — genau das Gefühl, das dieses Produkt verkauft: Dein Agent liest dein Repo. Dein Gate liest mit. Gemessene Qualität statt Deko: Lighthouse 100/100/100/100 auf Desktop und Mobile, LCP 179 ms, CLS ~0, kein Horizontal-Scroll bis 320 px.

Probier es aus

MIT-lizenziert, kostenlos für öffentliche Repos auf dem GitHub Marketplace. Schick dein Repo und bekomm einen kostenlosen Erst-Scan — oder stell die Anfrage direkt: Audit/Trial/RedTeam-Formular.

🔗 Code: https://github.com/agentguard-dev/agentguard
🛒 Marketplace: https://github.com/marketplace/actions/agentguard-security
📊 Verifizierte Befunde: https://github.com/agentguard-dev/agentguard/blob/main/docs/REAL-WORLD-FINDINGS.md
🔴 Live-Demo (Angriff geblockt): https://github.com/agentguard-dev/agentguard-demo/pull/2
🌐 Landingpage: https://agentguard-dev.github.io/agentguard/

I attacked my own repo — my PR bot blocked the attack before merge

AgentGuard — Tue, 08 Sep 2026 16:49:35 +0000

Coding agents are the new benchmark for dev teams: Claude Code, Cursor, Codex & Co. read your repo — and trust it. I asked myself: what happens when someone smuggles an instruction into the repo that the agent happily executes?

So I built AgentGuard — a CI gate for agent configurations (AGENTS.md, skills, MCP servers, hooks). And I stuffed my own repo with 12 targeted attacks. The honest protocol:

1. The attacks were easy to hide

12 payloads: a hidden instruction-override in AGENTS.md, invisible zero-width characters in a skill file, a typo-squatted MCP server host, a hook piping network content into a shell, a committed API key, an agent with wild Bash access… Every single one looks normal in a PR review.

AgentGuard detects all 12 — deterministically, no LLM in the scan path — with 47 unit tests that prove it forever (12/12 detected, 0 false positives on the clean control repo).

2. The real-world run: 30 repos, 5 with critical findings

I scanned 30 public repos via GitHub's code search for AGENTS.md — including Google, Microsoft and Nextcloud. 5 had critical findings. The most interesting: an invisible character right before a bash block in an agent spec. Coincidence or intention? That's exactly what the tool is for. Every finding was byte-verified manually and is public: real-world findings.

3. Double dogfooding

Two things happened that I could not have staged better:

(a) GitHub's own push protection blocked one of my pushes — a fake token in my own test file triggered GH013: Push cannot contain secrets. The biggest code host on the internet demonstrated on my repo exactly what AgentGuard catches on yours.

(b) Weeks later, after we shipped the v0.2.1 bypass protection, our own gate blocked our own pull request during the self-test — the new rule ignores any .agentguard-ignore shipped inside a PR, and our self-test workflow had relied on the old behavior. Red check. Merge refused. Working as designed. The full story is in the changelog.

Yesterday my own security tool blocked my own pull request. That is the best demo a security product can have.

4. What shipped in v0.2.1

Fail-closed gates: a typo in exit-on no longer silently disables the gate — it fails loudly.
PR bypass protection: a .agentguard-ignore shipped inside a PR is ignored; exclusions come only from the trusted workflow.
Hardened Pro server: HMAC length checks, 1 MB webhook body limit, per-repo installation resolution, safe tarball extraction (size limit, symlink/traversal rejection).
New secret patterns: private keys, GitHub PATs, npm, Stripe, Slack webhooks. Details in SECURITY.md.

5. The bot blocked an attack, live

The GitHub App comments on every PR with a grade and findings, and sets a check-run gate. The proof is a real pull request: a planted attack got Note E, a red check, and no merge — see it live.

6. The landing page now shows the moment

The landing page has a live scan terminal in the hero: it types through files, finds the planted instruction, and ends on the green MERGE BLOCKED moment — the exact emotion this product sells: your agent reads your repo; your gate reads with it. Measured quality, not decoration: Lighthouse 100/100/100/100 on desktop and mobile, LCP 179 ms, CLS ~0, no horizontal scroll down to 320 px.

Try it

MIT-licensed, free for public repos on the GitHub Marketplace. Reply with your repo and get a free first scan — or open a request directly: audit/trial/redteam form.

🔗 Code: https://github.com/agentguard-dev/agentguard
🛒 Marketplace: https://github.com/marketplace/actions/agentguard-security
📊 Verified findings: https://github.com/agentguard-dev/agentguard/blob/main/docs/REAL-WORLD-FINDINGS.md
🔴 Live demo (attack blocked): https://github.com/agentguard-dev/agentguard-demo/pull/2
🌐 Landing page: https://agentguard-dev.github.io/agentguard/