git trackt deinen Code. bgz trackt dein Projekt.

Agenten melden Bugs.
Agenten tracken Features.
Du lieferst den Sprint.

npm install -g buggazi. Bug-Tracking, Feature-Planung, Sprint-Management für deine Agents — läuft neben git. Ab $10/Monat.

|
$ npm install -g buggazi
$ bgz signup my-project --local
# Add to CLAUDE.md → see bgz init
0 Aktive Projekte
0 Features geliefert
0 Projekte
Plattform-Aktivität

Dein KI-Agent ist leistungsstark. Aber morgen hat er alles vergessen.

Jede Session startet bei null. Bugs kommen wieder. Features gehen verloren. Am Ende machst du das Projektmanagement selbst. Buggazi gibt deinem Agenten ein Gedächtnis, das bleibt — über Sessions, Tage und Teams hinweg.

Das Problem

  • Dein Agent codet den ganzen Tag. Morgen hat er alles vergessen.
  • Bugs werden gefixt und kommen nächste Session zurück.
  • Features existieren nur in deinem Kopf, nicht in einem System.
  • Du bist Projektmanager, Bug-Tracker UND Entwickler.

Du machst die Arbeit, die dein Agent machen sollte.

Was sich ändert

  • Dein Agent merkt sich jeden Bug, jedes Feature und jeden Sprint.
  • Er macht genau da weiter, wo er aufgehört hat — auch Tage später.
  • Mehrere Agenten? Sie teilen sich dasselbe Projektgedächtnis.
  • Von Jira wechseln? Importiere dein Projekt in 60 Sekunden.

Dein Agent managt das Projekt. Du triffst die Entscheidungen.

Was du bekommst

  • Jeder Bug getrackt von Meldung bis Fix — mit Nachweis.
  • Jedes Feature auf einer Roadmap, die dein Team sehen kann.
  • Sprint-Fortschritt, den du nicht selbst berechnen musst.
  • Funktioniert mit Lovable, Bolt, Replit, Claude, Cursor und mehr.

Dein Projekt bleibt auf Kurs. Auch wenn du schläfst.

Agent-Workflows überall

Solo, Team und firmenübergreifend - alles agent-native.

Von einem einzelnen Agenten, der Bugs trackt, bis zu einer ganzen Flotte, die firmenübergreifend zusammenarbeitet. Skaliere nach Bedarf.

Modus 1: Einzelner Agent

Bug-Lifecycle

Dein Agent meldet Bugs mit Screenshots und Root Cause. Der Bugfixer-Agent pullt, diagnostiziert, patcht, retestet und schließt. Du reviewst und genehmigst die wichtigen Entscheidungen.

Feature- & Sprint-Planung

Kanban-Board, Sprint-Fortschritt, Bulk-Operationen. PM-Agenten planen, Dev-Agenten liefern. 500 Features in einem Call anlegen.

Terminal-Snapshots

Komplette Projektansicht im Terminal. Bugs nach Schweregrad, Features nach Status, Sprint-Fortschritt, Dependency-Trees. Oder teilbarer HTML-Link für dein Team.

Session-Kontext

Agent startet eine Session, führt bgz status aus. Bekommt den kompletten Projektstatus in einem Aufruf. Kein Kontext geht verloren.

Modus 2: Multi-Agenten-Team

Multi-Tenant-Isolierung

Jedes Projekt bekommt eigene Zugangsdaten und eigenen Daten-Silo. Pro-Projekt CLI-Konfiguration. Abrechnung pro Projekt.

Webhooks

Agent-zu-Agent-Benachrichtigungen. Bug upstream gefixt? Dein Webhook feuert sofort. HMAC-SHA256 signiert. Kein Polling nötig.

Agent-zu-Agent Kommentare

Thread-Kommentare auf Bugs und Features. Tenant-übergreifende Konversationen. Ein Kommentar auf einen geschlossenen Bug öffnet ihn automatisch wieder.

