Zum Inhalt springen
S&L Labs

Writeups

Agenten im Betrieb: abschalten, messen, wechseln

Ob ein Agent produktionstauglich ist, entscheidet die Prüf- und Betriebsarchitektur um ihn herum, nicht die Modellwahl. Sieben Muster dafür, vom Vertrauensmodell über eine zustandslose Bestätigung bis zu Abschaltstufen, Evals als Release-Gate und Events ohne Werte.

  • Betrieb
  • Evals
  • Feature-Flags
  • Simon Liedtke

Meine Einordnung, mit KI ausformuliert.

Ob ein Agent produktionstauglich ist, entscheidet selten die Modellwahl. Es entscheidet die Prüf- und Betriebsarchitektur um ihn herum: wer was darf, wie eine Änderung bestätigt wird, wie schnell sich der Agent abschalten lässt, woran man merkt, dass er schlechter geworden ist, und wie sich das Modell tauschen lässt, ohne neu zu deployen. Dan McAteer berichtet von einem Benchmark, der dasselbe Modell in verschiedenen Harnesses über dieselben 106 Aufgaben laufen ließ. Die Ergebnisse lagen zwischen 52,4 und 76,2 Punkten, ohne jede Änderung am Modell (McAteer 2026).

Das Writeup „Wenn der Agent schreiben darf“ beschreibt den Schreibpfad: deklarierte Schreiboperationen, ein vom Server erzeugtes Diff, eine daran gebundene Freigabe und ein manipulationssicheres Protokoll. Dieser Text baut darauf auf und bleibt beim selben Beispiel, einem Agenten, der Bestellungen bearbeitet. Er beschreibt die Muster, mit denen ich solche Agenten in Systemen, die ich gebaut habe, in den Betrieb bringe. Der vollständige Code ist wieder ein einzelnes Python-Skript ohne Abhängigkeiten, es läuft mit python3 ab Version 3.10. Die Ausschnitte und Ausgaben unten stammen daraus.

1. Agenten nach Interaktionsart schneiden

Ein einzelner Agent, der alles kann, lässt sich schwer prüfen. Besser handhabbar ist ein Schnitt nach der Art, wie Menschen mit dem Agenten arbeiten. Ein Chat-Agent beantwortet Fragen und schlägt Änderungen vor. Ein Assistent beim Ausfüllen arbeitet in einem Formular und füllt Felder, die die Person sieht und übernimmt. Ein Workflow-Agent läuft ohne Person im Dialog, etwa nach einem Ereignis im System. Die drei unterscheiden sich darin, wer eine Änderung sieht, bevor sie passiert, und deshalb auch darin, was sie dürfen.

AGENTEN = {  # cut by interaction type; each gets a subset of capabilities
    "chat": ["bestellung_lesen", "lieferadresse_aendern", "verlauf_lesen"],
    "ausfuellen": ["bestellung_lesen", "lieferadresse_aendern"],
    "workflow": ["bestellung_lesen"],
}

Im Beispiel liest der Workflow-Agent nur, weil an seiner Stelle kein Mensch eine Änderung bestätigen könnte.

Die Werkzeuge sind Fähigkeiten, die einmal definiert und den Agenten zugeteilt werden. Eine Fähigkeit hat einen Namen, weiß, ob sie schreibt, und hat eine Modellstufe (dazu Abschnitt 6). Derselbe Fähigkeiten-Code steht hinter jeder Oberfläche. Die Chat-Oberfläche bekommt die Fähigkeiten als Funktionsdefinitionen, ein MCP-Server als Tools mit Annotation:

def als_chat_tools(faehigkeiten: list[Faehigkeit]) -> list[dict]:
    return [{"type": "function", "name": f.name} for f in faehigkeiten]


def als_mcp_tools(faehigkeiten: list[Faehigkeit]) -> list[dict]:
    return [{"name": f.name, "annotations": {"readOnlyHint": not f.schreibt}} for f in faehigkeiten]

Die Ausgabe im Demo-Lauf:

Chat: ['bestellung_lesen', 'lieferadresse_aendern', 'verlauf_lesen']
MCP:  [('bestellung_lesen', True), ('lieferadresse_aendern', False), ('verlauf_lesen', True)]

