Code-Execution-Agent-Pattern: Sicheres Ausführen von Code

Kern des Patterns

Code-Execution Agent ist ein Pattern, bei dem der Agent nicht nur textuell denkt, sondern generierten Code in einer kontrollierten Umgebung ausführt, ein faktisches Ergebnis erhält und damit weiterarbeitet.

Wann einsetzen: wenn die Antwort durch Code-Ausführung berechnet oder verifiziert werden muss und nicht nur textuell generiert werden soll.

Der Agent:

• Generate: erzeugt kurzen, task-spezifischen Code
• Run: führt ihn in einer Sandbox aus
• Observe: erhält das reale Ergebnis
• Explain: liefert Ergebnis mit Erklärung zurück

Problem

Stell dir vor, du fragst:

"Berechne die durchschnittliche Conversion aus dieser CSV."

Der Agent schreibt ein Skript und sagt: "Durchschnittliche Conversion ist 3,84%."

Aber ohne kontrollierte Umgebung siehst du nicht:

• was genau ausgeführt wurde
• welche Dateien gelesen wurden
• ob Netzwerkaufrufe versucht wurden
• wie viele Ressourcen der Code verbraucht hat

Bei Code-Ausführung ist nicht nur die Logik wichtig, sondern auch die Grenzen der Laufzeitumgebung.

Genau hier liegt das Problem: Das Ergebnis hängt gleichzeitig von Code und Laufzeitumgebung ab, deshalb ist "einfach ausführen" unsicher und intransparent.

Lösung

Code-Execution Agent führt Code nur über eine kontrollierte Execution Layer aus.

Analogie: Das ist wie ein Labor mit Sicherheitsregeln. Ein Experiment darf nur in einem isolierten Raum und nach klaren Regeln stattfinden. So sinkt das Risiko, die Umgebung zu beschädigen oder unnötige Daten herauszugeben.

Schlüsselprinzip: Das Modell darf Code schreiben, aber Ausführung ist nur in Sandbox und nach Policy-Check erlaubt.

Grundlegende Einschränkungen:

• Sandbox Runtime
• eingeschränkter Dateizugriff
• kein Netzwerk
• CPU/RAM/Time-Limits

Kontrollierter Zyklus:

1. Planung: minimales Skript für die Aufgabe bestimmen
2. Generierung: Code erzeugen
3. Policy-Check: Sicherheit und erlaubte Operationen prüfen
4. Isolierte Ausführung: Code in Sandbox ausführen
5. Ergebnisprüfung: Korrektheit und Risiko des Outputs prüfen

Wenn Policy-Check oder Output-Validierung fehlschlagen, wird gestoppt oder eskaliert.

Das schützt vor Situationen, in denen der Agent:

• sensible Dateien liest
• Daten nach außen sendet
• in langen Schleifen hängt
• gefährliche Operationen ausführt

Zuverlässige Code-Ausführung ist nicht "nur ausführen", sondern Ausführung, die runtime-policy technisch nicht umgehen lässt.

Wie es funktioniert

Der Schlüsselbaustein ist die Sandbox.

Sie begrenzt typischerweise:

• Dateisystem: Zugriff nur auf Arbeitsverzeichnis
• Netzwerk: oft vollständig deaktiviert
• Ressourcen: CPU/RAM/time quotas
• Laufzeitumgebung: erlaubte Bibliotheken und Syscalls

Im Code sieht das so aus

code = agent.generate_code(goal, constraints={
    "language": "python",
    "no_network": True,
    "max_seconds": 5,
})

exec_result = execution_layer.run_code(
    code=code,
    policy="sandboxed_python",
)

if not exec_result.success:
    return fallback_or_stop(exec_result.error)

validated = validate_output(exec_result.stdout, schema=expected_schema)
if not validated.ok:
    return stop_with_reason(validated.reason)

return format_answer(validated.data)

Hauptregel: generierten Code niemals außerhalb von sandbox und policy-Kontrolle ausführen.

So sieht es bei der Ausführung aus

Goal: Conversion aus CSV-Report berechnen

Generate Code:
- sales.csv lesen
- conversion_rate = paid / leads berechnen
- Tabelle pro Tag ausgeben

Sandbox Run:
- timeout: 5s
- memory: 256MB
- network: disabled

Output:
- Tabelle mit 7 Zeilen
- durchschnittliche Conversion: 3,84%

Wann es passt - und wann nicht

Passt

Passt nicht

Denn Code-Ausführung erhöht die operativen Anforderungen: Sandbox, Resource Limits, Monitoring und Audit.

Unterschied zu Guarded-Policy

Guarded-Policy entscheidet, ob überhaupt gehandelt werden darf. Code-Execution entscheidet, wie eine Code-Aktion sicher und reproduzierbar ausgeführt wird.

Wann Code-Execution verwenden (vs andere Patterns)

Verwende Code-Execution, wenn der Agent Code ausführen, Ergebnisse prüfen und sicher iterieren muss.

Kurzer Test:

• wenn du "Code ausführen und mit faktischem Output arbeiten" musst -> Code-Execution
• wenn du "zuerst nur eine große Aufgabe in Teilaufgaben zerlegen" musst -> Task Decomposition Agent

Mit anderen Patterns kombinieren

• Code-Execution + Guarded-Policy: vor der Ausführung prüft der Agent den Code gegen Sicherheitsregeln und blockiert gefährliche Aktionen.
• Code-Execution + Fallback-Recovery: wenn die Ausführung hängt oder fehlschlägt, wechselt der Agent in ein sicheres Fallback-Szenario.
• Code-Execution + Supervisor: riskante Runs werden nicht automatisch ausgeführt, sondern zur menschlichen Freigabe gegeben.

Kurzfassung

Vorteile und Nachteile

FAQ

Q: Kann man Code einfach auf dem Server ohne Isolation ausführen?
A: Für Produktion: nein. Es braucht Isolation, Resource Limits und Kontrolle erlaubter Operationen.

Q: Garantiert Code-Ausführung die Korrektheit des Ergebnisses?
A: Nicht vollständig. Du brauchst Output-Validierung, Invarianten-Tests und Policy-Checks.

Q: Was tun, wenn Code bei der Ausführung abstürzt?
A: Begrenzte Recovery nutzen: retry, Fallback-Laufzeit oder kontrollierter Stop mit stop reason.

Was als Nächstes

Code-Execution ermöglicht dem Agenten, Berechnungen zuverlässig auszuführen.

Aber wie setzt man das für vollständige Analytics ein: Datenbereinigung, Aggregate, Charts und Schlussfolgerungen?