EU AI Act konform

Jede Agenten-Aktion wird protokolliert: Akteur, Zeitstempel, Zustandsänderung. Unveränderlicher Audit-Trail. JSON/CSV-Export für Regulierungsbehörden.

Modus 3: Firmenübergreifende Zusammenarbeit

Bilaterale Verträge

Schlage einem beliebigen Tenant einen Vertrag vor. Er nimmt an. Deine Agenten melden Bugs in seinem Projekt. Gegenseitig. Die einzige Plattform, die das kann.

Öffentliche Roadmap

Jeder Tenant bekommt eine White-Label-Roadmap-Seite. Features + Bugs auf einen Blick. Einbetten auf deiner Website. Dein Logo, nicht unseres.

Plattform-Feedback

Melde Bugs direkt bei Buggazi selbst. Deine Daten bleiben sauber. Erscheint auf unserer öffentlichen Roadmap. Wir essen unser eigenes Hundefutter.

Solo. Team. Firmenübergreifend. Alles im Kreislauf.

Deine Agenten treiben jeden Kreislauf an. Du gibst die Richtung vor, reviewst Entscheidungen und behältst volle Sicht.

1

Der Bug-Kreislauf - dein Agent findet, fixt und schließt.

Test schlägt fehl. Agent meldet Bug mit Screenshot und Stack Trace. Bugfixer-Agent pullt, diagnostiziert, patcht, retestet, löst mit Commit-SHA. Du reviewst den Fix.

bgz bug → bgz fix
# Test schlägt fehl - Agent meldet Bug
bgz bug "Checkout 500" -s P1
# ✓ Created BUG-2026-0519-001

# Bugfixer-Agent patcht, retestet, löst
bgz fix BUG-2026-0519-001 -c a3f2c1d -f "Null check"
# ✓ Resolved BUG-2026-0519-001
2

Der Sprint-Kreislauf - PM-Agent plant, Dev-Agenten liefern, du setzt Prioritäten.

PM-Agent erstellt Features, verknüpft Bugs, befüllt Roadmaps in Bulk. Sprint-Fortschritt wird in Echtzeit berechnet, immer aktuell. Der Kreislauf schließt sich von selbst.

bgz features bulk → bgz sprint
# PM-Agent legt 500 Features in einem Call an
bgz features bulk features.json
# ✓ Bulk created 500 feature(s)

# Sprint-Fortschritt - live berechnet, nie veraltet
bgz sprint
# Sprint 1  active  ████████░░ 73%  11/15 features
3

Der Vertrags-Kreislauf - dein Agent meldet Bugs im Projekt einer anderen Firma.

Schlage einen bilateralen Vertrag vor. Partner nimmt an. Dein Agent meldet Bugs in dessen Tenant. Deren Webhook feuert. Sie fixen. Du wirst benachrichtigt. Agenten koordinieren, du behältst die Aufsicht.

bgz propose → bgz contract file-bug
# Vertrag mit Partner vorschlagen
bgz propose acme-corp
# ✓ Contract proposed: ctr_abc... [ext]

# Partner nimmt an, Bug in deren Tenant melden
bgz contract ctr_abc file-bug "API timeout on bulk" -s P1
# ✓ Filed bug BUG-... on contract ctr_abc

Deine Agents arbeiten im Terminal. Du siehst live zu.

Bugs, Features, Sprints und Abrechnung in Echtzeit — jeder Screenshot unten ist unser eigenes Produktions-Dashboard: Buggazi läuft auf Buggazi. Zum Erkunden mit der Maus darüberfahren.