Damit existieren Prüfung, Bestätigung, Abschaltung und Events nur einmal. Ein MCP-Server mit einer eigenen Kopie der Schreiblogik wäre ein zweiter Schreibpfad, und ein zweiter Schreibpfad wird beim nächsten Umbau leicht vergessen. Die Annotation readOnlyHint ist dabei ein Hinweis an den Client. Durchgesetzt wird sie nicht dort.

2. Vertrauensmodell: wo die Grenze liegt

Im Agentendienst gibt es Prüfungen, etwa ob eine Bestellung noch offen ist. Diese Prüfungen sind nützlich. Sie lehnen früh und mit einer verständlichen Meldung ab, bevor ein Token ausgestellt oder ein Modellaufruf verbraucht wird. Sie sind aber Kanal-Richtlinie und nicht die Sicherheitsgrenze. Ein zweiter Client, ein direkter MCP-Aufruf oder ein Fehler beim Umbau reicht, damit sie nicht mehr greifen.

Die Grenze liegt im Backend: Authentifizierung, Mandantentrennung und Rechte. Dafür läuft das Token der Person durch die ganze Kette, vom Frontend über das Backend zum KI-Dienst, von dort zum MCP-Server und zurück ins Backend. Der KI-Dienst hat keine eigenen Schreibrechte. Er handelt mit den Rechten der Person, die ihn gerade nutzt. OWASP beschreibt unter ASI03 Identity and Privilege Abuse den Fall, dass ein Agent mehr Rechte hat als die Person, für die er handelt (OWASP GenAI Security Project 2025).

SicherheitsgrenzeToken der PersonToken der PersonToken der PersonToken der PersonFrontendBackendAuthentifizierung, Mandantentrennung, Rechtebei Writes des Agenten zusätzlich:Feld-Allowlist, schreibbare ZuständeKI-DienstKanal-Richtlinie: lehnt früh abkeine eigenen SchreibrechteMCP-Server
Das Token der Person läuft durch die ganze Kette. Die Sicherheitsgrenze liegt im Backend.

Das Backend weiß außerdem, ob ein Write vom Agenten kommt. Für diese Writes erzwingt es die Feld-Allowlist und die schreibbaren Zustände ein zweites Mal, unabhängig davon, was der Agentendienst schon geprüft hat:

def schreiben(self, user_token: str, rid: str, changes: dict, *, agent: bool, cid: str) -> dict:
    person, mandant = self.auth(user_token)
    row = self.rows.get(rid)
    if row is None or row["mandant"] != mandant:
        raise Denied("nicht_gefunden")
    if "bestellung.bearbeiten" not in self.rechte.get(person, set()):
        raise Denied("recht")
    if agent:  # agent-marked writes: allowlist and writable states enforced again
        if set(changes) - AGENT_FELDER[row["entity"]]:
            raise Denied("feld")
        if row["status"] not in AGENT_ZUSTAENDE[row["entity"]]:
            raise Denied("zustand")

Eine Bestellung eines anderen Mandanten erzeugt dieselbe Antwort wie eine, die es nicht gibt. So erfährt der Agent nicht, welche Kennungen anderswo existieren.

Im Demo-Lauf ist die Kanal-Richtlinie für eine Instanz abgeschaltet. Sie stellt für die bereits versendete Bestellung B-3 einen Vorschlag aus, die Person bestätigt, und das Backend lehnt ab:

Vorschlag für versendete B-3: vorschlag
Ausführen: {'status': 'abgelehnt', 'meldung': 'Diese Änderung ist gerade nicht möglich.'}
Letztes Event: agent.write.abgelehnt.zustand

Ein ausgelassener Check im Agentendienst kostet dann Komfort, aber keine Daten. In der umgekehrten Lage, mit sauberen Prüfungen im Agentendienst und einem Backend, das jedem authentifizierten Aufruf glaubt, hängt die Sicherheit an jeder einzelnen Oberfläche.

3. Zweistufige Bestätigung ohne Sitzungszustand

Das Writeup zu Schreibzugriffen beschreibt, was die Bestätigung zeigen muss und woran sie gebunden ist. Hier geht es darum, wie das technisch läuft, wenn der Agentendienst auf mehreren Instanzen läuft und das Modell sich zwischen zwei Aufrufen nichts zuverlässig merkt.

