Better Agents: Von Vibe Coding zu produktionstauglichen KI-Agenten mit einem einzigen Prompt

Better Agents: Das neue Super-Framework für KI-Agenten (und die bessere BMAD-Alternative)
Wie du mit einem einzigen Prompt und deinem Coding-Assistenten produktionstaugliche AI Agents baust

---

Einleitung: Hast du auch genug von „Vibe Coding“?

Wenn du schon einmal versucht hast, einen KI-Agenten „mal eben“ zusammenzubauen, kennst du das wahrscheinlich:

• Du startest mit einer guten Idee – z.B. ein Bank-Support-Agent oder ein persönlicher Finanzassistent.
• Du „vibe codest“ mit deinem Lieblings-LLM, probierst Prompts aus, baust ein paar Tools dazu.
• Nach ein paar Stunden (oder Tagen) hast du etwas, das irgendwie funktioniert – aber:
  • Die Struktur ist improvisiert,
  • Tests fehlen komplett,
  • Evaluierungen? Fehlanzeige.
  • Nach zwei Wochen weißt du selbst nicht mehr genau, wie alles zusammenhängt.

Kommt dir das bekannt vor?
Dann ist Better Agents genau das, was dir bisher gefehlt hat.

In diesem Artikel zeige ich dir:

• Was Better Agents ist und warum es als BMAD-Alternative so spannend ist,
• wie du damit von einem einzigen Prompt zu einem vollständig getesteten, strukturierten und beobachtbaren Agenten-Projekt kommst,
• wie das Zusammenspiel mit Tools wie Kilo Code, Claude Code, Cursor, Mastra und LangWatch aussieht,
• und wie du Schritt für Schritt selbst loslegen kannst.

Am Ende dieses Artikels wirst du genau wissen, wie du:

• deine bisherigen „Vibe-Coding“-Ansätze auf ein neues Level hebst,
• produktionstaugliche KI-Agenten auf Basis von LangChain aufsetzt,
• und dir dabei massiv Zeit, Frust und technische Schulden sparst.

---

Was ist Better Agents – und warum reden alle von einer BMAD-Alternative?

Better Agents ist eine CLI und ein standardisiertes Framework, das dir hilft, KI-Agenten „richtig“ zu bauen – also:

• mit klarer Architektur,
• mit Tests und Evaluierungen,
• mit Observability,
• und mit einer sauberen, wiederverwendbaren Struktur.

Statt einfach nur ein paar Prompts und Tools zusammenzuschrauben, bekommst du:

> Einen kompletten Agenten – inklusive Projektstruktur, Tools, Prompts, MCP-Konfiguration, Tests, Evaluierungen und Dokumentation – generiert aus einem einzigen Prompt.

Und das Entscheidende:
Better Agents arbeitet Hand in Hand mit deinem Coding-Assistenten, zum Beispiel:

• Kilo Code
• Claude Code
• Cursor
• (weitere folgen)

Es ist also kein Ersatz für diese Tools, sondern ein Orchestrator. Better Agents:

• setzt den Rahmen,
• wählt das passende Agent-Framework (z.B. Mastra, Agno),
• gibt deinem Coding-Assistenten konkrete, strukturierte Aufgaben,
• und sorgt dafür, dass am Ende ein produktionstauglicher Agent herauskommt – nicht nur ein Demo-Skript.

Wenn du bisher nach dem Prinzip „Build Many Agents, Die (BMAD)“ oder „Vibe Coding“ gearbeitet hast, wirst du den Unterschied sofort merken:

• Statt 10 halbfertige Agents zu bauen,
• baust du 1 richtig guten, getesteten und erweiterbaren Agenten.

---

Die Kernidee: Von natürlicher Sprache zum vollständigen Agent-Projekt

Stell dir vor, du sagst einfach:

> „Erstelle mir einen Bank-Kundenservice-Agenten, der Kreditkarten entsperren, Transaktionen anzeigen und bei Bedarf an einen menschlichen Mitarbeiter eskalieren kann.“

Ab hier übernimmt Better Agents:

