Menschliche Freigabe: Approval Gates für Agenten

Was dieser Artikel behandelt

Was Approval Gates sind und wie sie KI-Agenten kontrollierbar machen
Wann Du eine menschliche Freigabe einfordern solltest und wann nicht
Wie Du Freigaben in LangGraph, CrewAI und AutoGen umsetzt
Welche Escalation-Patterns und Veto-Rechte es gibt
Wie Du Approval Fatigue vermeidest und trotzdem sicher bleibst

Einleitung

KI-Agenten arbeiten selbstständig. Sie planen, rufen Tools auf und treffen Entscheidungen ohne menschliches Eingreifen. Genau das macht sie nützlich, aber auch riskant. Eine falsche Entscheidung kann eine E-Mail an alle Kunden auslösen, eine Datenbank löschen oder unerwartete Kosten verursachen.

Menschliche Freigabe, auch Human-in-the-Loop genannt, ist der Schutzmechanismus, der dem Agenten Autonomie lässt, aber bei kritischen Aktionen einen Menschen einschaltet. Der Agent plant, der Mensch prüft, der Agent führt aus. So profitierst Du von Geschwindigkeit, ohne die Kontrolle abzugeben.

Dieser Artikel gehört zur Reihe Agentensicherheit und vertieft die Grundlagen aus Menschliche Freigaben.

Warum brauche ich menschliche Freigabe?

Stell Dir vor, Dein Agent soll Rechnungen automatisch bezahlen. Er liest Rechnungen, prüft Beträge und löst Überweisungen aus. Ohne Freigabe bezahlt er jede Rechnung, die er findet. Was passiert, wenn eine Rechnung über 50.000 Euro enthält, weil ein Lieferant einen Tippfehler gemacht hat? Der Agent bezahlt, weil er keine Plausibilitätsprüfung macht.

Oder stell Dir vor, Dein Agent soll Kundenanfragen beantworten. Er hat ein Tool, um E-Mails zu senden. Ein Kunde fragt nach einer Rückerstattung. Der Agent entscheidet selbststndig, eine Rückerstattung über 10.000 Euro zu versprechen und per E-Mail zu bestätigen. Ohne Freigabe ist das übereits passiert.

Menschliche Freigabe verhindert, dass solche Aktionen ungeprüft durchgeführt werden. Der Agent bereitet alles vor, Du siehst es Dir an, Du stimmst zu oder lehnst ab. Das kostet Sekunden, aber es rettet Dein Geschäft.

Menschliche Freigabe kurz erklärt

Ein Approval Gate ist eine Kontrollstelle im Workflow eines Agenten. Bevor der Agent eine Aktion ausführt, die als kritisch markiert ist, pausiert er. Er stellt Dir vor, was er tun möchte, mit welchen Parametern und warum. Du entscheidest: zustimmen, ablehnen oder anpassen.

Der Kerngedanke lautet: nicht jede Aktion braucht eine Freigabe, aber jede irreversible, externe oder kostenintensive Aktion braucht eine.

Für wen ist dieser Artikel gedacht?

Dieser Artikel richtet sich an Entwicklerinnen und Entwickler, die KI-Agenten mit Frameworks wie LangGraph, CrewAI oder AutoGen aufbauen und kritische Aktionen absichern wollen. Du solltest wissen, wie Tool-Calling funktioniert und was Agentensysteme ausmacht. Grundkenntnisse in Python sind hilfreich für die Code-Beispiele.

Wichtige Begriffe

Begriff	Erklärung
Approval Gate	Kontrollstelle, an der ein Mensch eine geplante Aktion freigeben muss
Human-in-the-Loop	Prinzip, bei dem ein Mensch in den automatisierten Ablauf eingreift
Veto	Recht, eine geplante Aktion des Agenten abzulehnen
Escalation	Weiterleitung einer Entscheidung an eine höhere Instanz
Approval Fatigue	Erschpfungseffekt, wenn zu viele Freigaben angefordert werden
Sync Approval	Freigabe, bei der der Agent wartet, bis der Mensch entscheidet
Async Approval	Freigabe, bei der der Agent weiterarbeitet und später das Ergebnis abholt
Risk Score	Bewertung, wie riskant eine Aktion ist, um Freigaben zu priorisieren
Whitelist	Liste erlaubter Aktionen, die keine Freigabe benötigen
Blacklist	Liste verbotener Aktionen, die nie ausgeführt werden dürfen