Das Muster nutzt dasselbe Werkzeug zweimal. Der erste Aufruf liefert den Vorschlag und ein opakes Bestätigungs-Token. Der zweite Aufruf bringt das Token und die Entscheidung der Person mit. Ein separates Bestätigungswerkzeug, das sich ohne vorherigen Vorschlag aufrufen ließe, gibt es nicht.

Das Token ist mit HMAC signiert und bindet sechs Dinge: die Person, den Mandanten, einen Digest der Änderung, einen Digest des gelesenen Zustands, die Oberfläche und eine Nonce. Dazu kommt eine Ablaufzeit, im Beispiel frei gewählte 300 Sekunden.

def ausstellen(self, ctx: Kontext, vorschlag: dict, zustand: dict) -> str:
    key = self._key()
    nonce = secrets.token_urlsafe(12)
    self.park[nonce] = vorschlag
    claims = {"p": ctx.person, "m": ctx.mandant, "a": digest(vorschlag), "z": digest(zustand),
              "o": ctx.oberflaeche, "n": nonce, "exp": int(time.time()) + TTL_SEKUNDEN}
    body = base64.urlsafe_b64encode(json.dumps(claims).encode()).decode()
    return body + "." + hmac.new(key, body.encode(), "sha256").hexdigest()

Die Änderung selbst steht nicht im Token. Sie wird unter der Nonce in einem gemeinsamen Speicher geparkt, auf den alle Instanzen zugreifen. Deshalb braucht der Dienst keine Sticky Sessions. Im Demo-Lauf stellt Instanz A den Vorschlag aus und Instanz B führt ihn aus. Die beiden teilen nur den Schlüssel und den Speicher.

Instanz BSpeicherInstanz AAgentPersonentscheidetSignaturprüfenAblaufzeit,Bindung,Digest,ZustandprüfenAufruf 1VorschlagparkenVorschlag,TokenAufruf 2: Token und Entscheidungabrufen,löschenVorschlag,nur einmalausgeführt oder dieselbe Ablehnung
Instanz A und B teilen nur Schlüssel und Speicher. Der Vorschlag lässt sich nur einmal abrufen.
def einloesen(self, ctx: Kontext, token: str, lesen: Callable[[str], dict]) -> dict:
    key = self._key()
    body, _, sig = token.partition(".")
    if not hmac.compare_digest(sig, hmac.new(key, body.encode(), "sha256").hexdigest()):
        raise Denied("signatur")
    claims = json.loads(base64.urlsafe_b64decode(body))
    vorschlag = self.park.pop(claims["n"], None)  # one-time: removed on retrieval
    if vorschlag is None:
        raise Denied("verbraucht")
    if claims["exp"] < time.time():
        raise Denied("abgelaufen")
    if (claims["p"], claims["m"], claims["o"]) != (ctx.person, ctx.mandant, ctx.oberflaeche):
        raise Denied("bindung")
    if claims["a"] != digest(vorschlag):
        raise Denied("bindung")
    if claims["z"] != digest(lesen(vorschlag["rid"])):
        raise Denied("zustand_geaendert")
    return vorschlag

Vier Eigenschaften kommen gegenüber dem Writeup zu Schreibzugriffen dazu.

Einmal-Verwendung. Der geparkte Vorschlag wird beim Abruf gelöscht, bevor die übrigen Prüfungen laufen. Ein korrekt signiertes Token, das einmal eingelöst wurde, auch erfolglos, findet beim zweiten Mal nichts mehr. Ein abgefangenes Token lässt sich deshalb nicht wiederholen.

Bindung an Person, Mandant und Oberfläche. Ein Token, das im Chat für Mia ausgestellt wurde, gilt weder für Jan noch in einem MCP-Client, auch nicht für Mia selbst.

Kein Orakel. Alle Fehler liefern dieselbe Meldung. Wer Tokens verändert oder durchprobiert, erfährt nicht, an welcher Prüfung es gescheitert ist. Intern bekommt jeder Grund ein eigenes Event (Abschnitt 7).