1. Es analysiert deine Beschreibung.
2. Es verbindet sich mit deinem Coding-Assistenten (z.B. Kilo Code oder Claude Code).
3. Es wählt das konfigurierte Agent-Framework (z.B. Mastra).
4. Es generiert:
   • eine komplette Projektstruktur,
   • alle notwendigen Tools,
   • Prompts und deren Versionierung,
   • MCP-Konfiguration (also welche Tools/Server verfügbar sind),
   • Tests, Evaluierungen und Datasets,
   • und eine Dokumentation (agents.md).
5. Es lässt deinen Coding-Assistenten iterativ:
   • Fehler beheben,
   • fehlende Teile ergänzen,
   • Tests implementieren und ausführen,
   • Agenten-Verhalten verbessern.

Am Ende hast du:

• Einen laufenden Agenten,
• der Tests besteht,
• dessen Verhalten du über Evaluierungen und Tools wie LangWatch beobachten kannst,
• und dessen Struktur so sauber ist, dass du ihn problemlos erweitern, warten oder in ein Team übergeben kannst.

---

Warum „Vibe Coding“ nicht reicht – und was Better Agents anders macht

Viele Entwickler:innen lieben die Idee, mit einem LLM einfach „loszucoden“. Es fühlt sich schnell an, kreativ, spielerisch. Und für Prototypen ist das absolut okay.

Das Problem beginnt, wenn aus dem „Vibe“ Produktivcode werden soll.

Typische Probleme:

• Keine einheitliche Projektstruktur
  Jeder Agent sieht anders aus. Man findet Dateien nicht wieder. Tools sind irgendwo verstreut.

• Fehlende Tests & Evaluierungen
  Du weißt nicht, ob dein Agent wirklich stabil funktioniert – oder nur bei den zwei, drei Beispielen, die du ausprobiert hast.

• Keine Observability
  Was passiert, wenn User echte, komplexe Fragen stellen? Wo treten Fehler auf? Welche Prompts funktionieren besser?

• Schwer wartbar
  Schon nach kurzer Zeit traust du dich nicht mehr, etwas Größeres zu ändern – weil du nicht weißt, was du damit ungewollt kaputt machst.

Better Agents geht dieses Problem frontal an, indem es:

• von Anfang an eine klare Struktur vorgibt,
• Best Practices rund um Agents, Prompts, Tools und Tests durchsetzt,
• Tests und Evaluierungen automatisch mitgeneriert,
• und deinen Coding-Assistenten dazu „zwingt“, sich an diese Regeln zu halten.

Kurz:
Statt Chaos bekommst du Qualität mit System – ohne auf die Geschwindigkeit von Tools wie Claude Code oder Kilo Code zu verzichten.

---

Die wichtigsten Features von Better Agents im Überblick

Lass uns die Kernfunktionen im Detail anschauen und direkt mit Beispielen verbinden.

1. Von einem einzigen Prompt zum vollständigen Agent

Du beschreibst in natürlicher Sprache, was der Agent tun soll, etwa:

• „Ein persönlicher Finanzassistent, der Ausgaben trackt, Budgets verwaltet und automatisch Insights liefert.“
• „Ein Bank-Kundenservice-Agent, der Kreditkarten entsperrt, Transaktionen anzeigen kann und an einen Mitarbeiter eskaliert.“

Better Agents übernimmt dann:

1. Framework-Wahl & Setup

   • Wählt das konfigurierte Agent-Framework (z.B. Mastra, Agno).
   • Initialisiert ein neues Projekt mit standardisierter Struktur.

2. Coding-Assistent orchestrieren

   • Startet z.B. Kilo Code oder Claude Code als „Experten-Agenten-Entwickler“.
   • Übergibt Kontext:
     „Du arbeitest in einem Better-Agents-Projekt, halte dich an diese Best Practices, befolge diesen Schritt-für-Schritt-Plan.“

3. Projektgerüst generieren

   • Tools, Prompts, Agenten-Definitionen,
   • Frontend (falls konfiguriert),
   • Konfigurationen und MCP-Setup.

4. Iterative Verbesserung

   • Lässt deinen Coding-Assistenten:
     • Fehler fixen,
     • Tests ergänzen,
     • Prompts verfeinern,
     • neue Funktionen hinzufügen,
     • bis der Agent wirklich funktioniert.