Wann eine Freigabe nötig ist

Irreversible Aktionen

Alles, was nicht rückgängig gemacht werden kann, braucht eine Freigabe. Dateien löschen, Datenbankeinträge entfernen, Überweisungen auslösen. Sobald die Aktion ausgeführt ist, gibt es keinen Weg zurück.

Externe Kommunikation

Alles, was nach außen sichtbar wird, braucht eine Freigabe. E-Mails senden, Slack-Nachrichten posten, Social-Media-Posts veröffentlichen, API-Requests an externe Dienste. Ein falscher Inhalt kann Reputation schädigen oder Datenschutzverstoß auslösen.

Kostenintensive Aktionen

Alles, was Geld kostet, braucht eine Freigabe. Cloud-Ressourcen starten, bezahlte API-Aufrufe tätigen, Bestellungen aufgeben. Setze einen Schwellenwert fest: Aktionen unter 10 Euro laufen automatisch, darüber brauchen Freigabe.

Aktionen mit sensiblen Daten

Alles, was sensible Daten verarbeitet, braucht eine Freigabe. Kundendaten exportieren, personenbezogene Daten an externe Services senden, Datenbank-Backups erstellen. Auch wenn die Aktion selbst harmlos wirkt, kann der Kontext kritisch sein.

Implementierungsmuster

Sync Approval

Bei der synchronen Freigabe pausiert der Agent komplett. Er sendet die Anfrage an Dich und wartet. Erst wenn Du antwortest, führt er fort oder bricht ab. Das ist die einfachste Form, aber sie blockiert den gesamten Workflow.

import asyncio

class ApprovalGate:
    def __init__(self):
        self.pending = {}

    async def request_approval(self, action, params, reason):
        approval_id = generate_id()
        self.pending[approval_id] = {
            "action": action,
            "params": params,
            "reason": reason,
            "status": "pending"
        }
        # Agent pausiert hier und wartet
        while self.pending[approval_id]["status"] == "pending":
            await asyncio.sleep(1)
        return self.pending[approval_id]["status"] == "approved"

    def approve(self, approval_id):
        self.pending[approval_id]["status"] = "approved"

    def reject(self, approval_id):
        self.pending[approval_id]["status"] = "rejected"

Async Approval

Bei der asynchronen Freigabe arbeitet der Agent weiter. Er führt Aufgaben aus, die keine Freigabe brauchen, und kommt später auf die Freigabe zurück. Das ist effizienter, aber komplexer zu implementieren.

class AsyncApprovalGate:
    def __init__(self):
        self.queue = []

    def submit_for_approval(self, action, params, reason):
        task_id = generate_id()
        self.queue.append({
            "id": task_id,
            "action": action,
            "params": params,
            "reason": reason,
            "status": "pending"
        })
        return task_id

    def check_status(self, task_id):
        task = next(t for t in self.queue if t["id"] == task_id)
        return task["status"]

    def process_pending(self):
        pending = [t for t in self.queue if t["status"] == "pending"]
        return pending

Risk-Score-basierte Freigabe

Statt jede Aktion manuell zu kategorisieren, kannst Du einen Risk Score berechnen. Aktionen mit niedrigem Score laufen automatisch, Aktionen mit hohem Score brauchen Freigabe.

def calculate_risk_score(action, params):
    risk = 0
    if action in ["delete_file", "drop_table"]:
        risk += 50
    if action in ["send_email", "post_slack"]:
        risk += 30
    if "amount" in params and params["amount"] > 1000:
        risk += 40
    if "external_api" in params:
        risk += 20
    return risk

def needs_approval(risk_score, threshold=50):
    return risk_score >= threshold

Freigaben in Frameworks

LangGraph Interrupt