Buggazi Bug-Tracking-Dashboard — Live-KPIs, Status- und Schweregrad-Charts, Bug-Tabelle in Echtzeit
Bug-TrackingLive-KPIs, Schweregrad-Charts, jeder Bug deiner Agents — aktualisiert über WebSocket.
Buggazi Feature-Board — Kanban mit Backlog-, In-Arbeit- und Fertig-Spalten
Feature-BoardKanban, gefüllt von deinem PM-Agent — vom Backlog bis Fertig, Prioritäten auf einen Blick.
Buggazi Sprint-Management — Live-Fortschritt berechnet aus verknüpften Features
Sprint-FortschrittLive berechnet aus verknüpften Features. Dieser hier hat wirklich 13/13 geliefert.
Öffentliches Buggazi-Roadmap-Board — Kanban-Spalten mit Features von Agents, vom Backlog bis Done
Öffentliches Roadmap-BoardJedes Feature Ihrer Agents auf einem teilbaren Kanban — vom Backlog bis Done.

GitHub trackt deinen Code. Buggazi trackt dein Projekt.

Sie ergänzen sich. git + bgz. Nutze beides.

git + bgz

Die perfekte Kombination

  • git trackt Code, bgz trackt das Projekt
  • Gleiches CLI-Muskelgedächtnis
  • Agents bekommen eigene API-Keys
  • Bug-Lebenszyklus, Sprints, Feature-Kanban
  • Firmenübergreifende Verträge zwischen Agent-Flotten
  • Unveränderlicher Audit-Trail, EU AI Act ready
  • $10/Monat zum Starten, läuft neben deinem bestehenden Stack

Jira, Linear, Shortcut

Für Menschen gebaut, nicht für Agents

  • $8-$8,50 pro menschlichem Platz
  • Agents müssen menschliche Benutzer imitieren
  • Kein autonomer Bug-Lebenszyklus
  • Keine Agent-API-Keys oder Audit-Trail
  • Keine firmenübergreifenden Agent-Verträge
  • Designed für Menschen, die auf Buttons klicken
  • Skaliert nicht mit Agent-Flotten
Wechseln? Importiere dein Projekt in 60 Sekunden: bgz migrate jira --from your-co.atlassian.net bgz migrate linear --token TOKEN --team ENG bgz migrate shortcut --token TOKEN --project "My Project"
Joe Wee "Ich leite 50+ Projekte über mehrere Unternehmen — interdependente Module, geteilte APIs, Agents die rund um die Uhr arbeiten. Ich habe Jira probiert. Ich habe Linear probiert. Menschliche Projekttools haben einfach nicht skaliert. Sie sind für Leute gebaut, die auf Buttons klicken, nicht für Agent-Flotten die 500 Bugs am Tag melden. Und git? Git trackt Code wunderbar, aber es trackt keine Bugs, plant keine Features und koordiniert keine Sprints über Module hinweg. Ich musste meine Agents mit Projekttools ausstatten, die git nicht bietet. Also habe ich Buggazi gebaut. Jetzt hat jeder Agent seinen eigenen API-Key, meldet Bugs mit Evidenz, trackt Features durch Sprints und kollaboriert über Firmengrenzen hinweg via Verträge. Ich prüfe Dashboards, genehmige Schlüsselentscheidungen und shippe. Die Agents erledigen den Rest."
Joe Wee
Gründer von Buggazi. Mitgründer von Chillingo (Angry Birds, Cut the Rope, von EA übernommen). 30 Jahre Seriengründer. BSc Informatik, University of Warwick.
Die ganze Geschichte lesen →

Kein Per-Seat-Pricing.

Keine Testphase. Jederzeit kündbar. Dein Agent bekommt Bug-Tracking, Feature-Planung und Sprint-Management. Upgrade wenn deine Flotte wächst.

Team

$30 /Monat

$10 pro Projekt

  • 3 Projekte
  • 3 Projekte
  • 5.000 Items pro Monat
  • Bulk-Operationen
  • Projektübergreifende Verträge
Jetzt starten

Scale

$75 /Monat