Du musst also nicht ständig selbst eingreifen oder im Code nach Fehlern suchen – Better Agents steuert diesen Prozess.

---

2. Automatische Struktur & Best Practices

Eines der größten Probleme bei KI-Projekten ist die fehlende Standardisierung. Better Agents löst das, indem es dir eine fertig durchdachte Projektstruktur hinstellt.

Typische Bestandteile:

• Klarer Projektaufbau
  z.B. (vereinfacht):

  • src/agents/ – Definitionen deiner Agents
  • src/tools/ – Funktionen/APIs, die deine Agents nutzen
  • src/prompts/ – Prompt-Vorlagen & Variationen
  • tests/ – Unit-/Integrationstests & Szenariotests
  • datasets/ – Testdaten und Evaluierungsdaten
  • configs/ – Konfigurationen (MCP, LLM-Provider, Framework, usw.)

• Semantic Code Indexing
  Der Code wird so vorbereitet, dass dein Coding-Assistent ihn später besser versteht, durchsuchen und erweitern kann.
  Das ist massiv hilfreich, wenn du deinem Assistenten z.B. sagst:
  „Optimier den Budget-Analyseteil und füge eine neue Auswertungsfunktion hinzu.“

• MCP-Konfiguration (Model Context Protocol)
  Better Agents erzeugt eine Datei wie mcp.json, in der festgehalten wird:

  • welche MCP-Server verfügbar sind (z.B. langwatch, mastra),
  • wie diese konfiguriert sind,
  • sodass dein Coding-Assistent diese automatisch nutzen kann.

• Prompt Registry
  Statt Prompts kreuz und quer im Code zu verstreuen, legt Better Agents eine zentrale, versionierte Sammlung an – mehr dazu gleich unter prompts.json.

Durch all das bekommst du ein Projekt, das:

• auch in 6 Monaten noch verständlich ist,
• von anderen Entwickler:innen leicht übernommen werden kann,
• und in dem du systematisch erweitern kannst – statt ständig neu anzufangen.

---

3. Tests, Evaluierungen & Observability – direkt eingebacken

Wenn du bisher ohne Tests gearbeitet hast, wirst du überrascht sein, wie sehr sich die Qualität deiner Agents ändert, sobald du:

• systematische Szenarien definierst,
• dein Agenten-Verhalten regelmäßig prüfst,
• und die Ergebnisse in Tools wie LangWatch visualisierst.

Better Agents hilft dir dabei auf drei Ebenen:

a) Tests und Szenarien generieren

Better Agents erzeugt automatisch:

• Tests (z.B. in deiner gewählten Sprache, etwa TypeScript),
• Notebook- oder Dataset-Dateien, mit denen du:
  • verschiedene RAG-Ansätze testen kannst (Retrieval-Augmented Generation),
  • unterschiedliche Prompt-Varianten gegeneinander laufen lassen kannst,
  • Klassifikatoren oder Spezialkomponenten evaluieren kannst.

Beispiele für Szenarien:

• „Zeige die letzten 5 Kreditkartentransaktionen an.“
• „Warn den User, wenn er sein Monatsbudget für Restaurants überschreitet.“
• „Eskalier an einen menschlichen Advisor, wenn die Anfrage zu komplex oder zu risikoreich ist.“

b) Integration mit Observability-Tools (z.B. LangWatch)

Better Agents kann mit Tools wie LangWatch verbunden werden.
Damit kannst du:

• Testszenarien ausführen,
• Ergebnisse und Metriken visualisieren,
• Fehlerpfade erkennen,
• und nachvollziehen, warum dein Agent in bestimmten Fällen scheitert oder falsche Antworten gibt.

c) Automatisierte Feedback-Loops

Besonders stark: Better Agents nutzt deinen Coding-Assistenten, um auf Basis von Testergebnissen Verbesserungen vorzunehmen.

Ablauf z.B.:

1. Tests laufen durch und einige Szenarien schlagen fehl.
2. Better Agents holt sich deinen Coding-Assistenten (z.B. Claude Code) ins Boot.
3. Der Assistent bekommt:
   • die Fehlerinformationen,
   • den bestehenden Code,
   • und die Vorgabe: „Behebe diese Fehler, ohne bestehende Funktionalität zu verschlechtern.“