LangGraph bietet eine eingebaute interrupt-Funktion. Der Agent pausiert an einer definierten Stelle und wartet auf eine Eingabe. Das ist die direkteste Methode, um Approval Gates zu implementieren.

from langgraph.graph import StateGraph, END
from langgraph.checkpoint.memory import MemorySaver

def execute_with_approval(state):
    action = state["planned_action"]
    if is_critical(action):
        # Agent pausiert hier
        approval = interrupt({
            "action": action["name"],
            "params": action["params"],
            "reason": action["reason"]
        })
        if not approval:
            return {"status": "rejected"}
    result = run_tool(action)
    return {"result": result, "status": "completed"}

workflow = StateGraph(AgentState)
workflow.add_node("plan", plan_step)
workflow.add_node("execute", execute_with_approval)
workflow.add_edge("plan", "execute")
workflow.add_edge("execute", END)

app = workflow.compile(checkpointer=MemorySaver())

CrewAI human_input

CrewAI bietet den Parameter human_input=True für Tasks. Der Agent fragt vor der Ausführung nach einer Bestätigung. Das ist einfach, aber weniger granular als LangGraph.

from crewai import Agent, Task, Crew

reviewer = Agent(
    role="Reviewer",
    goal="E-Mails vor dem Versand prüfen",
    backstory="Du bist verantwortlich für die Qualittssicherung.",
    allow_delegation=False
)

send_task = Task(
    description="Verfasse eine Antwort-E-Mail an den Kunden.",
    agent=reviewer,
    human_input=True
)

crew = Crew(agents=[reviewer], tasks=[send_task])
result = crew.kickoff()

AutoGen human_in_the_loop

AutoGen erlaubt es Dir, einen UserProxyAgent einzusetzen. Dieser Agent leitet jede geplante Aktion an einen echten Menschen weiter. Du kannst konfigurieren, wie oft und bei welchen Aktionen der Mensch gefragt wird.

from autogen import ConversableAgent, UserProxyAgent

user_proxy = UserProxyAgent(
    name="Human",
    human_input_mode="ALWAYS",
    max_consecutive_auto_reply=0
)

assistant = ConversableAgent(
    name="Assistant",
    system_message="Du bist ein hilfreicher Agent."
)

user_proxy.initiate_chat(
    assistant,
    message="Fasse die neuesten E-Mails zusammen und sende sie an Slack."
)

Escalation Patterns

Stufenweise Eskalation

Nicht jede Freigabe muss beim ersten Ansprechpartner landen. Du kannst Stufen definieren. Aktionen mit geringem Risiko gehen an den Operator, Aktionen mit hohem Risiko an den Teamleiter, Aktionen mit kritischem Risiko an die Geschäftsführung.

def escalate(approval_request):
    risk = approval_request["risk_score"]
    if risk < 30:
        return "operator"
    elif risk < 70:
        return "team_lead"
    else:
        return "management"

def route_approval(approval_request):
    approver = escalate(approval_request)
    notify(approver, approval_request)
    return wait_for_response(approver)

Timeout-Eskalation

Wenn niemand innerhalb einer bestimmten Zeit antwortet, eskaliert die Anfrage automatisch an die nächste Stufe. Das verhindert, dass kritische Aktionen unbearbeitet bleiben.

import time

def request_with_timeout(approval, timeout_seconds=300):
    start = time.time()
    while time.time() - start < timeout_seconds:
        if check_response(approval["id"]):
            return get_response(approval["id"])
        time.sleep(5)
    # Timeout erreicht, eskaliere
    return escalate_to_next_level(approval)

Veto-Rechte

Ein Veto ist das Recht, eine Aktion abzulehnen, ohne eine Alternative vorzuschlagen. Veto-Rechte sollten klar definiert sein. Jeder Approver kann ein Veto einlegen, aber nicht jeder Approver kann eine Aktion freigeben. Das verhindert, dass eine einzelne Person kritische Aktionen ohne Kontrolle durchführt.

Approval Fatigue vermeiden

Das Problem

Wenn Dein Agent jede kleine Aktion zur Freigabe vorlegt, bestätigst Du irgendwann blind. Du klickst “approve”, ohne zu lesen. Das ist gefährlicher als keine Freigabe, weil es ein falsches Sicherheitsgefühl erzeugt.