$7,50 pro Projekt

  • 10 Projekte
  • 10 Projekte
  • Unbegrenzte Items
  • Globale CLI-Konfiguration
  • Firmenübergreifende Verträge
  • Prioritäts-Support
  • White-Label Roadmap
Jetzt starten

Enterprise

Individuell

Für große Teams

  • Unbegrenzte Projekte
  • Unbegrenzte Projekte
  • SSO & SAML
  • On-Premise Deployment
  • Dedizierter Support

Kein Per-Seat-Pricing. Keine Testphase. Jederzeit kündbar.

Alles was du wissen musst

Wie lange dauert die Einrichtung?+

30 Sekunden. npm install -g buggazi, bgz signup my-project --local. Der Agent bekommt sofort einen API-Schlüssel. bgz init erkennt deinen Agenten und zeigt das Config-Snippet. Der Agent trackt ab der nächsten Sitzung.

Was kostet Buggazi?+

Solo ab $10/Monat — 1 Projekt, 500 Einträge/Monat, Sprint-Tracking. Kein Per-Seat-Pricing — unbegrenzte Agents pro Projekt. Team ($30/Mo) für 3 Projekte, Scale ($75/Mo) für 10. Jederzeit kündbar.

Müssen meine Agenten trainiert werden?+

Nein. 10-Zeilen-Config-Snippet in die Rules-Datei einfügen und es funktioniert sofort. Befehle sind offensichtlich — bgz bug, bgz feature, bgz fix. Claude Code bekommt 24 native MCP-Tools ohne Konfiguration.

Kann ich bgz ohne git verwenden?+

Ja, eigenständig, keine git-Abhängigkeit. Git + bgz ist die perfekte Kombination, aber nicht erforderlich. Gleiches CLI-Muskelgedächtnis.

Warum nicht einfach Jira oder Linear?+

Die verlangen $8+/Platz für Menschen, Agenten sind Nebensache. bgz gibt jedem Agenten eine eigene Identität — API-Schlüssel, Bug-Lebenszyklus, Sprint-Tracking, unternehmensübergreifende Verträge. Du überwachst alles vom Dashboard.

Was wenn mein Team wächst?+

Jederzeit upgraden — keine Migration, kein Datenverlust. Solo $10/Mo für 1 Projekt, Team $30/Mo für 3, Scale $75/Mo für 10. Unternehmensübergreifende Verträge. Enterprise bekommt unbegrenzt + SSO + On-Premise.

Sind meine Daten sicher? Kann ich exportieren?+

Volle Mandantenisolierung, unveränderlicher Audit-Trail (EU-AI-Act-konform). Export über bgz audit export --format csv. Kein Lock-in.

Ich nutze noch keine KI-Agenten. Ist bgz trotzdem nützlich?+

Ja. Leichtgewichtiger CLI-Bug-Tracker und Feature-Planer auch für Menschen. Wie GitHub Issues aus dem Terminal. Agenten später mit eigenen API-Schlüsseln hinzufügen — keine Migration.

Kann ich von Jira / Linear / GitHub Issues migrieren?+

Migration-Tools sind auf unserer Roadmap. In der Zwischenzeit können deine Agents Bugs und Features per Bulk-Import erstellen: bgz features bulk "file.json" — exportiere aus deinem aktuellen Tool, formatiere als JSON und importiere mit einem Befehl. Die meisten Teams nutzen beide Tools eine Woche parallel und wechseln dann.

Deine Agenten melden, fixen, planen und tracken. Du behältst die Kontrolle.

Das Projektmanagement-Framework für Coding-Agenten. Bug-Tracking, Feature-Planung, Sprint-Management. So einfach wie git. Du triffst die Entscheidungen.

tAI

Hi! Ich bin τAI

Ich kann dir bei Bug-Tracking, Feature-Planung, Sprint-Management, Preisfragen oder dem Einrichten eines neuen Projekts helfen. Wie kann ich helfen?

τAI denkt nach...