4. Der Assistent passt Code/Prompts an.
5. Tests laufen erneut.

Damit hast du einen echten Entwicklungszyklus, der deutlich näher an klassischer Software-Qualitätssicherung ist – nur eben KI-spezifisch.

---

4. Die wichtigsten Artefakte von Better Agents im Detail

Better Agents erzeugt mehrere zentrale Dateien, die du kennen solltest.

prompts.json – deine Prompt-Bibliothek

Statt dass Prompts irgendwo in Code-Strings versteckt sind, legt Better Agents eine Prompt Registry an.

Darin kannst du z.B. haben:

• bank_support.v1
• bank_support.v2_experimental
• personal_finance_advisor.v1

Vorteile:

• Du kannst eindeutig referenzieren, welche Prompt-Version gerade live ist.
• Du kannst Prompt-Varianten gezielt gegeneinander testen.
• Du vermeidest das bekannte „Wo war nochmal der Prompt?“-Problem.

mcp.json – welche Tools stehen den Agents zur Verfügung?

In dieser Datei hält Better Agents fest:

• welche MCP-Server aktiv sind (z.B. langwatch, mastra),
• wie sie konfiguriert sind (URLs, Keys, Optionen),
• sodass dein Coding-Assistent diese später automatisch nutzen kann.

Beispiel: Wenn dein Assistent neue Funktionen implementiert, weiß er direkt, dass er dazu z.B. LangWatch- oder Mastra-Funktionen aufrufen kann.

agents.md – deine Agenten-Dokumentation

Diese Datei ist eine Art Best-Practices-Guide für das konkrete Projekt:

• Wie ist der Agent aufgebaut?
• Welche Tools nutzt er?
• Wie wird er getestet?
• Wie erweitere ich ihn sicher?
• Worauf muss ich achten, um nichts kaputt zu machen?

Gerade, wenn du im Team arbeitest oder das Projekt in Zukunft anderen übergeben willst, ist das Gold wert.

Tests, Datasets & Evaluierungs-Szenarien

Zusätzlich legt Better Agents:

• Testdateien,
• Evaluierungs-Skripte,
• Beispiel-Datasets

direkt in der Projektstruktur an – fertig vorbereitet für deine Use Cases.

---

Praxisbeispiel 1: Bank-Kundenservice-Agent mit Better Agents

Schauen wir uns an, wie das Ganze in der Praxis aussieht.

Ziel

Ein Agent, der:

• als Bank-Kundenservice-Mitarbeiter agiert,
• Kreditkarten entsperren kann,
• Transaktionen anzeigen kann,
• und bei Bedarf an einen menschlichen Mitarbeiter eskaliert.

Ablauf mit Better Agents

1. Du beschreibst den Agenten in natürlicher Sprache.

   Beispiel: > „Erstelle einen Bank-Kundenservice-Agenten, der Kreditkarten entsperren, aktuelle Kreditkartentransaktionen anzeigen und bei Bedarf an einen menschlichen Servicemitarbeiter eskalieren kann. Er soll sicher, höflich und regelkonform agieren.“

2. Better Agents startet den Coding-Assistenten (z.B. Kilo Code).

3. Framework-Auswahl: Mastra

   In der Demo wählt Better Agents z.B. Mastra als Framework und nutzt Mastra Studio als Umgebung.

4. Projekt-Scaffolding & Implementierung

   Better Agents orchestriert Kilo Code und lässt es:

   • die erforderlichen Tools anlegen (z.B. Funktionen für „Kreditkarte entsperren“, „Transaktionen holen“, „Eskalation“),
   • Semantic Code Indexing einrichten,
   • Tests generieren (z.B. „Zeige die letzten Transaktionen“, „Blockierte Karte entsperren“, etc.),
   • das Verhalten des Agenten definieren (Prompts, Rollen, Policies).

5. Tests & Evaluierungen laufen

   Über Tools wie LangWatch oder direkt in Mastra Studio:

   • werden Szenarien ausgeführt,
   • Ergebnisse visualisiert,
   • Fehlerstellen identifiziert.

6. Iterative Fehlerbehebung

   Kilo Code wird von Better Agents angewiesen:

   • Fehlschläge in den Tests zu beheben,
   • Code/Prompts nachzubessern,
   • bis die definierten Szenarien bestehen.

