Von Ziel zu kontrollierter Aktion: Schleifen, Überprüfung und Berechtigungen in KI-Agenten
Erfahren Sie, wie KI-Agenten ein Ziel durch einen Plan-Handeln-Beobachten-Zyklus in Tool-Aufrufe umwandeln, und warum Überprüfungen, Autonomiegrade sowie Berechtigungsstufen darüber entscheiden, ob sie sicher sind.
Die meisten Menschen lernten Sprachmodelle zunächst als Fragenbeantwortungsmaschinen kennen: Eingabe eines Prompts, Ausgabe einer Antwort – und das war’s. Agentensysteme durchbrechen dieses Muster. Gegeben ein Ziel, planen sie, rufen Tools auf, prüfen die Ergebnisse und setzen ihre Arbeit fort, bis die Aufgabe erledigt ist. Diese Übersicht behandelt den Ablaufprozess, die verwendeten Tools, das Gedächtnis sowie mehragentige Konfigurationen und konzentriert sich anschließend auf das Wichtigste in der Praxis: die Überprüfung der Arbeit eines Agenten und die Einschränkung seiner Befugnisse.
Antworten versus Zielverfolgung
Ein klassischer Chatbot führt nur eine einzige Aktion durch: Eine Frage wird eingegeben, das Modell liefert eine Antwort – mehr passiert nicht.
User
↓
Question
↓
AI
↓
Answer
Fragen Sie es „Was ist maschinelles Lernen?“ und Sie erhalten eine Erklärung, nichts weiter. Ein Agent ist um ein Ziel herum organisiert, das durch eine Abfolge von Aktionen mit Zwischenergebnissen erreicht wird.
User
↓
Goal
↓
AI Agent
↓
Plan
↓
Use Tools
↓
Observe Results
↓
Take More Actions
↓
Complete Goal
Eine Anfrage wie „Analysieren Sie diese Datensammlung und erstellen Sie einen Bericht“ muss in konkrete Schritte unterteilt werden:
Read dataset
↓
Understand columns
↓
Clean data
↓
Analyze statistics
↓
Create graphs
↓
Find patterns
↓
Write report
Kurz gesagt: Ein Chatbot antwortet, während ein Agent Aufgaben ausführt und unterwegs Anpassungen vornimmt.
Was macht ein System zu einem Agenten?
Es gibt keine einheitlich vereinbarte Definition. Eine praktische: Ein Agent übernimmt eine Aufgabe, trifft Entscheidungen, nutzt verfügbare Werkzeuge, betrachtet die Ergebnisse und wählt weitere Aktionen aus, bis das Ziel erreicht ist. Das entscheidende Merkmal ist der Schleifenabschnitt am Ende, der die Steuerung wieder nach oben leitet.
USER GOAL
↓
AI AGENT
↓
PLAN
↓
SELECT ACTION
↓
USE TOOL
↓
OBSERVE
↓
EVALUATE
↓
NEXT ACTION?
↙ ↘
YES NO
↓ ↓
Continue Finish
Ohne diese Schleife hat man ein einmal ablaufendes Pipeline-Verfahren. Mit ihr kann das System von unerwarteten Situationen wiederherstellen – das ist sowohl seine Stärke als auch der Grund, warum es Überwachung benötigt.
Der Denken-, Handeln- und Beobachten-Zyklus
Das einfachste mentale Modell für diesen Zyklus ist Denken, Handeln, Beobachten. Stellen Sie sich vor, Sie bitten einen Agenten, den besten Laptop innerhalb Ihres Budgets zu finden und drei Kandidaten miteinander zu vergleichen. Intern könnte der Prozess wie folgt ablaufen:
Goal
↓
Understand requirements
↓
Search for products
↓
Read results
↓
Compare specifications
↓
Check prices
↓
Evaluate options
↓
Generate recommendation
Der Agent schreibt nicht auf Basis von Trainingsdaten über Laptops. Er durchsucht echte Quellen und basiert seine Empfehlungen auf dem, was er findet – genau dieser Kontakt zur Außenwelt unterscheidet ihn von der reinen Textgenerierung.
Drei Komponenten: Modell, Werkzeuge und Zustand
Einen einfachen Agenten kann man anhand von drei Komponenten beschreiben.
Das Modell als Entscheidungsträger
In der Regel handelt es sich um ein großes Sprachmodell, das Anweisungen interpretiert und entscheidet, was als Nächstes getan werden soll.
Werkzeuge als Fähigkeiten
Werkzeuge sind die externen Fähigkeiten, die der Agent nutzen kann, zum Beispiel:
Search
Python
Calculator
Database
API
File system
Computer
Vision model
Der Zustand als laufende Aufzeichnung
Der Zustand ist das, was der Agent bislang über die Aufgabe weiß. Er beantwortet Fragen wie diese:
What did I search?
What did I find?
What have I already done?
What remains?
Zusammenfassend fließen die drei Komponenten in die Aktionen ein, die der Agent ausführt:
AI AGENT
│
┌──────────┼──────────┐
↓ ↓ ↓
Model Tools Memory
│ │ │
└──────────┼──────────┘
↓
Actions
Für eine ausführlichere Behandlung dieser Bausteine siehe unsere Anleitung zu Agentenzielen, Werkzeugen, Speicher und dem Schleifenmechanismus.
Warum Werkzeuge eine so große Bedeutung haben
Fragen Sie ein Modell, 938472 mit 827391 zu multiplizieren – es könnte zwar richtig antworten, doch es prognostiziert die Ziffern anstelle, sie zu berechnen; daher sind Taschenrechner oder Python zuverlässiger. Ein Agent kann die Aufgabe weitergeben:
User
↓
LLM
↓
"I need exact arithmetic."
↓
Calculator
↓
Result
↓
LLM
↓
Answer
Das Modell muss nicht alles selbst erledigen. Es delegiert.
Die richtige Wahl des Werkzeugs für die Eingabe
Wie wählt der Agent aus seinen Werkzeugen aus? Angenommen, er hat Zugriff auf alle folgenden:
Python
SQL
Search
Calculator
Vision Model
File Reader
Email API
Calendar
Angesichts der Aufgabe „Schauen Sie sich diese Verkaufs-Tabelle an und erklären Sie, warum der Umsatz gesunken ist“, leitet das System aufgrund des Eingabetyps, der Datenstruktur und der Aufgabe ein geeignetes Werkzeug ab:
Input = Spreadsheet
↓
Data = Tabular
↓
Task = Analysis
↓
Tool = Python/pandas
Danach übernimmt das ausgewählte Werkzeug die Hauptaufgabe und gibt seine Ergebnisse zurück:
pandas
↓
Analyze sales
↓
Find patterns
↓
Return results
Anschließend interpretiert der Agent diese Ergebnisse. In der Praxis hängt die Wahl des Werkzeugs stark von klaren Namen und Beschreibungen ab, da das Modell nur diese sieht.
Verschaltung mehrerer Werkzeuge in einem Workflow
Betrachten Sie die Aufgabe „Analysieren Sie unsere Verkaufsdaten, erstellen Sie eine Grafik davon und senden Sie den Bericht per E-Mail an meinen Vorgesetzten“ – dabei sind Analyse, Visualisierung, Erstellung von Texten und Übermittlung erforderlich:
Sales Dataset
↓
Python / pandas
↓
Statistical Analysis
↓
Matplotlib
↓
Create Charts
↓
LLM
↓
Write Report
↓
Email Tool
↓
Send Report
Das System koordiniert nun einen Workflow, bei dem jede Ausgabe als Eingang für den nächsten Schritt dient, sodass ein früher Fehler bis zur E-Mail weitergegeben wird.
Planung durch Aufgabenteilung
„Eine Website für mein Projekt erstellen“ ist zu umfangreich, um in einem Schritt erledigt zu werden. Ein fähiger Agent teilt es in geordnete Teile auf:
Goal
↓
Understand requirements
↓
Create project structure
↓
Build frontend
↓
Build backend
↓
Connect database
↓
Run application
↓
Test
↓
Fix errors
↓
Deploy
Das ist die Aufgabenteilung: Das Ziel wird in eine Reihe kleinerer Aktionen umgewandelt, die jeweils ausgeführt und überprüft werden können.
Auf Fehler reagieren anstatt sie zu melden
Der Schleifenmechanismus kommt zum Tragen, wenn etwas schiefgeht. Angenommen, der Agent führt some Code aus:
Write code
↓
Run code
↓
ERROR
Ein Chatbot kann nur den Fehler melden. Ein Agent kann ihn lesen, den Code korrigieren und es erneut versuchen:
Write code
↓
Run code
↓
ERROR
↓
Read error
↓
Identify problem
↓
Modify code
↓
Run again
↓
SUCCESS
Im Allgemeinen handelt es sich dabei um den agilen Schleifenmechanismus, wobei die Bewertung einen neuen Plan liefert:
┌──────────────┐
│ PLAN │
└──────┬───────┘
↓
┌──────────────┐
│ ACT │
└──────┬───────┘
↓
┌──────────────┐
│ OBSERVE │
└──────┬───────┘
↓
┌──────────────┐
│ EVALUATE │
└──────┬───────┘
│
└──────→ PLAN AGAIN
Eine Schleife, die wiederholen kann, kann auch endlos weitermachen, daher begrenzen reale Systeme die Anzahl der Iterationen.
Gedächtnis und Kontinuität über die Schritte hinweg
Ohne Gedächtnis beginnt jede Aufgabe von vorne:
Task 1
↓
Forget
↓
Task 2
↓
Forget
Durch das Weitergeben des Zustands baut jeder Schritt auf dem vorherigen auf:
Task 1
↓
Save result
↓
Task 2
↓
Use previous result
↓
Task 3
Der Speicher existiert in mehreren Bereichen:
- Kurzfristiger Zustand speichert Informationen aus der laufenden Aufgabe.
- Langfristiger Speicher bleibt über verschiedene Interaktionen hinweg bestehen, sofern das System dies unterstützt.
- Außenspeicher befindet sich außerhalb des Modells, in Datenbanken, Dokumenten, Vektorlagern oder Dateien.
Ein Agent kann vor dem aktuellen Schritt Projektunterlagen sowie frühere Ergebnisse konsultieren:
Agent
↓
Memory
↓
Project documents
↓
Previous results
↓
Current task
Kombination von Abruf und Handlung
Retrieval-augmented Generation (RAG) eignet sich hervorragend für Agenten. Um aus internen Unternehmensdokumenten Antworten zu geben, durchsucht ein Agent diese, liest die relevanten Abschnitte und begründet seine Entscheidungen darauf:
Question
↓
Search company documents
↓
Retrieve relevant information
↓
Read context
↓
Reason about it
↓
Answer
Durch Hinzufügen von Werkzeugen kann der Agent auch auf das, was er gefunden hat, reagieren:
AI AGENT
│
┌───────────┼───────────┐
↓ ↓ ↓
RAG Python APIs
↓ ↓ ↓
Documents Analysis Actions
Aufteilung der Arbeit auf mehrere Agenten
Wenn ein Agent nicht ausreicht, können mehrere spezialisierte Agenten unter der Leitung eines Koordinators arbeiten:
MAIN AGENT
│
┌────────────┼────────────┐
↓ ↓ ↓
Research Agent Coding Agent Data Agent
│ │ │
Search Code Analysis
Die Forschungs-, Programmier- und Datenspezialisten kümmern sich jeweils um ihre eigene Aufgabe, während der Hauptagent die Arbeiten zwischen ihnen verteilt. Dies ist ein Mehr-Agenten-System.
Die Team-Analogie und ihre Grenzen
Die Struktur ähnelt einem Softwareunternehmen mit klar definierten Rollen:
Manager
↓
Developer
↓
Tester
↓
Designer
↓
Deployment
Ein KI-System kann diese Arbeitsteilung nachahmen:
Coordinator Agent
↓
Research Agent
↓
Coding Agent
↓
Testing Agent
↓
Deployment Agent
Der Vergleich ist grob, weist aber eine Richtung vor: Die Koordination spezialisierter Modelle und Tools anstelle der Abhängigkeit von einem einzigen Modell. Jeder zusätzliche Agent erhöht außerdem Kosten und Latenz, weshalb die Spezialisierung tatsächlich notwendig ist.
Wie Agenten Fehler machen
Autonomie bedeutet nicht Notwendigerweise Zuverlässigkeit. Ein Agent kann:
- das falsche Tool wählen
- das Ziel falsch interpretieren
- fehlerhaften Code erzeugen
- irrelevante Informationen abrufen
Fehler verschärfen sich in jeder nachfolgenden Phase:
User Goal
↓
Wrong interpretation
↓
Wrong tool
↓
Wrong result
↓
Wrong action
Je mehr Freiheit ein Agent hat, desto stärker muss seine Arbeit überprüft werden.
Verifizierung in den Schleifenprozess integrieren
Das Anti-Muster ist ein Agent, der handelt und einfach voraussetzt, dass die Aktion funktioniert hat:
Act → Assume success
Das bessere Muster führt vor dem Weitermachen eine explizite Überprüfung durch:
Act
↓
Observe
↓
Verify
↓
Continue
Bei Code besteht die Überprüfung in einem Testlauf mit einer klaren Abzweigung je nach Ergebnis:
Write Code
↓
Run Tests
↓
Tests Pass?
├── NO → Fix
└── YES → Continue
Bei Daten handelt es sich um eine Plausibilitätsprüfung des Ergebnisses, bevor jemand darauf vertraut:
Database Query
↓
Check Result
↓
Is result reasonable?
├── NO → Investigate
└── YES → Continue
Das Überprüfen anstelle des Annahmens ist ein wesentlicher Unterschied zwischen einem adaptiven Agenten und einem einfachen Skript. Ziehen Sie deterministische Überprüfungen wie Tests oder Schema-Validierung dem Beurteilen des Modells durch sich selbst vor.
Autonomie ist ein Regler, kein Schalter
Agenten benötigen keine vollständige Freiheit. Stellen Sie sich eine Skala vor, die mit einem System beginnt, das nur antwortet:
Level 1
AI only answers
Die höheren Ebenen fügen vorgeschlagene Aktionen hinzu, dann Toolaufrufe, anschließend mehrstufiges Planen und schließlich Workflows, die mit eingeschränkter Überwachung ausgeführt werden:
Level 2
AI suggests actionsLevel 3
AI calls toolsLevel 4
AI plans multiple actionsLevel 5
AI executes workflows with limited supervision
Jeder Schritt nach oben auf der Skala erhöht die Anforderungen an den Agenten:
Permissions
Safety
Monitoring
Verification
Human oversight
Die niedrigste Ebene, die das Problem löst, ist in der Regel die sicherste Wahl.
Begrenzung dessen, was ein Agent erreichen darf
Stellen Sie sich einen Agenten vor, der mit all den folgenden Komponenten verbunden ist:
Email
Banking
Files
Database
Cloud infrastructure
Production servers
Ein unbeschränkter Zugriff wäre unvorsichtig. Ein sichereres Design leitet Aktionen über eine Berechtigungsstufe weiter:
AI Agent
↓
Permission Layer
↓
Allowed Tools
↓
Action
Dann werden die Berechtigungen pro Aktion festgelegt: Das Lesen einer Datei mag in Ordnung sein, während Löschvorgänge, Versand per E-Mail, Bereitstellung oder Datenbankzugriff vom Kontext abhängen:
Read file ✓
Delete file ?
Send email ?
Deploy software ?
Access database ?
Das Prinzip ist das der geringsten Befugnisse.
Schutzmaßnahmen und menschliche Genehmigung
Auch Produktionsagenten benötigen strenge Grenzen für ihre Abläufe:
Allowed tools
Maximum actions
Time limits
Budget limits
File permissions
Network permissions
Human approval
Bei hochwirksamen Aktionen bereitet der Agent die Aktion vor und wartet auf eine menschliche Genehmigung:
Agent
↓
Prepare Action
↓
Human Approval
↓
Execute
Das ist ein Design mit menschlicher Einmischung. Begrenzte Schleifen werden in unserem Artikel über begrenzte agente Schleifen in TypeScript behandelt.
Wo Agenten eingesetzt werden
Dieselbe Schleifenstruktur kommt in vielen Bereichen vor.
Softwareentwicklung
Requirement
↓
Coding Agent
↓
Code
↓
Testing
↓
Bug Fixing
Datenanalyse
Dataset
↓
Data Agent
↓
Cleaning
↓
Analysis
↓
Visualization
↓
Report
Kundenservice
Achten Sie auf den Schritt „erlaubte Aktionen“: Support-Mitarbeiter arbeiten innerhalb einer eng definierten, im Voraus genehmigten Reihe von Operationen.
Customer Question
↓
Retrieve Account Information
↓
Understand Problem
↓
Take Permitted Action
↓
Respond
Forschung
Research Question
↓
Search
↓
Read Papers
↓
Extract Information
↓
Compare Findings
↓
Generate Report
Persönliche Produktivität
Goal
↓
Calendar
↓
Email
↓
Documents
↓
Tasks
↓
Summary
Eine andere Art von Schnittstelle
Herkömmliche Software ordnet eine Steuerung einer Funktion und anschließend einem Ergebnis zu:
Button
↓
Function
↓
Result
Ein Agent ordnet ein festgelegtes Ziel einem Plan sowie Toolaufrufen und Aktionen zu:
Goal
↓
Planning
↓
Tools
↓
Actions
↓
Result
Anstatt zu lernen, welche Knöpfe gedrückt werden müssen, beschreibt der Benutzer das gewünschte Ergebnis. Dadurch ändert sich die Mensch-Computer-Interaktion, und die Sichtbarkeit der Aktionen des Agents wird zu einem Gestaltungsanforderung.
Eine Anmerkung zum Wort „Denken“
Wenn wir sagen, ein Agent „denkt“, meinen wir in der Regel rechnerische Schritte: Eingaben interpretieren, planen, Aktionen wählen, Ausgaben bewerten und den Zustand aktualisieren. Das begründet jedoch keine Bewusstseinsebene. Genauer gesagt führen Agenten iterative Zyklen aus Vernunftdenken und Aktionswahl auf ein Ziel hin; „Agent“ beschreibt Verhalten und Architektur, nicht Erfahrungen.
Das Gesamtbild in einem Zyklus
Zusammengesetzt bilden die einzelnen Bestandteile diese Architektur: Planen, über ein Werkzeug handeln, beobachten, überprüfen und anschließend fortfahren oder stoppen.
USER
│
▼
┌─────────┐
│ GOAL │
└────┬────┘
↓
┌─────────────┐
│ AI / LLM │
└──────┬──────┘
↓
PLAN
↓
SELECT ACTION
↓
┌─────────────┼─────────────┐
↓ ↓ ↓
Search Python SQL
↓ ↓ ↓
└─────────────┼─────────────┘
↓
RESULT
↓
OBSERVE
↓
VERIFY
↓
Continue or Finish
Dieser Zyklus steht im Zentrum der meisten agentenbasierten Systeme.
Wohin das führt
Stellen Sie sich vor, Sie bitten Ihren Computer um Ihren wöchentlichen Forschungsbericht, und ein Agent kümmert sich um die gesamte Abfolge:
Open research sources
↓
Collect information
↓
Read documents
↓
Analyze data
↓
Create charts
↓
Write report
↓
Check errors
↓
Prepare final document
Der Computer koordiniert anschließend Anwendungen, anstatt sie nur zu hosten. Auf längere Sicht sieht die Entwicklung so aus:
Rule-Based Software
↓
Machine Learning
↓
Chatbots
↓
LLMs
↓
Tool-Using LLMs
↓
AI Agents
↓
Multi-Agent Systems
Es geht nicht nur um größere Modelle, sondern auch um Modelle, die zunehmend externe Systeme steuern.
Kernpunkte
Ein Chatbot gibt Anleitung, wie man ein Datensatz analysieren kann. Ein agentenbasiertes System könnte ihn finden, laden, analysieren, grafisch darstellen, Probleme markieren, einen Bericht entwerfen, eine Freigabe einholen und ihn übergeben:
Find the dataset
↓
Load it
↓
Analyze it
↓
Create visualizations
↓
Detect problems
↓
Write a report
↓
Ask for approval
↓
Deliver the result
Der Fortschritt erfolgt durch Antworten, Planung, Handeln, Beobachten und Überprüfen. Einige Punkte, die bei der Entwicklung jedes Agenten berücksichtigt werden sollten:
- Der Schleifenmechanismus und nicht das Modell macht ein System zu einem Agenten; begrenzen Sie ihn durch Iterations-, Zeit- und Budgetlimits.
- Delegieren Sie präzise Aufgaben wie Rechenoperationen, Abfragen und Codeausführung an Tools und beschreiben Sie diese Tools klar.
- Überprüfen Sie jeden folgenden Schritt mithilfe von Prüfungen, die nicht auf der Bewertung des Modells selbst beruhen.
Agenten sind weniger Maschinen, die wie Menschen denken, sondern eher Systeme, die Ziele in Aktionen umsetzen. Die entscheidende Frage ist nicht, wie fähig das Modell ist, sondern was Sie bereit sind, es tun zu lassen.
Verwandte Artikel
- Agentic AI Explained: Von Sprachmodellen zu autonomen Agenten — Eine strukturierte Einführung dazu, wie LLMs durch Werkzeuge, Speicherfunktionen, Planung, mehragentige Architekturen und MCP-Integration zu agierenden Systemen werden.
- Verifizieren, was KI-Agenten tun: Berechtigungen, Zustimmungstore und Risikostufen — Erfahren Sie, warum handelnde Agenten eine verifizierende Denkweise benötigen und wie das Prinzip der geringsten Berechtigungen, menschliche Zustimmung sowie risikobasierte Autonomie dazu beitragen, Fehler einzudämmen.
- Statistische Textwasserzeichen gegen C2PA-Berechtigungen in Claude-Ausgaben — Erfahren Sie, wie Claudes auf SynthID basierendes Textwasserzeichen sowie C2PA-Dateiberechtigungen funktionieren, was Detektoren nachweisen können und wie Sie Tools beurteilen, die behaupten, sie entfernen zu können.
- AI-Agenten auf der Grundlage Ihrer bestehenden .NET-Dienste und APIs erstellen — Wie C#-Teams bestehende Dienste und APIs in kontrollierte Agentenwerkzeuge umwandeln können, mit den Regeln für Kontext, Sicherheit und Überwachung, die ihre Sicherheit gewährleisten.
- Lektionen aus Bun’s AI-gestütztem Umstieg von Zig zu Rust: Die eigentliche Arbeit ist die Verifizierung — Was Bun’s agentenunterstützter Wechsel von Zig zu Rust über Testsets als Verträge, Portierungsleitfäden, unsicheren Code und warum die Verifizierung heute das AI-Programmieren einschränkt, lehrt.