Lösungen

Granularitt erhöhen: Fordere Freigaben nur für Aktionen, die wirklich kritisch sind. Lesezugriffe, Berechnungen und interne Türansformationen brauchen keine Freigabe.

Risk Scores nutzen: Automatisiere die Entscheidung, ob eine Freigabe nötig ist. Niedriger Score bedeutet automatische Ausführung, hoher Score bedeutet Freigabe.

Batches bilden: Wenn der Agent 50 ähnliche Aktionen ausführen will, zeige sie als Liste und frage einmal, ob alle freigegeben werden. Statt 50 einzelner Freigaben brauchst Du eine.

Whitelists pflegen: Aktionen, die regelmäßig freigegeben werden, können auf eine Whitelist. Sie laufen dann automatisch. überprüfe die Whitelist regelmäßig.

Typische Stolpersteine

Zu viele Freigaben: Wenn jede Aktion eine Freigabe braucht, bestätigt niemand mehr richtig. Setze Freigaben gezielt ein, nur bei kritischen Aktionen.
Keine klaren Kriterien: Wenn nicht definiert ist, wann eine Freigabe nötig ist, entscheiden Entwickler unterschiedlich. Dokumentiere die Kriterien und automatisiere sie über Risk Scores.
Kein Timeout: Wenn ein Approver nicht reagiert, steht der Agent still. Definiere Timeouts und Escalation-Stufen, damit der Workflow weiterläuft.
Freigaben ohne Kontext: Der Agent fordert eine Freigabe, aber der Approver sieht nicht, warum. Zeige immer die geplante Aktion, die Parameter und die Begründung des Agenten.
Keine Protokollierung: Wer hat was freigegeben? Wenn Du das nicht protokollierst, fehlt die Nachvollziehbarkeit. Speichere jede Freigabe mit Zeitstempel, Approver und Entscheidung.
Sync Approval bei langen Workflows: Wenn der Agent bei jeder Freigabe komplett pausiert, dauert der Workflow ewig. Nutze Async Approval, wo möglich, damit der Agent weiterarbeitet.
Keine Trennung von Rollen: Wenn derselbe Mensch plant, freigibt und ausführt, gibt es keine Kontrolle. Türenne die Rollen: der Agent plant, ein anderer Mensch gibt frei.
Veto ohne Begründung: Wenn jemand ein Veto einlegt, ohne zu sagen warum, lernt der Agent nichts. Fordere eine Begründung bei jedem Veto und speichere sie im Audit Log.

Hardware, Kosten und Sicherheit

Menschliche Freigaben kosten keine Hardware, aber sie kosten Zeit. Jede Freigabe verzögert den Workflow um die Zeit, die ein Mensch braucht, um die Anfrage zu prüfen. Bei synchronen Freigaben steht der Agent still, bei asynchronen Freigaben läuft er weiter, aber die kritische Aktion wartet.

Die Kosten für die Implementierung sind gering. LangGraph, CrewAI und AutoGen bieten eingebaute Mechanismen. Du benötigst lediglich eine Benutzeroüberflche, über die Approver Freigaben erteilen können. Das kann ein Chat-Interface, ein Web-Dashboard oder eine E-Mail-basierte Lösung sein.

Sicherheitstechnisch sind Freigaben eine der wichtigsten Maßnahmen. Sie sind die letzte Barriere, bevor eine irreversible Aktion ausgeführt wird. Kombiniere sie mit den anderen Maßnahmen aus der Agentensicherheit: Sandbox, Tool-Berechtigungen und Guardrails. Wenn Du lokal mit Ollama arbeitest, gelten die gleichen Prinzipien.

Wie der Agent entscheidet, welche Aktionen er überhaupt plant, hngt mit seiner Planung und Reflexion zusammen. Eine gute Planung reduziert die Anzahl kritischer Aktionen und damit die Anzahl nötiger Freigaben.

Weiterführende Links