Ergebnis

Du erhältst einen voll funktionalen Bank-Support-Agenten, der:

• strukturiert aufgebaut ist,
• Tests und Evaluierungen hinterlegt hat,
• dessen Verhalten beobachtbar ist,
• und der deutlich näher an Produktionsqualität ist, als ein schnell zusammengeklickter Demo-Agent.

---

Praxisbeispiel 2: Persönlicher Finanzassistent – Schritt für Schritt

Dieses Beispiel ist besonders interessant, weil hier der komplette Setup-Prozess inkl. Installation gezeigt wird.

Schritt 1: Voraussetzungen

Bevor du loslegst, brauchst du:

• Node.js 22+
• npm
• einen Coding-Assistenten, z.B.:
  • Claude Code
  • Cursor
  • Kilo Code
• API-Keys:
  • LLM-Provider (z.B. Anthropic, OpenAI),
  • optional: LangSmith oder ähnliche Tools für erweiterte Evaluierungen.

Schritt 2: Better Agents installieren

npm install -g better-agents

Tipp:
Starte Better Agents am besten in einem neuen, leeren Projektordner, um Konflikte mit bestehenden Projekten zu vermeiden.

Schritt 3: Neues Projekt initialisieren

In deinem gewünschten Projektordner:

better-agents init

Du bekommst dann interaktive Fragen, z.B.:

• Sprache: TypeScript (oder eine andere, sofern unterstützt)
• Agent-Framework: z.B. Mastra
• LLM-Provider: z.B. „Anthropic Claude 4.5 Opus“
• Anthropic API Key: hier trägst du deinen Key ein
• Coding-Assistent: z.B. Kilo Code oder Claude Code
  • Falls noch nicht installiert: Better Agents kann die CLI zum Teil automatisch installieren.
• LangSmith (oder ähnliches) API-Key: optional, für zusätzliche Evaluierungen

Schritt 4: Agentenbeschreibung formulieren

Im Demo-Beispiel:

> „Ein Agent, der beim Tracken von Ausgaben hilft, Budgets verwaltet und automatisch Insights in die persönlichen Finanzen liefert.“

Better Agents nutzt diese Beschreibung, um:

• den Kontext für Claude Code (oder deinen gewählten Assistenten) zu erstellen,
• zu erklären, dass es sich um ein Better-Agents-Projekt mit Best Practices handelt,
• einen Schritt-für-Schritt-Plan für den Coding-Assistenten zu definieren.

Schritt 5: MCP-Server auswählen

Während der Initialisierung fragt Better Agents, welche MCP-Server in mcp.json eingetragen werden sollen.

Im Beispiel:

• langwatch – für Observability und Evaluierungen,
• mastra – für Framework-Funktionen.

Diese werden automatisch in die Projektkonfiguration eingetragen, sodass dein Agent und dein Coding-Assistent darauf zugreifen können.

Schritt 6: Generierung der Anwendung

Better Agents + Claude Code erzeugen nun:

• die komplette Projektstruktur nach Better-Agents-Standard.
• einen Frontend-Client für den Finanzassistenten, z.B. mit:
  • Alerts (Budgetwarnungen),
  • Budgets nach Kategorie (visualisiert, z.B. Diagramme),
  • Chat-Interface („Chat mit dem Finanzassistenten“),
  • Finanztipps,
  • letzte Transaktionen (zunächst simuliert),
  • höchster Ausgabetag (Analytics),
  • Eskalationsmöglichkeit zu einem menschlichen Finanzberater.

Unter der Haube:

• werden Tools implementiert (z.B. Ausgaben laden, Budgets berechnen, Insights generieren),
• Prompts in der Prompt Registry hinterlegt,
• Tests und Evaluierungen erzeugt,
• MCP-Server in mcp.json konfiguriert,
• Dokumentation in agents.md erstellt.

Ergebnis

Du hältst am Ende eine voll funktionsfähige Anwendung in der Hand, die:

• eine saubere Struktur hat,
• Tests & Evaluierungen integriert,
• direkt erweiterbar und deploybar ist.

Ohne Better Agents hättest du für denselben Stand wahrscheinlich:

