agentbrake-sdk 0.1.0__tar.gz

agentbrake_sdk-0.1.0/.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+*.egg-info/
+dist/
+build/
+.venv/
+venv/
+.env
+.DS_Store
+.pytest_cache/
+*.egg

agentbrake_sdk-0.1.0/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+
+All notable changes to AgentBrake are documented here.
+This project adheres to [Semantic Versioning](https://semver.org/).
+
+## [0.1.0] — unreleased
+
+First public release.
+
+### Added
+- **Framework-agnostic engine** (`core`): live loop detection (identical
+  tool+args repeated N times), cost ceiling, step / tool-call / duration limits,
+  warn-at-80%, built-in pricing for GPT-4o, GPT-4, Claude, and Gemini.
+- **LangChain 1.x support** via `LangChainBrakeMiddleware` — runs inside the
+  `create_agent` / LangGraph execution graph, so it can actually halt a run.
+- **Classic LangChain (0.x) support** via the `LangChainBrake` callback for
+  `AgentExecutor`.
+- **CrewAI 1.x support** via `CrewAIBrake` — patches every provider completion
+  class plus `ToolUsage._use`, with per-instance token-delta cost accounting.
+- Runnable examples for both frameworks (LangChain demo needs no API key).
+- Test suite covering the engine and both framework integrations against the
+  real `langchain` 1.3 and `crewai` 1.14 libraries.
+
+### Notes
+- On LangChain 1.x, callbacks are observe-only (the framework swallows
+  exceptions raised from them) — use `LangChainBrakeMiddleware` to brake, not the
+  callback. See the README for the 1.x-vs-0.x guidance.
+- CrewAI cost accuracy depends on the provider reporting token usage; without it
+  the brake falls back to a rough length-based estimate while all other limits
+  (loop, steps, tool-calls, duration) remain exact.

agentbrake_sdk-0.1.0/GO-TO-MARKET.md

@@ -0,0 +1,104 @@
+# 🚀 AgentBrake — Go-to-Market-Plan
+
+*Wie du AgentBrake live bringst und die ersten Nutzer & Kunden gewinnst.*
+
+---
+
+## Die Grundregel für Entwickler-Tools
+
+AgentBrake ist kein SaaS, das man über eine Landing Page verkauft. Es ist ein
+Entwickler-Tool. Entwickler kaufen nicht wegen Marketing — sie übernehmen ein
+Tool, weil es ihren echten Schmerz löst und andere Entwickler es empfehlen.
+
+Deshalb ist die Reihenfolge: **erst Code & Verbreitung, dann Landing Page, dann Umsatz.**
+Eine schöne Website für ein Tool, das auf GitHub 3 Stars hat, überzeugt niemanden.
+Umgekehrt verkauft sich ein Tool mit 800 Stars fast von selbst.
+
+Deine stärkste Waffe ist **eine Story**: der reale 47.000-Dollar-Loop. Die
+verkauft das Produkt in einem Satz. Nutze sie überall.
+
+---
+
+## Phase 1 — Fundament legen (Woche 1)
+
+**Ziel:** Das Tool ist installierbar und auffindbar.
+
+1. **CrewAI-Pfad echt testen** (siehe PROJECT-CONTEXT.md, offener Punkt #1).
+   Vor dem Launch muss beides nachweislich funktionieren.
+2. **GitHub-Repo anlegen.** Code pushen. README ist schon launch-fertig.
+   - Repo-Beschreibung: „The emergency brake for multi-agent systems. Stop runaway LangChain & CrewAI agents before they burn your budget."
+   - Topics/Tags: `langchain`, `crewai`, `ai-agents`, `llm`, `cost-control`, `guardrails`, `finops`
+3. **Auf PyPI veröffentlichen.** Dann ist `pip install agentbrake-sdk` weltweit live.
+4. **Kurzes Demo-GIF/Video aufnehmen** (30-60 Sek): Terminal zeigt einen Loop,
+   die Kosten laufen hoch, AgentBrake schlägt zu. Das ist dein wichtigstes Asset —
+   es zeigt den „Aha"-Moment in Sekunden.
+
+---
+
+## Phase 2 — Soft Launch in Communities (Woche 2-3)
+
+**Ziel:** Erste echte Nutzer, erstes Feedback, erste GitHub-Stars.
+
+Geh dorthin, wo LangChain/CrewAI-Entwickler über genau diesen Schmerz reden.
+**Wichtig: erst Wert liefern, dann erst das Tool erwähnen.** Nicht spammen.
+
+### Rented Channels (wo deine Käufer schon sind)
+
+| Kanal | Was du postest | Aufhänger |
+|-------|----------------|-----------|
+| **r/LangChain** (Reddit) | „I built a one-line brake that stops runaway agent loops" + Demo-GIF | Der 47k-Loop |
+| **r/CrewAI / r/AI_Agents** | Gleiche Story, CrewAI-fokussiert | Loop zwischen zwei Agenten |
+| **Hacker News** (Show HN) | „Show HN: AgentBrake – stop runaway LangChain/CrewAI agents in real time" | Die Story + dass es Open Source ist |
+| **LangChain Discord / CrewAI Discord** | Im #show-and-tell oder Hilfe-Channel, wenn jemand über Kosten klagt | Direkt auf konkreten Schmerz antworten |
+| **X/Twitter** | Thread: „A LangChain agent once cost someone \$47.000 overnight. Here's the 1-line fix I built." | Story-Thread mit Demo-GIF am Ende |
+
+### Die Hacker-News-„Show HN" ist dein wichtigster Moment
+- Poste dienstags-donnerstags, früh US-Pazifik-Zeit (ca. 16-17 Uhr deutsche Zeit).
+- Sei den ganzen Tag online und antworte auf JEDEN Kommentar.
+- Sei ehrlich über den Stand („LangChain getestet, CrewAI frisch") — HN belohnt Ehrlichkeit, bestraft Hype.
+
+---
+
+## Phase 3 — Momentum & erste Einnahmen (Monat 2-3)
+
+**Ziel:** Aus Nutzern Fürsprecher machen, erste Zahlungsbereitschaft testen.
+
+1. **Sammle Beweise.** Jeder, der sagt „das hat mir X gespart" → um ein kurzes
+   Zitat bitten. Diese Testimonials sind Gold für die Landing Page.
+2. **Schreib einen ehrlichen Erfahrungs-Post:** „I open-sourced an agent brake.
+   Here's what 1.000 downloads taught me about runaway agents." → bringt Backlinks
+   und Glaubwürdigkeit.
+3. **Product Hunt Launch**, sobald du GitHub-Traktion hast (nicht vorher).
+   Tagline-Vorschlag: „AgentBrake – The emergency brake for AI agents".
+4. **Teste die bezahlte Idee.** Wenn genug Leute es nutzen: eine gehostete
+   Version mit Team-Dashboard, zentralen Limits über alle Agenten, Alerts.
+   Das ist, wofür Firmen zahlen — der Open-Source-Kern bleibt gratis.
+
+---
+
+## Phase 4 — Auf den Radar der großen Firmen (Monat 4+)
+
+Damit AgentBrake für eine Übernahme interessant wird, brauchst du genau das,
+was Phase 1-3 aufbaut: **Nutzer, Downloads, einen Namen in der Nische.**
+
+- Sprich auf Meetups/Konferenzen über „Runaway agents in production".
+- Schreib Gastbeiträge in KI-Engineering-Newslettern.
+- Tag relevante Leute bei LangChain Inc., Datadog, den Hyperscalern in deinen
+  Posts — nicht aufdringlich, aber sichtbar. Übernahmen beginnen oft damit,
+  dass ein Engineering-Leiter dein Tool schon kennt.
+
+**Ehrliche Einordnung:** Eine Übernahme ist ein mögliches Ende, kein Plan, auf
+den man bauen kann. Der realistische, in deiner Hand liegende Weg ist:
+Open-Source-Verbreitung → bezahlte Cloud-Version → profitables kleines SaaS.
+Eine Übernahme passiert *dann* von selbst, wenn überhaupt — weil du wertvoll
+geworden bist, nicht weil du danach gefragt hast.
+
+---
+
+## Die wichtigsten 3 Dinge, falls du nur Zeit für 3 hast
+
+1. `pip install agentbrake-sdk` live bringen (GitHub + PyPI).
+2. Das Demo-GIF mit der 47k-Story auf Hacker News + r/LangChain posten.
+3. Auf jeden einzelnen Kommentar antworten und Feedback einbauen.
+
+Alles andere folgt daraus.

agentbrake_sdk-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AgentBrake
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

agentbrake_sdk-0.1.0/PKG-INFO

@@ -0,0 +1,172 @@
+Metadata-Version: 2.4
+Name: agentbrake-sdk
+Version: 0.1.0
+Summary: The emergency brake for multi-agent systems. Stop runaway LangChain & CrewAI agents in real time — before 50 cents becomes $47,000.
+Project-URL: Homepage, https://agentbrake.dev
+Project-URL: Repository, https://github.com/marcoschulz7/agentbrake
+Author: AgentBrake
+License: MIT
+License-File: LICENSE
+Keywords: ai-agents,cost-control,crewai,finops,guardrails,langchain,llm,observability
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.9
+Provides-Extra: all
+Requires-Dist: crewai>=0.80; extra == 'all'
+Requires-Dist: langchain-core>=0.2; extra == 'all'
+Provides-Extra: crewai
+Requires-Dist: crewai>=0.80; extra == 'crewai'
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Provides-Extra: langchain
+Requires-Dist: langchain-core>=0.2; extra == 'langchain'
+Description-Content-Type: text/markdown
+
+# 🛑 AgentBrake
+
+**The emergency brake for multi-agent systems.**
+Stop runaway LangChain & CrewAI agents in real time — *before* 50 cents turns into $47,000.
+
+```bash
+pip install agentbrake-sdk
+```
+
+> The install name is `agentbrake-sdk`; you import it as `agentbrake`.
+
+---
+
+## The problem
+
+In November 2025, four LangChain agents entered an infinite loop. They ran for 11 days. The bill was **$47,000**. Nobody noticed until it was over.
+
+This is not rare. Autonomous agents fail *expensively* rather than loudly:
+
+- An agent calls the same tool **14,000 times** with identical arguments.
+- A planner expands one simple task into dozens of high-context subagent calls.
+- A reasoning loop never hits its stopping condition and runs all night.
+
+Observability tools **record** this. They don't **stop** it. By the time the alert fires — or someone reads it — the money is gone. The gap between "the alert fired" and "the run stopped" is exactly where the damage compounds.
+
+**AgentBrake closes that gap. It intercepts, not just observes.**
+
+---
+
+## How it works
+
+AgentBrake hooks into your agent's execution and watches every step in real time. When a run crosses a limit you set, it raises a clean exception that **halts the agent before the next expensive call goes out.**
+
+```python
+from agentbrake import LangChainBrakeMiddleware
+from langchain.agents import create_agent
+
+agent = create_agent(
+    model, tools=tools,
+    middleware=[LangChainBrakeMiddleware(max_cost_usd=2.00, repeat_tool_limit=5)],
+)
+```
+
+That's it. One line.
+
+---
+
+## What it catches
+
+| Runaway pattern | How AgentBrake stops it |
+|---|---|
+| **Identical-tool loops** (same call, same args, over and over) | `repeat_tool_limit` — trips after N identical calls in a row |
+| **Cost blowouts** (the $47k overnight run) | `max_cost_usd` — a hard ceiling, enforced live as tokens are spent |
+| **Endless reasoning** (no stopping condition) | `max_steps` — caps total reasoning steps |
+| **Tool-call storms** | `max_tool_calls` — caps total tool invocations |
+| **Hung runs** | `max_duration_s` — wall-clock ceiling |
+
+It warns at 80% of any limit, and stops at 100%.
+
+---
+
+## LangChain
+
+LangChain has two agent stacks, and they intercept differently — AgentBrake
+ships the right tool for each.
+
+**LangChain 1.x** (`create_agent` / LangGraph) — use the middleware. It runs
+inside the agent graph, so it can actually halt the run:
+
+```python
+from agentbrake import LangChainBrakeMiddleware, AgentBrakeError
+from langchain.agents import create_agent
+
+agent = create_agent(
+    model, tools=tools,
+    middleware=[LangChainBrakeMiddleware(max_cost_usd=2.00, repeat_tool_limit=5, max_steps=30)],
+)
+
+try:
+    agent.invoke({"messages": [("user", "...")]})
+except AgentBrakeError as e:
+    print(f"Stopped safely: {e.reason}")
+```
+
+**Classic `AgentExecutor`** (LangChain 0.x) — use the callback:
+
+```python
+from agentbrake import LangChainBrake, AgentBrakeError
+
+brake = LangChainBrake(
+    max_cost_usd=2.00,
+    repeat_tool_limit=5,
+    max_steps=30,
+)
+
+try:
+    agent_executor.invoke({"input": "..."}, config={"callbacks": [brake]})
+except AgentBrakeError as e:
+    print(f"Stopped safely: {e.reason}")
+```
+
+## CrewAI
+
+```python
+from agentbrake import CrewAIBrake, AgentBrakeError
+
+CrewAIBrake(max_cost_usd=3.00, repeat_tool_limit=5).install()
+
+try:
+    crew.kickoff()
+except AgentBrakeError as e:
+    print(f"Crew stopped safely: {e.reason}")
+```
+
+---
+
+## Live cost visibility
+
+Every run prints where your money is going, step by step:
+
+```
+[AgentBrake] step 1: web_search · running cost $0.0080
+[AgentBrake] step 2: web_search · running cost $0.0160
+[AgentBrake] ⚠️  approaching cost limit (1.60 of 2.00)
+[AgentBrake] 🛑 STOPPED — loop detected: same tool call repeated 5× in a row
+  steps=5 tool_calls=5 llm_calls=4 tokens=9,200 cost=$0.032 elapsed=0.4s
+```
+
+---
+
+## Pricing built in
+
+AgentBrake ships with current pricing for GPT-4o, GPT-4, Claude (Opus/Sonnet/Haiku), and Gemini, so cost ceilings work out of the box. Override anytime with your own rates.
+
+---
+
+## Why not just set a provider spend cap?
+
+Provider caps are **monthly** and **account-wide** — they fire after the damage, across everything. AgentBrake is **per-run** and **in-process** — it stops *this* agent *now*, before the next call. It's the difference between a smoke alarm and a sprinkler.
+
+---
+
+## License
+
+MIT — free to use, including commercially.

agentbrake_sdk-0.1.0/PROJECT-CONTEXT.md

@@ -0,0 +1,117 @@
+# 📋 AgentBrake — Projekt-Kontext & Übergabe
+
+*Dies ist der Übergabe-Brief. In Claude Code als Erstes lesen lassen, dann ist die neue Session sofort im Bild.*
+
+---
+
+## Was ist das hier?
+
+**AgentBrake** — die Notbremse für Multi-Agenten-Systeme. Ein Python-Paket, das
+Runaway-Loops in **LangChain** und **CrewAI** in Echtzeit stoppt, bevor aus
+50 Cent ein 47.000-Dollar-Loop wird.
+
+Das Produkt **existiert und funktioniert bereits** — es ist kein Konzept.
+Es ist gegen die echten Libs verifiziert: CrewAI 1.14.6 und LangChain 1.3
+(inkl. eines No-Key-Beispiels, das einen echten LangGraph-Loop bremst).
+
+## Die Geschäftsidee in einem Satz
+
+Solo-Entwickler-Produkt in einer brandneuen, noch nicht dominierten Nische
+(Agenten-Kostenkontrolle). Open-Source-Kern (MIT) für Verbreitung, später
+bezahlte Cloud-/Team-Version für Umsatz. Langfristiges Ziel: Übernahme durch
+einen großen Player (Datadog, LangChain Inc., ein Hyperscaler) oder profitabler
+SaaS.
+
+## Warum diese Nische (Recherche-Ergebnis, Stand Juni 2026)
+
+- Markt explodiert: LLM-API-Ausgaben haben sich 2024→2025 verdoppelt (3,5 → 8,4 Mrd. $).
+- Schmerz ist real & teuer dokumentiert: ein LangChain-Loop kostete real $47.000 über 11 Tage.
+- CrewAI: 12 Mio. Agenten-Läufe/Tag in Produktion. LangChain: 50.000+ Produktions-Apps.
+- Die Lücke: Bestehende Tools **loggen** Loops, sie **stoppen** sie nicht in Echtzeit.
+  AgentBrake greift ein statt nur zu beobachten.
+- Konkurrenz existiert (Magicrails, Waxell, Galileo), aber niemand besitzt die
+  Position „*die* LangChain/CrewAI-Notbremse" eindeutig. Markt ist erst Wochen alt.
+
+## Was schon gebaut ist
+
+| Datei | Inhalt | Status |
+|-------|--------|--------|
+| `src/agentbrake/__init__.py` | Öffentliche API (Exports), Package-Einstieg | ✅ |
+| `src/agentbrake/core.py` | Framework-neutrale Engine: Loop-Detektor, Budget-Tracker, Preis-Tabelle | ✅ getestet (14 Tests) |
+| `src/agentbrake/langchain.py` | **Zwei** Integrationen: `LangChainBrake` (Callback, klassisches 0.x) + `LangChainBrakeMiddleware` (1.x / LangGraph) | ✅ Unit-Tests + echte Integrationstests gegen LangChain **1.3** |
+| `src/agentbrake/crewai.py` | CrewAI-Adapter via Monkey-Patching | ✅ gegen echtes CrewAI **1.14.6** verifiziert & repariert — siehe Hinweis unten |
+| `tests/` | Engine + LangChain (Unit + Middleware-Integration) + CrewAI | ✅ **grün** — 20 ohne Frameworks, 22 mit LangChain, 26 mit CrewAI; nicht-installierte Pfade skippen sauber |
+| `pyproject.toml` | Packaging (hatchling, src-Layout) + pytest-Config | ✅ Wheel baut, `pip install -e .` läuft |
+| `README.md` | Doku + Verkaufstext | ✅ aktualisiert (1.x-Middleware vs. 0.x-Callback) |
+| `examples/` | `langchain_quickstart.py` (läuft **ohne API-Key**), `crewai_quickstart.py` (braucht Key), `README.md` | ✅ |
+
+### ⚠️ Wichtiger Hinweis zum LangChain-Adapter (Stand 1.x)
+
+LangChain 1.x hat die Agenten-Architektur auf `create_agent` / LangGraph
+umgebaut. Zwei Konsequenzen, die den Adapter direkt betreffen:
+
+- **Callbacks können nicht mehr bremsen.** In LangGraph laufen Callback-Handler
+  als Beobachter; eine Exception aus einem Callback wird **geloggt und
+  verschluckt**, der Lauf geht weiter. Der klassische `LangChainBrake`-Callback
+  funktioniert daher nur noch beim alten `AgentExecutor` (0.x).
+- **Für 1.x gibt es `LangChainBrakeMiddleware`.** Middleware läuft *im*
+  Ausführungsgraphen (`wrap_tool_call` / `wrap_model_call`), eine Exception
+  daraus stoppt den Lauf wirklich. Verifiziert: das No-Key-Beispiel bremst einen
+  echten LangGraph-Loop bei Step 3.
+
+**Faustregel:** 1.x (`create_agent`) → `LangChainBrakeMiddleware`. Klassischer
+`AgentExecutor` (0.x) → `LangChainBrake`-Callback.
+
+### ⚠️ Wichtiger Hinweis zum CrewAI-Adapter (Stand 1.x)
+
+CrewAI 1.x hat die interne Architektur umgebaut: `LLM(...)` ist jetzt eine
+**Factory**, die provider-spezifische Subklassen (`OpenAICompletion`, …)
+zurückgibt — das alte Patchen von `LLM.call` lief ins Leere. Der Adapter wurde
+darauf umgebaut: er patcht jetzt **jede Provider-Klasse mit eigenem `call()`**
+(plus `ToolUsage._use`). Was man wissen muss:
+
+- **Loop-/Step-/Tool-/Duration-Limits** greifen zuverlässig (über `ToolUsage._use`).
+- **Cost-Limit** ist so genau, wie der Provider seine Tokens meldet
+  (`_token_usage`); ohne gemeldete Tokens fällt der Adapter auf eine grobe
+  Längen-Schätzung zurück.
+- `install()` muss **nach** dem Bauen der Agenten/LLMs laufen (CrewAI lädt
+  Provider lazy) — am besten direkt vor `crew.kickoff()`.
+- Noch offen: ein echter End-to-End-Lauf mit live LLM-Key (kostet echtes Geld).
+  Patch-Punkte + Token-Buchhaltung sind aber gegen die reale Lib verifiziert.
+
+## Die offenen nächsten Schritte (Priorität von oben)
+
+1. **Echter End-to-End-Lauf mit live LLM-Key** (kostet ein paar Cent): einmal
+   `crewai_quickstart.py` mit `OPENAI_API_KEY` laufen lassen und einen echten
+   Crew-Loop bremsen sehen. Letzter ungetesteter Pfad — Mechanik ist verifiziert,
+   nur der Live-Lauf fehlt. (LangChain ist via No-Key-Beispiel schon abgedeckt.)
+2. **Auf GitHub stellen.** Repo anlegen, Code pushen (LICENSE + .gitignore liegen bei).
+3. **Auf PyPI veröffentlichen.** `pip install build twine`, `python -m build`,
+   `twine upload dist/*`. Dann ist `pip install agentbrake-sdk` weltweit live.
+4. **Go-to-Market starten.** Siehe `GO-TO-MARKET.md` — der 47k-Loop ist die beste Story.
+5. **Landing Page bauen.** Siehe `WEBSITE-ARCHITECTURE.md`.
+
+**Erledigt (Juni 2026):** Packaging zu echtem `src/agentbrake`-Paket umgebaut
+(`__init__.py`, Wheel baut, `pip install -e .` läuft) · Testsuite neu von Null
+geschrieben · CrewAI-Adapter gegen echtes CrewAI 1.14.6 verifiziert und auf die
+neue Provider-Factory-Architektur repariert · LangChain-1.x-Lücke gefunden
+(Callbacks bremsen in LangGraph nicht mehr) und mit `LangChainBrakeMiddleware`
+geschlossen — bremst nachweislich einen echten LangGraph-Loop ohne API-Key ·
+Examples für beide Frameworks geschrieben.
+
+## Arbeitsweise mit Marco (für Claude in der neuen Session)
+
+- Marco kommuniziert auf Deutsch (informell).
+- Marco will so wenig wie möglich selbst machen — Claude agiert als technischer
+  Co-Founder und trifft Entscheidungen, statt viele Fragen zu stellen.
+- Marco schätzt Ehrlichkeit über Schönfärberei: echte Vorbehalte nennen
+  (z.B. „CrewAI-Cost-Limit hängt davon ab, dass der Provider Tokens meldet"),
+  nicht verstecken.
+- Iterativ arbeiten: erste Version ist Startpunkt, nicht Endprodukt.
+
+## Wichtiger realistischer Rahmen
+
+Große Firmen kaufen selten reine Ideen oder frühe Tools. Was zählt, ist
+**Traction**: echte Nutzer, GitHub-Stars, Downloads. Der Plan ist deshalb:
+erst Verbreitung über Open Source + Communities, dann Umsatz, dann ggf. Exit.
+Das ist ein Monate-bis-Jahre-Weg, kein Schnellschuss — ehrlich eingeordnet.

agentbrake_sdk-0.1.0/README.md

@@ -0,0 +1,145 @@
+# 🛑 AgentBrake
+
+**The emergency brake for multi-agent systems.**
+Stop runaway LangChain & CrewAI agents in real time — *before* 50 cents turns into $47,000.
+
+```bash
+pip install agentbrake-sdk
+```
+
+> The install name is `agentbrake-sdk`; you import it as `agentbrake`.
+
+---
+
+## The problem
+
+In November 2025, four LangChain agents entered an infinite loop. They ran for 11 days. The bill was **$47,000**. Nobody noticed until it was over.
+
+This is not rare. Autonomous agents fail *expensively* rather than loudly:
+
+- An agent calls the same tool **14,000 times** with identical arguments.
+- A planner expands one simple task into dozens of high-context subagent calls.
+- A reasoning loop never hits its stopping condition and runs all night.
+
+Observability tools **record** this. They don't **stop** it. By the time the alert fires — or someone reads it — the money is gone. The gap between "the alert fired" and "the run stopped" is exactly where the damage compounds.
+
+**AgentBrake closes that gap. It intercepts, not just observes.**
+
+---
+
+## How it works
+
+AgentBrake hooks into your agent's execution and watches every step in real time. When a run crosses a limit you set, it raises a clean exception that **halts the agent before the next expensive call goes out.**
+
+```python
+from agentbrake import LangChainBrakeMiddleware
+from langchain.agents import create_agent
+
+agent = create_agent(
+    model, tools=tools,
+    middleware=[LangChainBrakeMiddleware(max_cost_usd=2.00, repeat_tool_limit=5)],
+)
+```
+
+That's it. One line.
+
+---
+
+## What it catches
+
+| Runaway pattern | How AgentBrake stops it |
+|---|---|
+| **Identical-tool loops** (same call, same args, over and over) | `repeat_tool_limit` — trips after N identical calls in a row |
+| **Cost blowouts** (the $47k overnight run) | `max_cost_usd` — a hard ceiling, enforced live as tokens are spent |
+| **Endless reasoning** (no stopping condition) | `max_steps` — caps total reasoning steps |
+| **Tool-call storms** | `max_tool_calls` — caps total tool invocations |
+| **Hung runs** | `max_duration_s` — wall-clock ceiling |
+
+It warns at 80% of any limit, and stops at 100%.
+
+---
+
+## LangChain
+
+LangChain has two agent stacks, and they intercept differently — AgentBrake
+ships the right tool for each.
+
+**LangChain 1.x** (`create_agent` / LangGraph) — use the middleware. It runs
+inside the agent graph, so it can actually halt the run:
+
+```python
+from agentbrake import LangChainBrakeMiddleware, AgentBrakeError
+from langchain.agents import create_agent
+
+agent = create_agent(
+    model, tools=tools,
+    middleware=[LangChainBrakeMiddleware(max_cost_usd=2.00, repeat_tool_limit=5, max_steps=30)],
+)
+
+try:
+    agent.invoke({"messages": [("user", "...")]})
+except AgentBrakeError as e:
+    print(f"Stopped safely: {e.reason}")
+```
+
+**Classic `AgentExecutor`** (LangChain 0.x) — use the callback:
+
+```python
+from agentbrake import LangChainBrake, AgentBrakeError
+
+brake = LangChainBrake(
+    max_cost_usd=2.00,
+    repeat_tool_limit=5,
+    max_steps=30,
+)
+
+try:
+    agent_executor.invoke({"input": "..."}, config={"callbacks": [brake]})
+except AgentBrakeError as e:
+    print(f"Stopped safely: {e.reason}")
+```
+
+## CrewAI
+
+```python
+from agentbrake import CrewAIBrake, AgentBrakeError
+
+CrewAIBrake(max_cost_usd=3.00, repeat_tool_limit=5).install()
+
+try:
+    crew.kickoff()
+except AgentBrakeError as e:
+    print(f"Crew stopped safely: {e.reason}")
+```
+
+---
+
+## Live cost visibility
+
+Every run prints where your money is going, step by step:
+
+```
+[AgentBrake] step 1: web_search · running cost $0.0080
+[AgentBrake] step 2: web_search · running cost $0.0160
+[AgentBrake] ⚠️  approaching cost limit (1.60 of 2.00)
+[AgentBrake] 🛑 STOPPED — loop detected: same tool call repeated 5× in a row
+  steps=5 tool_calls=5 llm_calls=4 tokens=9,200 cost=$0.032 elapsed=0.4s
+```
+
+---
+
+## Pricing built in
+
+AgentBrake ships with current pricing for GPT-4o, GPT-4, Claude (Opus/Sonnet/Haiku), and Gemini, so cost ceilings work out of the box. Override anytime with your own rates.
+
+---
+
+## Why not just set a provider spend cap?
+
+Provider caps are **monthly** and **account-wide** — they fire after the damage, across everything. AgentBrake is **per-run** and **in-process** — it stops *this* agent *now*, before the next call. It's the difference between a smoke alarm and a sprinkler.
+
+---
+
+## License
+
+MIT — free to use, including commercially.

agentbrake_sdk-0.1.0/RELEASE.md

@@ -0,0 +1,52 @@
+# Releasing AgentBrake
+
+The package is built, `twine check`-clean, and committed. Publishing is
+outward-facing, so it needs *your* accounts — here are the exact steps.
+
+## 0. Public identity (decided)
+
+- Homepage: `https://agentbrake.dev`
+- Repository: `https://github.com/marcoschulz7/agentbrake`
+
+The PyPI project name `agentbrake` still needs to be free — check
+https://pypi.org/project/agentbrake/ before the upload.
+
+## 1. Push to GitHub — done via gh
+
+```bash
+gh repo create marcoschulz7/agentbrake --public --source=. --remote=origin --push
+```
+
+## 2. Publish to PyPI
+
+Use TestPyPI first to see the page render, then the real index.
+
+```bash
+# build fresh artifacts
+uv build                              # -> dist/agentbrake-0.1.0.tar.gz + .whl
+uvx twine check dist/*                # must say PASSED for both
+
+# dry run on TestPyPI (needs a TestPyPI token)
+uvx twine upload --repository testpypi dist/*
+pip install -i https://test.pypi.org/simple/ agentbrake-sdk   # smoke-test the install
+
+# the real thing (needs a PyPI token)
+uvx twine upload dist/*
+```
+
+After this, `pip install agentbrake-sdk` is live worldwide.
+
+## 3. Tag the release
+
+```bash
+git tag -a v0.1.0 -m "AgentBrake 0.1.0"
+git push origin v0.1.0
+```
+
+## Still open before/after launch
+
+- **CrewAI live end-to-end run** with a real `OPENAI_API_KEY` (a few cents) —
+  run `examples/crewai_quickstart.py` and watch a real crew get braked. The
+  mechanics are verified against the real library; only the live run is left.
+- Go-to-market — see `GO-TO-MARKET.md` (the $47k loop is the lead story).
+- Landing page — see `WEBSITE-ARCHITECTURE.md`.