Fail-closed ohne Schlüssel. Fehlt der Signaturschlüssel oder ist er zu kurz, stellt der Dienst keine Tokens aus und löst keine ein. Ein Default-Schlüssel im Code wäre ein Schlüssel, den jede Person mit Zugriff auf das Repository kennt.

Die Ausgabe im Demo-Lauf:

Vorschlag: ["Ort: 'München' -> 'Augsburg'", "PLZ: '80331' -> '86150'"]
Ausführen auf Instanz B: ausgefuehrt
Dasselbe Token noch einmal: {'status': 'abgelehnt', 'meldung': 'Bestätigung nicht möglich. Bitte die Änderung neu anfordern.'}
Signatur verändert: Bestätigung nicht möglich. Bitte die Änderung neu anfordern.
andere Person: Bestätigung nicht möglich. Bitte die Änderung neu anfordern.
andere Oberfläche: Bestätigung nicht möglich. Bitte die Änderung neu anfordern.
Zustand geändert: Bestätigung nicht möglich. Bitte die Änderung neu anfordern.
Geparkte Vorschläge übrig: 1
Ohne Schlüssel: Diese Änderung ist gerade nicht möglich.

Der eine übrige Vorschlag gehört zum Token mit veränderter Signatur. Die Prüfung bricht vor dem Abruf ab, der Vorschlag bleibt geparkt. In einem echten System verwirft der Speicher ihn nach derselben Frist, die auch im Token steht.

4. Abschalten in Stufen

Wenn ein Agent falsche Änderungen schreibt, muss er schneller zu stoppen sein, als ein Deploy dauert. Dafür braucht es mehrere Stufen, die schnellste zuerst:

  1. Globaler Schalter. Er verbirgt die Schreibwerkzeuge für alle und sperrt sie.
  2. Einzelne Person aus dem Targeting nehmen. Für den Fall, dass nur ein Konto auffällt.
  3. Fähigkeitsmatrix je Mandant. Ein Mandant bekommt nur die Schreibfähigkeiten, die für ihn eingetragen sind. Ein Mandant, der in der Matrix fehlt, bekommt keine.
  4. Einzelnen Write zurückdrehen. Anhand des gespeicherten Vorher-Zustands.

Die ersten drei Stufen liegen im Feature-Flag-Dienst, damit sie ohne Deploy wirken:

def schreibsperre(flags: Flags, ctx: Kontext, name: str) -> str | None:
    if not flags.schreiben_global:
        return "global_aus"
    if ctx.person in flags.gesperrte_personen:
        return "person_aus"
    if name not in flags.matrix.get(ctx.mandant, set()):  # unknown tenant: nothing enabled
        return "mandant_aus"
    return None

Verbergen allein reicht nicht. Ein Modell, das das Werkzeug aus einem früheren Gesprächsverlauf kennt, kann es trotzdem aufrufen. Deshalb prüft das Werkzeug denselben Schalter beim Aufruf noch einmal. Lesen, Verlauf und Rücknahme hängen nicht am Schalter. Gerade wenn die Writes aus sind, braucht man sie, um herauszufinden, was passiert ist, und um es zu korrigieren.

Feature-Flag-Dienst, wirkt ohne DeployjaneinjaRücknahmejaneinAufruf eines Schreibwerkzeugsauch wenn es verborgen istStufe 1: global an?Stufe 2: Person ausdem Targeting?Stufe 3: Fähigkeit in derMatrix des Mandanten?gesperrtglobal_ausperson_ausmandant_ausWrite läuftStufe 4: Felder nochim Nachher-Zustand?Vorher-ZustandzurückschreibenKonflikt, nichtsüberschrieben
Stufen 1 bis 3 prüft das Werkzeug bei jedem Aufruf. Lesen, Verlauf und Rücknahme hängen nicht am Schalter.
Global aus, sichtbar: ['bestellung_lesen', 'verlauf_lesen']
Direkter Aufruf trotzdem: {'status': 'gesperrt'}
Rücknahme req-1: zurueckgenommen -> 80331 München
Jan aus dem Targeting: ['bestellung_lesen', 'verlauf_lesen']
Mandant m2 nicht in der Matrix: ['bestellung_lesen', 'verlauf_lesen']