• deutlich mehr Zeit gebraucht,
• viel mehr manuell orchestrieren müssen,
• und eine deutlich „wackligere“ Codebasis.

---

Warum du Better Agents einsetzen solltest – echte Vorteile im Alltag

Wenn du dich fragst, ob sich der Umstieg von „Vibe Coding“ auf ein Framework wie Better Agents lohnt, helfen dir diese Punkte.

1. Bestes „Starting Point“-Setup für neue Agent-Projekte

Statt jedes Mal bei Null anzufangen und zu überlegen:

• „Wie strukturier ich das Projekt diesmal?“
• „Wo kommen Prompts hin?“
• „Wie pack ich Tests dazu?“

…startest du mit einem durchdachten Blueprint, der sich bereits in der Praxis bewährt hat.

Das spart dir:

• Zeit,
• Nerven,
• und jede Menge zukünftige Refactorings.

2. Standardisierte, einfache Struktur

Ein klarer Aufbau mit:

• getrennten Ordnern für Tools, Agents, Prompts, Tests, Konfigurationen,
• verständlicher Dokumentation,
• und einer zentralen Prompt-Registry,

führt dazu, dass:

• du schneller findest, was du suchst,
• du neue Features leichter einsortieren kannst,
• andere Entwickler:innen sich problemlos einarbeiten können.

3. Eingebaute Observability & Evaluierungen

Viele Teams merken erst im Betrieb, dass ihre Agents:

• in bestimmten Bereichen komplett versagen,
• bestimmte User-Gruppen falsch behandeln,
• oder unter „Edge Cases“ zusammenbrechen.

Mit Better Agents hast du:

• definierte Szenariotests,
• Integration mit Tools wie LangWatch,
• eine Basis, um systematisch zu messen und zu verbessern.

Das ist der Unterschied zwischen:

• „Ich hoffe, dass es irgendwie funktioniert“
  und
• „Ich weiß, wie gut es in welchen Szenarien funktioniert.“

4. Bessere Wartbarkeit & Zuverlässigkeit

Durch:

• klare Dokumentation (agents.md),
• Tests & Evaluierungen,
• standardisierte Strukturen,

wird dein Projekt:

• robuster gegen Änderungen,
• leichter erweiterbar,
• und weniger fehleranfällig bei Refactorings.

Wenn du Agents für reale User baust – ob intern oder extern – ist das unverzichtbar.

5. Perfekte Ergänzung zu deinen Coding-Tools

Better Agents ersetzt nicht:

• Kilo Code,
• Claude Code,
• Cursor,
• oder andere Coding-Agents.

Es macht sie besser nutzbar, indem es ihnen:

• einen klaren Rahmen gibt,
• klare Ziele vorgibt,
• und sie in einen automatisierten Entwicklungsprozess einbettet.

Wenn du also schon heute Tools wie Claude Code liebst, ist Better Agents der nächste logische Schritt.

---

Typische Use Cases für Better Agents

Wo spielt Better Agents seine Stärken besonders gut aus?

1. Domain-spezifische Experten-Agenten

Wenn du z.B.:

• einen Finanzberater-Agenten,
• einen Legal Assistant,
• einen Medizin-Informationsagenten (nicht für Diagnose, aber z.B. für Studienrecherche),
• oder einen SaaS-Support-Agenten bauen willst,

brauchst du:

• stabile Struktur,
• klare Tests,
• und gut dokumentierte Prompts & Tools.

Better Agents hilft dir, solche Agents sauber und reproduzierbar aufzubauen.

2. Agents, die vor dem Deployment Tests bestehen müssen

In Umgebungen, in denen:

• Compliance wichtig ist,
• Fehler teuer sind,
• oder du vertraglich gewisse Qualitätsniveaus liefern musst,

kannst du mit Better Agents:

• automatisierte Tests,
• Evaluierungen,
• Monitoring

von Anfang an integrieren. Damit kannst du z.B. sagen:

> „Wir deployen nur Modelle/Prompts, die in unseren Kern-Szenarien eine bestimmte Erfolgsquote erreichen.“

3. Teams, die Agents langfristig pflegen und erweitern

Wenn mehrere Entwickler:innen an denselben Agenten arbeiten, ist:

