KI-Agenten in der Praxis: Aufbau, Werkzeuge und Grenzen

KI-Agenten in der Praxis: Aufbau, Werkzeuge und Grenzen

KI-Agenten sind 2026 eines der am schnellsten wachsenden Themen: Programme, die nicht nur Text erzeugen, sondern Aufgaben eigenständig planen und ausführen – Mails beantworten, Server verwalten, Code schreiben, Recherchen durchführen. Dieser Artikel erklärt, wie Agenten aufgebaut sind, welche Werkzeuge sie nutzen und wo die Grenzen liegen.

Was unterscheidet einen Agenten von einem Chatbot?

Ein Chatbot beantwortet Fragen. Ein Agent handelt: Er bekommt ein Ziel, plant Schritte, ruft Werkzeuge auf, prüft Ergebnisse und iteriert, bis die Aufgabe erledigt ist. Der Kern ist eine Schleife:

1. Ziel verstehen (Prompt/System-Prompt)
2. Beobachten (aktueller Zustand, Werkzeug-Ergebnisse)
3. Denken (nächster Schritt wählen)
4. Handeln (Werkzeug aufrufen: Shell, API, Datei, Suche)
5. Prüfen (Ergebnis bewerten)
6. Weiter bis Ziel erreicht – oder abbrechen

Diese „Agentenschleife" (Agent Loop) ist das Grundmuster hinter Werkzeugen wie Hanse-Computing-Devon, Claude Code, Codex oder OpenCode. Der Unterschied liegt in der Qualität der Planung, der Werkzeug-Auswahl und der Fähigkeit, Fehler zu erkennen.

Die Bausteine eines Agenten

  • LLM als „Gehirn": Entscheidet, was als Nächstes passiert (siehe LLMs verstehen).
  • Werkzeuge (Tools): Terminal, Dateisystem, Web-Suche, APIs, Datenbanken, E-Mail – der Agent kann damit die reale Welt verändern.
  • Kontext/Gedächtnis: System-Prompt mit Regeln, Konversationsverlauf, Notizen und gespeichertes Wissen.
  • Ausführungsumgebung: Sandbox, Container oder dedizierter Arbeitsbereich, in dem der Agent Befehle ausführt.
  • Menschlicher Aufsichts-Punkt: Bei riskanten Aktionen (Produktion, Geld, Löschen) sollte ein Mensch bestätigen – oder die Rechte sind technisch begrenzt.

Werkzeug-Nutzung: Der entscheidende Schritt

Moderne LLMs werden so trainiert, dass sie Werkzeug-Aufrufe (Function Calling) strukturiert ausgeben können. Der Agent sagt z.B. „Ich rufe terminal mit dem Befehl ls auf", das System führt aus und gibt die Ausgabe zurück. So entstehen Fähigkeiten, die ein reines Sprachmodell nie hätte: Dateien lesen, Pakete installieren, APIs aufrufen, Webseiten abrufen.