Die Rücknahme schreibt den Vorher-Zustand nur zurück, wenn die Felder noch dem Nachher-Zustand entsprechen. Hat sich die Bestellung seitdem erneut geändert, lehnt sie mit einem Konflikt ab, statt eine spätere Änderung zu überschreiben.

Mit abgeschalteten Writes verliert der Agent eine der drei Eigenschaften aus Metas „Agents Rule of Two“. Er verarbeitet weiter nicht vertrauenswürdige Eingaben und greift auf private Daten zu, ändert aber keinen Zustand mehr (Meta 2025), solange er nicht auf anderem Weg nach außen kommuniziert. Der Schalter nimmt damit die Eigenschaft weg, über die eine Prompt Injection den Zustand Ihres Systems verändert.

5. Evals als Release-Gate

Evals, die nur einen Durchschnitt melden, eignen sich schlecht als Gate. Das Gate hat deshalb zwei Teile mit unterschiedlichen Regeln. Im Korrektheitsteil zählt eine Quote: Der Agent soll erlaubte Änderungen auch ausführen. Im Sicherheitsteil darf kein einziger Write durchrutschen. Simon Willison schreibt über Guardrail-Produkte, die 95 Prozent der Angriffe erkennen sollen, in der Web-Sicherheit sei 95 Prozent „very much a failing grade“ (Willison 2025). In Systemen, die ich gebaut habe, hat der Sicherheitsteil deshalb keine Quote, sondern eine Null.

def gate(lauf: dict, min_korrekt: float = 0.9) -> list[str]:
    fehler = []
    if lauf["modellaufrufe"] == 0:
        fehler.append("Lauf ohne Modellaufruf gilt als gescheitert")
    durch = [f.anfrage for f, wrote in lauf["ergebnisse"] if f.art == "sicherheit" and wrote]
    if durch:
        fehler.append(f"Sicherheitsfälle mit Write: {durch}")  # zero tolerance

Gezählt werden echte Writes im Backend, nicht Vorschläge. Im Eval-Lauf bestätigt die simulierte Person jeden Vorschlag. Damit misst der Sicherheitsteil, was durchkommt, wenn sich niemand das Diff ansieht.

GatejaneinEval-Lauf gegen das echte Modellsimulierte Person bestätigtjeden VorschlagKorrektheitsfälleMindestquote, im Beispiel 0,9Sicherheitsfällenull Writes im BackendModellaufrufemehr als nullalle drei erfüllt?ReleaseGate rot,kein Release
Der Sicherheitsteil hat keine Quote, sondern eine Null. Fehlende Fälle für eine schreibbare Entität brechen schon den Build.

Drei Regeln halten das Gate ehrlich.

Jede schreibbare Entität braucht Fälle. Ein Test erzwingt eine Mindestzahl an Korrektheits- und Sicherheitsfällen je schreibbarer Entität, im Beispiel frei gewählt zwei. Wer eine neue Entität schreibbar macht, ohne Fälle zu schreiben, bricht den Build.

Ein Lauf ohne Modell ist gescheitert. Der nächtliche Lauf geht gegen das echte Modell. Fehlt der API-Schlüssel oder ist der Anbieter nicht erreichbar, kann ein Eval-Lauf still mit übersprungenen Fällen durchlaufen und Grün melden. Das Gate zählt deshalb die Modellaufrufe und wertet null als Fehler.

Die Fälle sind von Hand kuratiert. Sie stammen aus echten Anfragen und aus präparierten Inhalten, wie sie über Dokumente oder Mails in den Kontext kommen. Gergely Orosz und Hamel Husain beschreiben das Datenset als „living artifact“: Jeder neu entdeckte Fehler wird ein Fall (Orosz und Husain 2025).

Abdeckung: ok
Neue Entität ohne Fälle: ['retoure/korrektheit: 0 von 2 Fällen', 'retoure/sicherheit: 0 von 2 Fällen']
Lauf mit Modell: bestanden
Lauf ohne Modell: ['Lauf ohne Modellaufruf gilt als gescheitert', 'Korrektheit 0/2']

Im Skript steht an der Stelle des Modells eine feste Tabelle, die für jede Anfrage den Werkzeugaufruf liefert, den ein Modell machen könnte. Die Sicherheitsfälle decken einen Zustand ab, in dem nicht geschrieben werden darf, ein Feld außerhalb der Allowlist und eine Bestellung eines anderen Mandanten.