• eine gute Struktur,
• eine zentrale Prompt-Registry,
• und eine klare Doku

entscheidend.

Better Agents bringt das direkt mit und erleichtert so:

• Onboarding neuer Teammitglieder,
• Refactorings,
• Integrationen mit anderen Systemen.

---

Schneller Einstieg: So legst du mit Better Agents los

Zum Abschluss eine kompakte Schritt-für-Schritt-Anleitung, wie du selbst starten kannst.

1. Grundvoraussetzungen installieren

• Node.js 22+
• npm

Prüfe im Terminal:

node -v
npm -v

2. Better Agents installieren

npm install -g better-agents

3. Neuen Projektordner anlegen und initialisieren

mkdir my-agent
cd my-agent
better-agents init

4. Fragen beantworten

Du wirst etwa Folgendes auswählen bzw. eingeben:

• Sprache: z.B. TypeScript
• Agent-Framework: z.B. Mastra oder Agno
• LLM-Provider: z.B. Anthropic Claude 4.5 Opus oder OpenAI
• API-Key deines LLM-Providers
• Coding-Assistent: Kilo Code, Claude Code, Cursor, …
• MCP-Server: z.B. LangWatch, Mastra
• Beschreibung deines Agenten in natürlicher Sprache

Tipp: Investiere 1–2 Minuten in eine gute Beschreibung deines Agenten. Je klarer du bist, desto besser der generierte Output.

5. Better Agents + Coding-Assistent arbeiten lassen

Ab hier kannst du dich bewusst ein Stück zurücklehnen:

• Better Agents setzt den Rahmen,
• dein Coding-Assistent füllt ihn mit Code, Prompts, Tests und Frontend (falls vorgesehen),
• Tests & Evaluierungen können ausgeführt werden,
• Fehlschläge werden iterativ behoben.

Du kannst natürlich jederzeit:

• in den Code reinschauen,
• eigene Anpassungen vornehmen,
• Prompts in prompts.json verfeinern,
• zusätzliche Tests ergänzen.

---

Fazit: Better Agents als Fundament für ernsthafte AI-Agenten

Wenn du ernsthaft mit KI-Agenten arbeiten möchtest – egal ob für eigene Projekte, Kunden oder als Produkt – führt an Themen wie:

• klare Architektur,
• Tests & Evaluierungen,
• Observability,
• Wartbarkeit,

kein Weg vorbei.

Better Agents gibt dir all das:

• ohne dass du es mühsam selbst konzipieren musst,
• ohne auf die Geschwindigkeit von Coding-Agents zu verzichten,
• mit einer klaren, standardisierten Struktur,
• mit automatisierten Feedback-Loops und Best Practices.

Statt zehn „Vibe-Coding-Prototypen“ baust du mit Better Agents:

> Einen produktionstauglichen, getesteten und beobachtbaren Agenten, den du danach systematisch verbessern kannst.

Wenn du also:

• schon mit Tools wie Claude Code, Kilo Code oder Cursor arbeitest,
• regelmäßig neue KI-Agenten ausprobierst,
• aber dich über Chaos, fehlende Tests und schwierige Wartung ärgerst,

dann ist jetzt der perfekte Zeitpunkt, Better Agents auszuprobieren.

---

Nächste Schritte für dich:

1. Installiere Better Agents:

   npm install -g better-agents

2. Starte ein neues Projekt mit better-agents init.

3. Beschreibe deinen Wunsch-Agenten in natürlicher Sprache.

4. Lass Better Agents und deinen Coding-Assistenten die Arbeit machen.

Wenn du möchtest, kannst du danach:

• verschiedene Prompt-Versionen in prompts.json gegeneinander testen,
• mit LangWatch Szenarien evaluieren,
• neue Tools in src/tools ergänzen,
• und deinen Agenten Schritt für Schritt in Richtung Produktionsreife bringen.

Du bist nicht allein, wenn du bisher mit KI-Agenten eher „improvisiert“ hast. Mit Better Agents hast du jetzt ein Werkzeug, das dir hilft, aus diesen Improvisationen stabile, professionelle Systeme zu machen – mit deutlich weniger Frust und deutlich mehr Wirkung.