Wichtig für die Praxis: Werkzeug-Ergebnisse sind nicht automatisch wahr. Ein Agent muss Ausgaben verifizieren – Exit-Codes prüfen, HTTP-Status kontrollieren, Dateien zurücklesen. Genau diese Disziplin unterscheidet zuverlässige Agenten von oberflächlichen („Ich habe es gemacht" ohne Beleg).

Autonomie vs. Kontrolle

Der Grad der Autonomie ist eine Design-Entscheidung:

  • Vollautonom: Agent arbeitet unbeaufsichtigt, meldet nur Ergebnisse. Gut für klar abgegrenzte, risikoarme Aufgaben (Recherche, Inhalte, Monitoring).
  • Halbbewusst (human-in-the-loop): Agent stoppt bei kritischen Schritten und fragt nach. Standard für Produktion, Finanzen, Kundendaten.
  • Reine Assistenz: Agent schlägt vor, der Mensch führt aus.

Praxis-Empfehlung: Mit strikten Limits starten (Read-only, Sandbox, Budget), dann Autonomie schrittweise erhöhen. Ein Agent, der in einer isolierten Umgebung Fehler macht, kostet nichts – in Produktion kann derselbe Fehler teuer werden. (Siehe auch Systemadministration: Rechte, Logs, Backups gelten auch für Agenten.)

Typische Agenten-Aufgaben im Unternehmen

  • Support und Postfach: E-Mails sichten, priorisieren, standardisierte Antworten entwerfen.
  • Systemadministration: Monitoring, Log-Analyse, wiederkehrende Wartung, Backup-Prüfung.
  • Content: Artikel, Berichte, Übersetzungen, Social-Media-Posts – mit Qualitätsprüfung.
  • Code: Features implementieren, Bugs untersuchen, Tests schreiben, Code-Reviews.
  • Daten: Berichte erzeugen, CSV/Excel verarbeiten, Tabellen auswerten.
  • Wissensmanagement: Wissensdatenbanken befüllen, Dokumente strukturieren (wie dieses Wiki).

Grenzen und Risiken – ehrlich betrachtet

  • Halluzinationen bleiben: Ein Agent kann falsche Befehle ausführen oder erfundene Ergebnisse melden. Verifikation ist Pflicht.
  • Endlosschleifen: Ohne Schritt-Limits und Zeitbudgets dreht sich ein Agent im Kreis. Budgets und Abbruchkriterien einbauen.
  • Prompt-Injection: Böswillige Inhalte in Webseiten, E-Mails oder Dateien können den Agenten umsteuern. Niemals Anweisungen aus fremden Inhalten blind befolgen (nur aus dem ursprünglichen Auftrag).
  • Rechte-Eskalation: Ein Agent mit root-Zugriff und autonomem Handeln ist ein Risiko. Least-Privilege gilt auch hier: minimale Rechte, isolierte Umgebung, Logs.
  • Kosten: Agentenschleifen verbrauchen Tokens – bei großen Aufgaben das Budget im Auge behalten.

Ein einfaches Agenten-Setup selbst bauen

Wer das Prinzip verstehen will, baut eine Mini-Version mit einer LLM-API und einem Python-Skript:

# Pseudocode: Mini-Agent mit einem Werkzeug
while schritte < max_schritte:
    antwort = llm(verlauf + "Welches Werkzeug rufst du auf?")
    if antwort == "fertig":
        break
    ergebnis = fuehre_werkzeug_aus(antwort)   # z.B. terminal()
    verlauf.append(ergebnis)
    schritte += 1

In der Praxis nutzt man fertige Frameworks – etwa Hermes Agent, LangChain, oder CLI-Agenten wie Claude Code und Codex. Diese liefern Werkzeug-Sicherheit, Kontext-Management und Struktur gleich mit. Die Einrichtung eigener LLM-Infrastruktur beschreibt der Artikel Lokale KI vs. Cloud-KI.

Multi-Agenten-Systeme: Teamarbeit statt Einzelkämpfer

Komplexe Aufgaben lassen sich auf mehrere spezialisierte Agenten verteilen – ein Muster, das auch im Hanse-Computing-Netzwerk (Devon, HanseKI, K.I.T.T., smxlptp) praktisch eingesetzt wird. Typische Rollen:

  • Orchestrator: Zerlegt die Aufgabe, weist Teilaufgaben zu, sammelt Ergebnisse.
  • Spezialisten: Forscher, Coder, Schreiber, System-Admin – jeder mit eigenem Kontext und eigenen Werkzeugen.
  • Reviewer: Prüft Ergebnisse auf Qualität, Sicherheit und Konsistenz, bevor sie an den Menschen gehen.

Die Koordination passiert über geteilte Aufgaben-Boards (z.B. Kanban), Nachrichten-Kanäle oder direkte Aufrufe. Vorteil: parallele Arbeit, spezialisierte Kontexte, klarere Verantwortung. Risiko: höhere Fehleranfälligkeit durch Missverständnisse zwischen Agenten – deshalb sind strukturierte Übergaben („Handoffs") mit expliziten Ergebnissen wichtig.

Messbarkeit: Wann ist ein Agent gut?

Agenten-Qualität ist keine Magie, sondern messbar. Einfache Praxis-Metriken:

  • Aufgabenerfüllung: Wurde das Ziel erreicht? (Exit-Code, Test, HTTP-Status, Datei existiert?)
  • Fehlerquote: Wie oft musste ein Schritt wiederholt oder korrigiert werden?
  • Token-Kosten: Wie viele Tokens pro erfolgreicher Aufgabe – und wie viel hat das gekostet?
  • Menschliche Korrekturen: Wie oft greift der Mensch ein? Das ist der ehrlichste Qualitätsindikator.

Wer Agenten produktiv einsetzt, sollte diese Zahlen loggen und regelmäßig auswerten. Ein Agent, der ständig korrigiert werden muss, ist teurer als manuelle Arbeit – unabhängig davon, wie beeindruckend seine Zwischenantworten klingen.

Fazit

KI-Agenten sind mächtige Automatisierungswerkzeuge, aber keine Wunderwaffen. Der Unterschied zwischen nützlich und gefährlich liegt im Design: klare Ziele, begrenzte Rechte, verpflichtende Verifikation und menschliche Kontrollpunkte. Wer diese Disziplin einhält, kann repetitive Arbeit in großem Umfang delegieren – und behält trotzdem die Kontrolle. Die technische Grundlage dazu: LLMs verstehen und Python für Einsteiger.

Verwandte Artikel: LLMs verstehen · Systemadministration · Netzwerktechniken