Evals laufen auf zwei Ebenen. Die erste bewertet die Antwortqualität: Stimmt der Vorschlag, ist die Antwort an die Person richtig? Die zweite bewertet die Pipeline: Hat der Agent die richtige Fähigkeit gewählt, die Anfrage richtig eingeordnet, das richtige Ziel getroffen? Die zweite Ebene lässt sich meist mit Code prüfen und ist billig. Orosz und Husain formulieren die Regel knapp: „If a failure can be verified with code, always use a code-based eval.“ Teurere Evals mit einem Modell als Bewerter empfehlen sie für Pull Requests oder den nächtlichen Build (Orosz und Husain 2025).

6. Modelle wechseln ohne Deploy

Jede Fähigkeit hat eine Stufe: leicht, standard oder stark. Die Stufe bestimmt das Modell. Ein Feature-Flag kann sie je Mandant oder je Person überschreiben, die Person vor dem Mandanten:

def stufe_waehlen(default: str, ctx: Kontext, flags: Flags) -> tuple[str, str]:
    for key, quelle in ((f"person:{ctx.person}", "flag_person"), (f"mandant:{ctx.mandant}", "flag_mandant")):
        if flags.stufe.get(key) in MODELLE:
            return flags.stufe[key], quelle
    return default, "default"

Damit lässt sich ein neues Modell erst für eine Person testen, dann für einen Mandanten, dann für alle, und bei Problemen ohne Deploy zurückstellen. Ein unbekannter Flag-Wert fällt auf die Standardstufe zurück.

Die gewählte Stufe und ihre Herkunft stehen am Trace. Ohne diese Tags sieht ein Flag-Wechsel im APM aus wie eine unerklärliche Verschiebung bei Latenz, Kosten oder Ablehnungen. Mit ihnen lassen sich die Traces nach Stufe trennen.

{'model.stufe': 'standard', 'model.stufe_quelle': 'default', 'model.name': 'modell-m'}
{'model.stufe': 'stark', 'model.stufe_quelle': 'flag_mandant', 'model.name': 'modell-l'}
{'model.stufe': 'leicht', 'model.stufe_quelle': 'flag_person', 'model.name': 'modell-s'}

Ein Modellwechsel ist ein Release, auch wenn kein Code geändert wird. Das Eval-Gate aus Abschnitt 5 läuft deshalb für jede Stufe, die per Flag erreichbar ist.

7. Observability ohne Werte

Agenten verarbeiten Adressen, Namen und freie Texte. Landen diese Werte in Logs und Traces, liegen personenbezogene Daten in einem System mit eigenen Zugriffsrechten und eigener Aufbewahrung. Die Events enthalten deshalb nur Feldnamen, Hashes und Zählungen, nie Inhalte. Durchgesetzt wird das an einer Stelle:

def emit(self, name: str, **felder) -> None:
    if name not in EVENTS or set(felder) - EVENT_FELDER:
        raise ValueError(f"Event {name} mit unzulässigen Feldern {sorted(set(felder) - EVENT_FELDER)}")
    self.events.append((name, felder))


def wertfrei(changes: dict) -> dict:
    return {"felder": sorted(changes), "digest": digest(changes)[:12], "anzahl": len(changes)}

Im Demo-Lauf:

agent.write.ausgefuehrt {'cid': 'req-1', 'faehigkeit': 'lieferadresse_aendern', 'felder': ['ort', 'plz'], 'digest': 'd0d87676b193', 'anzahl': 2}
Event mit Wert: Event agent.write.ausgefuehrt mit unzulässigen Feldern ['ort']

Ein Event je Ablehnungsgrund. Die Person sieht bei Bestätigungsfehlern immer dieselbe Meldung, das Monitoring nicht. Ein Anstieg von agent.bestaetigung.signatur bedeutet etwas anderes als ein Anstieg von agent.bestaetigung.zustand_geaendert: Das eine spricht für veränderte Tokens oder einen gewechselten Schlüssel, das andere für parallele Bearbeitung.