Agentensicherheit - Übersicht aller Sicherheitsmaßnahmen
Sicherer Betrieb - Übersicht aller Artikel zum sicheren Betrieb
Menschliche Freigaben - Grundlagen zu Human-in-the-Loop
Tool-Calling - Wie Agenten Tools aufrufen
Agentensysteme - Architektur von Agentensystemen
Planung und Reflexion - Wie Agenten planen
LangGraph - Framework mit Interrupt-Untersttzung
Ollama - Lokale KI-Modelle ausführen

FAQ

Was ist ein Approval Gate?

Ein Approval Gate ist eine Kontrollstelle im Workflow eines KI-Agenten. Bevor der Agent eine als kritisch markierte Aktion ausführt, pausiert er und fordert die Freigabe eines Menschen. Erst nach der Freigabe wird die Aktion ausgeführt.

Wann brauche ich eine menschliche Freigabe?

Menschliche Freigaben sind bei allen Aktionen sinnvoll, die irreversibel sind, externe Auswirkungen haben oder Kosten verursachen. Dazu gehören Datei-Lschungen, E-Mail-Versand, API-Aufrufe an externe Dienste und Zahlungen.

Was ist der Unterschied zwischen Sync und Async Approval?

Bei Sync Approval pausiert der Agent komplett und wartet auf die Entscheidung. Bei Async Approval arbeitet der Agent weiter und prüft später, ob die Freigabe erteilt wurde. Async ist effizienter, aber komplexer.

Was ist Approval Fatigue?

Approval Fatigue tritt auf, wenn ein Agent zu viele Freigaben anfordert. Die Approver bestätigen blind, ohne die Anfragen zu prüfen. Das ist gefährlich, weil es ein falsches Sicherheitsgefühl erzeugt. Lösung: Freigaben gezielt einsetzen und Risk Scores nutzen.

Was ist ein Veto-Recht?

Ein Veto-Recht gibt einem Approver die Möglichkeit, eine geplante Aktion abzulehnen, ohne eine Alternative vorschlagen zu müssen. Veto-Rechte sollten klar definiert und an Rollen gebunden sein.

Wie implementiere ich Freigaben in LangGraph?

LangGraph bietet die interrupt-Funktion. Der Agent pausiert an einer definierten Stelle im Graph und wartet auf eine Eingabe. Du kannst die Eingabe über einen Checkpointer speichern und später fortsetzen.

Brauche ich Freigaben bei lokalen Modellen?

Ja. Auch wenn Du mit Ollama lokal arbeitest und keine Daten nach außen sendest, kann der Agent irreversible Aktionen ausführen. Freigaben sind unabhängig davon, wo das Modell läuft.

Was ist ein Risk Score?

Ein Risk Score ist eine numerische Bewertung, wie riskant eine Aktion ist. Er wird aus Faktoren wie Aktionstyp, Parametern und Kontext überechnet. Aktionen mit hohem Score brauchen Freigabe, Aktionen mit niedrigem Score laufen automatisch.

Wie vermeide ich, dass der Agent bei Freigaben stehen bleibt?

Nutze Async Approval. Der Agent führt nicht-kritische Aufgaben weiter aus, whörend er auf die Freigabe für die kritische Aktion wartet. Alternativ kannst Du Timeouts setzen und bei überziehung eskalieren.

Kann ich Freigaben automatisieren?

Teilweise. Du kannst Risk Scores berechnen und Aktionen mit niedrigem Score automatisch freigeben. Aktionen mit hohem Score sollten immer einen Menschen einbeziehen. Eine vollständige Automatisierung widerspricht dem Sinn von Human-in-the-Loop.

Wie protokolliere ich Freigaben?

Speichere für jede Freigabe den Zeitstempel, den Approver, die geplante Aktion, die Parameter und die Entscheidung (approved, rejected, modified). Das Protokoll sollte äußerhalb der Reichweite des Agenten liegen, damit er es nicht manipulieren kann.

Quellen

LangGraph Documentation: Human-in-the-Loop Workflows
CrewAI Documentation: Human Input in Tasks
AutoGen Documentation: UserProxyAgent and Human-in-the-Loop
OWASP: Top 10 for Large Language Model Applications
NIST: AI Risk Management Framework

Täglicher Artikel