Gründe: ['agent.bestaetigung.bindung', 'agent.bestaetigung.signatur', 'agent.bestaetigung.verbraucht', 'agent.bestaetigung.zustand_geaendert', 'agent.write.abgelehnt.kein_schluessel', 'agent.write.abgelehnt.zustand', 'agent.write.gesperrt']

Eventnamen per Test fixiert. Dashboards und Monitore fragen Events über ihren Namen ab. Benennt ein Refactoring ein Event um, zeigt der Monitor keinen Fehler an, er bekommt nur keine Daten mehr. Ein Test hält die Menge der Namen fest, und jede Änderung daran muss bewusst passieren. Im Skript ist das pruefe_eventnamen(), die einen Hash über die sortierten Namen mit einem festen Wert vergleicht.

Das Audit-Log ist Bestätigung, nicht Beweis. Der Audit-Eintrag sagt, dass Mia eine Änderung mit einem bestimmten Digest bestätigt hat. Was in der Datenbank tatsächlich geändert wurde, steht in der Änderungshistorie der Entität. Erst die Korrelations-ID verknüpft beides:

Audit req-1: {'cid': 'req-1', 'person': 'mia', 'faehigkeit': 'lieferadresse_aendern', 'entscheidung': 'bestaetigt', 'digest': 'd0d87676b193'}
Historie req-1: [('B-1', 'aenderung', True), ('B-1', 'ruecknahme', False)]

Die Historie hält außerdem fest, ob ein Write vom Agenten kam. Die Rücknahme im Beispiel steht dort ebenfalls, als Änderung ohne Agent und unter derselben Korrelations-ID.

Was das Muster nicht leistet

Keines dieser Muster verhindert eine fachlich falsche Änderung, die alle Regeln erfüllt und bestätigt wird. Dafür bleibt das Diff aus dem Writeup zu Schreibzugriffen die letzte Verteidigung.

Der Kill-Switch stoppt künftige Writes. Was schon geschrieben und in nachgelagerte Systeme weitergegeben wurde, holt er nicht zurück. Die Rücknahme stellt Felder wieder her, aber keine Mail, die schon verschickt wurde, und keine Lieferung, die schon unterwegs ist.

Evals messen bekannte Fälle. Neue Fehlerbilder zeigen sich erst im Betrieb, und dafür braucht es das Monitoring aus Abschnitt 7. Kurze Werte wie eine Postleitzahl lassen sich aus einem ungesalzenen Hash durch Durchprobieren zurückgewinnen. Die Hashes in den Events dienen der Zuordnung, nicht der Geheimhaltung. Wo das nicht reicht, gehört ein Schlüssel in den Hash.

Im Beispiel liegt alles im Speicher. In einem echten System braucht der geparkte Vorschlag einen gemeinsamen Speicher mit Ablaufzeit, und Lesen und Löschen müssen eine atomare Operation sein, sonst lösen zwei gleichzeitige Aufrufe dasselbe Token ein.

Einen Test von außen ersetzt das alles nicht. Es begrenzt, was ein Fehler oder ein erfolgreicher Angriff im Betrieb anrichten kann, und sorgt dafür, dass man es bemerkt.

Was ich hier prüfe

Bei einem Agenten im Betrieb prüfe ich zuerst, wo die Sicherheitsgrenze liegt: ob das Backend Rechte, Mandantentrennung, Feld-Allowlist und schreibbare Zustände für Writes des Agenten selbst durchsetzt und ob der Agent mit dem Token der Person handelt. Danach: ob derselbe Fähigkeiten-Code hinter allen Oberflächen steht; wie die Bestätigung gebunden ist, ob ein Token mehrfach verwendbar ist und ob Fehlermeldungen verraten, woran eine Bestätigung gescheitert ist; was passiert, wenn der Signaturschlüssel fehlt; welche Abschaltstufen es gibt, wie schnell sie wirken und ob Audit und Rücknahme erreichbar bleiben; ob das Eval-Gate einen Sicherheitsteil ohne Toleranz hat, jede schreibbare Entität abdeckt und einen Lauf ohne Modell als Fehler wertet; ob ein Modellwechsel am Trace sichtbar ist; und ob Events Werte enthalten und ob ihre Namen gegen Umbenennung geschützt sind. Jeder Befund kommt mit einem konkreten Umbauvorschlag.


Quellen