
Eine sichere* Laufzeitumgebung für autonome KI-Agenten. Richtlinien aus Verfassungen in einfachem Englisch. (*https://ironcurtain.dev)
# IronCurtain
[](https://github.com/provos/ironcurtain/actions/workflows/ci.yml)
[](https://www.npmjs.com/package/@provos/ironcurtain)
[](LICENSE)
[](https://ironcurtain.dev)
**Eine sichere\* Laufzeitumgebung für autonome KI-Agenten, bei der die Sicherheitsrichtlinie aus einer für Menschen lesbaren Verfassung abgeleitet wird.**
_\*Wenn jemand „sicher" schreibt, sollten Sie sofort skeptisch werden. [Was meinen wir mit sicher?](https://ironcurtain.dev)_
> [!WARNING]
> **Forschungsprototyp.** IronCurtain ist ein frühes Forschungsprojekt, das untersucht, wie KI-Agenten so sicher gemacht werden können, dass sie wirklich nützlich sind. APIs, Konfigurationsformate und Architektur können sich ändern. Beiträge und Feedback sind willkommen.
## Demo
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/42102/cf5f5cc847e63acad65eccf1c7fb33bacd782a5d592249cfea60e5f32830ac07.gif" alt="IronCurtain-Mux-Demo: vertrauenswürdige Eingabe aus dem Befehlsmodus ermöglicht die automatische Genehmigung von git clone und git push" width="800">
</p>
Der Agent wird gebeten, ein Repository zu klonen und Änderungen zu pushen. Sowohl `git_clone` als auch `git_push` werden von der Policy-Engine eskaliert, aber der Auto-Genehmiger genehmigt sie automatisch – die vertrauenswürdige Eingabe des Benutzers aus dem Befehlsmodus (Strg-A) lieferte eine eindeutige Absicht, sodass kein manuelles `/approve` erforderlich war.
## Das Problem
Autonome KI-Agenten können Dateien verwalten, Git-Befehle ausführen, Nachrichten senden und in Ihrem Namen mit APIs interagieren. Doch die heutigen Agenten-Frameworks verleihen dem Agenten dieselben Rechte wie dem Benutzer, etwa vollen Zugriff auf das Dateisystem, Anmeldedaten und das Netzwerk. Sicherheitsforscher nennen dies **ambient authority** (umgebende Autorität), und es bedeutet, dass eine einzige Prompt-Injection oder ein mehrstufiges Abdriften dazu führen kann, dass ein Agent Dateien löscht, Daten exfiltriert oder bösartigen Code pusht.
Die übliche Reaktion besteht darin, Agenten entweder auf eine enge Sandbox zu beschränken (was ihre Nützlichkeit einschränkt) oder den Benutzer zu bitten, jede Aktion zu genehmigen (was ihre Autonomie einschränkt). Beides ist unbefriedigend.
## Der Ansatz
IronCurtain geht einen anderen Weg: **Drücken Sie Ihre Sicherheitsabsicht in einfachem Englisch aus und lassen Sie das System die Durchsetzung herausfinden.**
Sie schreiben eine **Verfassung**, ein kurzes Dokument, das beschreibt, was Ihr Agent tun darf und was nicht. IronCurtain kompiliert diese mithilfe einer LLM-Pipeline in eine deterministische Sicherheitsrichtlinie, validiert die kompilierten Regeln anhand generierter Testszenarien und setzt die Richtlinie dann zur Laufzeit bei jedem Tool-Aufruf durch. Das Ergebnis ist ein Agent, der autonom innerhalb von Grenzen arbeiten kann, die Sie in natürlicher Sprache definieren.
Die zentralen Ideen:
- **Der Agent ist nicht vertrauenswürdig.** IronCurtain geht davon aus, dass das LLM durch Prompt-Injection oder Abdriften kompromittiert sein könnte. Die Sicherheit hängt nicht davon ab, dass das Modell „brav ist".
- **Englisch rein, Durchsetzung raus.** Sie schreiben die Absicht („keine destruktiven Git-Operationen ohne Genehmigung"); das System kompiliert sie in deterministische Regeln, die zur Laufzeit ohne weitere LLM-Beteiligung durchgesetzt werden.
- **Semantische Zwischenschaltung.** Statt dem Agenten rohen Systemzugriff zu geben, laufen alle Interaktionen über [MCP](https://modelcontextprotocol.io/)-Server (Dateisystem, Git usw.). Jeder Tool-Aufruf durchläuft eine Policy-Engine, die **erlauben**, **verweigern** oder zur Genehmigung an den Benutzer **eskalieren** kann.
- **Verteidigung in der Tiefe.** Der Agenten-Code läuft in einer V8-Isolate ohne direkten Zugriff auf den Host. Der einzige Ausweg führt über semantisch bedeutsame MCP-Tool-Aufrufe, und jeder einzelne wird gegen die Richtlinie geprüft.
## Architektur
IronCurtain unterstützt zwei Sitzungsmodi mit unterschiedlichen Vertrauensmodellen:
- **Builtin Agent (Code Mode)** — IronCurtains eigener LLM-Agent schreibt TypeScript-Snippets, die in einer V8-Sandbox ausgeführt werden. IronCurtain kontrolliert den Agenten, die Sandbox und die Policy-Engine. Jeder Tool-Aufruf verlässt die Sandbox als strukturierte MCP-Anfrage, durchläuft die Policy-Engine (erlauben / verweigern / eskalieren) und erreicht erst dann den echten MCP-Server.
- **Docker Agent Mode** — Ein externer Agent (Claude Code, Goose, Codex) läuft in einem Container ohne direkten Zugriff auf das öffentliche Netzwerk. IronCurtain vermittelt die externen Effekte: LLM-API-Aufrufe laufen über einen TLS-terminierenden MITM-Proxy (Host-Allowlist, Austausch von Fake- zu Echt-Schlüsseln), MCP-Tool-Aufrufe laufen über dieselbe Policy-Engine, und unterstützte Paketinstallationen laufen über validierende Paket-Proxys.
Opt-in [verschachteltes Docker](https://github.com/provos/ironcurtain/blob/master/CONFIG.md#nested-docker-workloads) gibt Entwickler-Sitzungen einen privaten, ephemeren
Daemon, ohne den Docker-Socket des Hosts offenzulegen. Die implementierten Profile decken Apple Container und Docker
Desktop unter macOS sowie WSL2 mit Docker Desktop unter amd64 ab. Seine Modi `offline`, `images` und `packages`
trennen die lokale Image-Nutzung, vermittelte öffentliche Image-Pulls und unterstützte Paket-Builds. Die native Linux Engine
ist für Verschachtelung nicht zugelassen; siehe die Konfigurationsreferenz für Voraussetzungen und Einschränkungen.
In beiden Modi ist der Agent **nicht vertrauenswürdig**. Die Sicherheit hängt nicht davon ab, dass das Modell Anweisungen befolgt — sie wird an der Grenze durchgesetzt.
Siehe [SANDBOXING.md](https://github.com/provos/ironcurtain/blob/master/SANDBOXING.md) für die vollständige Architektur mit Diagrammen, schichtweiser Vertrauensanalyse und Hinweisen zur macOS-Plattform.
## Schnellstart
### Voraussetzungen
- Node.js 24 oder 26 — die geradzahligen Hauptversionen, die IronCurtain testet. Beide installieren vorgebaute `isolated-vm`-Binaries. Node 25 wird nicht unterstützt und nicht getestet.
- Docker — nicht erforderlich, aber **dringend empfohlen** für den Docker Agent Mode, der die stärkste Isolation bietet. Unter macOS 26+ (Apple Silicon) funktioniert [Apple `container`](https://github.com/apple/container) als alternatives Backend (VM pro Container; wird automatisch verwendet, wenn dessen Dienste laufen — siehe `containerRuntime` in `ironcurtain config`)
- Ein API-Schlüssel für mindestens einen LLM-Anbieter (Anthropic, Google oder OpenAI)
### Installation
**Als globales CLI-Tool (Endnutzer):**
```bash
npm install -g @provos/ironcurtain
```
**Aus der Quelle (Entwicklung):**
```bash
git clone https://github.com/provos/ironcurtain.git
cd ironcurtain
npm install
```
### Einmalige Einrichtung
**1. Legen Sie Ihren API-Schlüssel fest:**
```bash
export ANTHROPIC_API_KEY=sk-ant-...
```
Du kannst Schlüssel auch in einer `.env`-Datei im Projektstamm ablegen (wird automatisch über `dotenv` geladen) oder sie über `ironcurtain config` zu `~/.ironcurtain/config.json` hinzufügen. Umgebungsvariablen haben Vorrang vor Werten aus der Konfigurationsdatei. Unterstützt werden: `ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`, `OPENAI_API_KEY`.
**2. Den Erststart-Assistenten ausführen** (führe dies explizit aus, bevor du den empfohlenen mux-Pfad verwendest; er läuft auch automatisch beim ersten Nicht-mux-`ironcurtain start`):
```bash
ironcurtain setup
```
Führt dich durch die Einrichtung des GitHub-Tokens, des Web-Suchanbieters, der Modellauswahl und weiterer Einstellungen. Erstellt `~/.ironcurtain/config.json` mit deinen Auswahlmöglichkeiten.
## IronCurtain ausführen
IronCurtain wird mit einer Standardrichtlinie ausgeliefert, die auf die Entwicklererfahrung ausgerichtet ist — schreibgeschützte Operationen sind erlaubt, Mutationen (Schreibvorgänge, Pushes, PR-Erstellung) werden zur menschlichen Genehmigung eskaliert. Du kannst es direkt nach der Einrichtung verwenden.
### Terminal-Multiplexer (empfohlen)
Die empfohlene Art, IronCurtain zu verwenden. Sie gibt dir die volle Leistungsfähigkeit der interaktiven TUI deines Agenten (Claude Code oder Goose), während IronCurtain jeden Tool-Aufruf über seine Policy-Engine vermittelt — alles in einem einzigen Terminal.
```bash
ironcurtain mux
```
**Hauptfunktionen:**
- **Vollständige Agent-TUI** — Der Agent läuft in einem PTY innerhalb eines Docker-Containers ohne Netzwerkzugriff. Sie interagieren mit ihm genau so, als würde er lokal laufen.
- **Inline-Eskalationsbehandlung** — Wenn ein Tool-Aufruf eine Genehmigung erfordert, überlagert ein Eskalations-Auswahldialog den Viewport mit Ein-Tasten-Aktionen (a/d/w für genehmigen/ablehnen/whitelisten). Verwenden Sie `/approve+ N`, um eine Domain oder einen Pfad für den Rest der Sitzung zu whitelisten.
- **Vertrauenswürdige Benutzereingabe** — Text, der im Befehlsmodus (Ctrl-A) eingegeben wird, wird auf der Host-Seite erfasst, bevor er in den Container gelangt. Dies erzeugt ein verifiziertes Absichtssignal, das der Auto-Genehmiger nutzen kann — z. B. wird durch die Eingabe von „push my changes to origin" eine nachfolgende `git_push`-Eskalation automatisch genehmigt.
- **Tab-Verwaltung** — Starten Sie mehrere gleichzeitige Sitzungen (`/new`), wechseln Sie zwischen ihnen (`/tab N`, Alt-1..9), schließen Sie sie (`/close`). Mehrere Mux-Instanzen können parallel laufen.
Siehe [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) für die vollständige Anleitung: Eingabemodi, Sicherheitsmodell für vertrauenswürdige Eingaben, Eskalations-Workflow und Tastaturreferenz.
### Nicht-Mux-Sitzungen
Verwenden Sie `ironcurtain start` für schnelle einmalige Aufgaben, Skripte oder wenn Sie explizit den lokalen integrierten Agenten wünschen. Für normale interaktive Docker-Agent-Arbeit verwenden Sie `ironcurtain mux`.
```bash
ironcurtain start "Summarize the files in ./src" # Single-shot mode
ironcurtain start -w ./my-project "Fix the tests" # Single-shot workspace mode
ironcurtain start --agent builtin # Local builtin REPL, no Docker
ironcurtain start --persona my-assistant "Check my email" # Use a persona
```
### Weitere Ausführungsmodi
IronCurtain unterstützt außerdem das Fortsetzen von Sitzungen (`--resume <session-id>`), einen veralteten Raw-PTY/Debug-Modus, einen Signal-Messaging-Transport für die Freigabe per Mobilgerät sowie einen Daemon-Modus für geplante Cron-Jobs. Der Daemon verfügt über eine optionale [Web-UI](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#web-ui) (`--web-ui`) für browserbasierte Überwachung und die Bearbeitung von Eskalationen. Details finden Sie in [RUNNING_MODES.md](https://github.com/provos/ironcurtain/blob/master/RUNNING_MODES.md).
### Multi-Agent-Workflows
IronCurtain orchestriert mehrere KI-Agenten über strukturierte Workflows. Der mitgelieferte **Vulnerability-Discovery**-Workflow sucht nach Speichersicherheits- und Logikfehlern in nativem Code über eine gestufte Harness-Pipeline (Stufe 1 isolierte Funktion → Stufe 2 mehrere Komponenten → Stufe 3 vollständiger Build) mit libFuzzer/AFL++-Coverage-Gating, hypothesengesteuerten `discover`/`triage`-Zuständen und einem abschließenden menschlichen Review-Gate für den Bericht. Der **Design-and-Code**-Workflow durchläuft Planungs-/Design-/Implementierungs-/Review-Zyklen, ebenfalls mit menschlichen Gates. Jeder Agent läuft in seinem eigenen Docker-Container mit rollenspezifischen Policy-Grenzen; die Engine verwaltet Zustandsübergänge, die Weitergabe von Artefakten und Crash-Resume-Checkpointing automatisch. Open Source, läuft vollständig auf Ihrer Maschine, erzwingt pro-Agent-Sicherheitsrichtlinien über die verfassungsbasierte Policy-Engine und funktioniert mit jedem in einem Docker-Container laufenden Agenten – vergleichbar im Umfang mit Amazon Kiro und Google Jules für Coding-Aufgaben, jedoch mit erstklassiger Sicherheit und einem erweiterbaren Workflow-Definitionsformat.

**Die Web-UI ist die vorgesehene Schnittstelle für Workflow-Läufe.** Starten Sie den Daemon, öffnen Sie die ausgegebene URL und steuern Sie Läufe über die Workflows-Seite – der obige Zustandsmaschinen-Graph ist live, die Agent-Nachrichten-Timeline wird mit Markdown-Rendering gestreamt, Gate-Reviews umfassen einen Workspace- und Artefakt-Browser, und vergangene Läufe bleiben aufgelistet.
```bash
ironcurtain daemon --web-ui
```
CLI-Zugriff ist für Skripterstellung, Automatisierung und Debugging verfügbar:
```bash
ironcurtain workflow start vuln-discovery \
"Find memory-safety bugs in libical" --workspace ~/src/libical
ironcurtain workflow start design-and-code \
"Build a REST API with authentication"
```
Siehe [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) für die vollständige Dokumentation.
## Anpassen Ihrer Richtlinie
Die Standardrichtlinie eignet sich gut für die allgemeine Entwicklung, aber Sie können sie an Ihren Workflow anpassen:
**1. Passen Sie Ihre Konstitution an** (optional, aber empfohlen):
```bash
ironcurtain customize-policy
```
Ein LLM-gestütztes Gespräch, das eine auf deinen Workflow zugeschnittene Verfassung generiert und in `~/.ironcurtain/constitution-user.md` speichert. Du kannst diese Datei auch direkt bearbeiten.
**2. Kompiliere die Richtlinie:**
```bash
ironcurtain compile-policy
```
Übersetzt deine Konstitution in deterministische Regeln, generiert Testszenarien und verifiziert sie. Kompilierte Artefakte werden in `~/.ironcurtain/generated/` abgelegt.
### Personas
Personas sind benannte Policy-Profile – jedes bündelt eine Konstitution, eine kompilierte Policy, einen persistenten Workspace und semantischen Speicher. Verwende sie, um Agenten mit unterschiedlichen Rollen oder Zugriffsebenen auszuführen.
```bash
ironcurtain persona create my-assistant # Create a persona
ironcurtain persona compile my-assistant # Compile its policy
ironcurtain start --persona my-assistant "Check my calendar"
```
Im Mux-Modus startet `/new my-assistant` einen Tab mit dieser Persona. Personas können auch Cron-Jobs zugewiesen werden. Siehe [DAEMON.md](https://github.com/provos/ironcurtain/blob/master/DAEMON.md) für die Konfiguration geplanter Jobs.
Personas können auch über die [Web-UI](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#persona-policy-management) verwaltet werden — durchsuchen, erstellen, Verfassungen bearbeiten und Richtlinien mit Live-Fortschritt kompilieren. Da eine Richtlinie eine Sicherheitsgrenze darstellt, sind die Änderungssteuerungen der Web-UI schreibgeschützt, es sei denn, der Daemon wird mit `--allow-policy-mutation` gestartet (standardmäßig deaktiviert).
### Skills
Lege SKILL.md-Pakete unter `~/.ironcurtain/skills/<name>/` ab, um zweckspezifische Anleitungen (Hilfsskripte, deterministische Prüfungen, Domänenwissen) für jede Docker-Agent-Sitzung verfügbar zu machen. Der zusammengeführte Satz wird in ein Host-Verzeichnis pro Bundle bereitgestellt und **schreibgeschützt** in den Container an dem Pfad eingebunden, den die native Discovery des aktiven Agents durchläuft — Claude Code wird über `--add-dir` auf das Staging-Verzeichnis verwiesen, Goose durchsucht `~/.config/goose/skills/<name>/SKILL.md`. Der Agent entdeckt sie automatisch und entscheidet anhand der Frontmatter-Beschreibung jedes Skills, wann er sie liest. Das SKILL.md-_Format_ ist der offene Standard, der von Claude Code, Goose und Codex übernommen wurde; nur der _Discovery-Pfad_ unterscheidet sich je Agent. Workflows können zustandsspezifische Skills innerhalb des Workflow-Pakets mitliefern — siehe [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md#skills).
## Policy: Verfassung → Durchsetzung
Du schreibst die Absicht in einfachem Englisch; IronCurtain kompiliert sie in deterministische Regeln:
```
constitution.md → [Annotate] → [Compile] → [Resolve Lists] → [Generate Scenarios] → [Verify & Repair]
│ │ │ │ │
▼ ▼ ▼ ▼ ▼
tool-annotations compiled-policy dynamic-lists test-scenarios verified policy
.json .json .json .json (or build failure)
```
1. **Annotieren** — Klassifiziere die Argumente jedes MCP-Tools nach Rolle (read-path, write-path, delete-path, none).
2. **Kompilieren** — Übersetze die englische Verfassung in deterministische if/then-Regeln. Kategorische Referenzen („major news sites", „my contacts") werden als symbolische `@list-name`-Referenzen ausgegeben.
3. **Listen auflösen** — Löse symbolische Listen über LLM-Wissen oder MCP-Tool-Nutzung (z. B. Abfrage einer Kontaktdatenbank) in konkrete Werte auf. Geschrieben in `dynamic-lists.json`, benutzerbearbeitbar. Wird übersprungen, wenn keine Listen vorhanden sind.
4. **Szenarien generieren** — Erstelle Testszenarien aus der Verfassung plus verpflichtende handgeschriebene Invariantentests.
5. **Verifizieren & Reparieren** — Führe Szenarien gegen die echte Policy-Engine aus. Ein LLM-Richter analysiert Fehler und generiert gezielte Reparaturen (bis zu 2 Runden). Der Build schlägt fehl, wenn die Policy nicht verifiziert werden kann.
Alle Artefakte werden per Content-Hash zwischengespeichert — nur geänderte Eingaben lösen eine Neukompilierung aus.
### Wie kompilierte Regeln aussehen
Eine Klausel der Verfassung wie:
```markdown
- The agent may perform read-only git operations (status, diff, log) within the sandbox without approval.
- The agent must receive human approval before git push, pull, fetch, or any remote-contacting operation.
```
compiliert zu:
```json
[
{ "tool": "git_status", "decision": "allow", "condition": { "directory": { "within": "$SANDBOX" } } },
{ "tool": "git_diff", "decision": "allow", "condition": { "directory": { "within": "$SANDBOX" } } },
{ "tool": "git_push", "decision": "escalate", "reason": "Remote-contacting git operations require human approval" }
]
```
Jeder Aufruf, der keiner expliziten `allow`- oder `escalate`-Regel entspricht, wird **standardmäßig verweigert**.
```bash
ironcurtain annotate-tools --server filesystem # Annotate one server (merge with existing)
ironcurtain annotate-tools --all # Re-annotate all servers
ironcurtain compile-policy # Compile constitution into rules and verify
ironcurtain refresh-lists # Re-resolve dynamic lists without full recompilation
ironcurtain refresh-lists --list major-news # Refresh a single list
```
Prüfe die generierte `~/.ironcurtain/generated/compiled-policy.json` — dies sind die exakten Regeln, die zur Laufzeit durchgesetzt werden.
## Konfiguration
IronCurtain speichert Konfigurations- und Sitzungsdaten in `~/.ironcurtain/`:
```
~/.ironcurtain/
├── config.json # User configuration
├── constitution.md # User-local base constitution (overrides package default)
├── constitution-user.md # Your policy customizations (generated by customize-policy)
├── generated/ # User-compiled policy artifacts (overrides package defaults)
├── personas/ # Persona directories (constitution, policy, workspace, memory)
├── skills/ # User-global SKILL.md packages, mounted into every Docker session
├── jobs/ # Cron job definitions, workspaces, and run records
├── statistics/ # Content-free local LLM usage database + pseudonymization key
├── sessions/
│ └── {sessionId}/
│ ├── sandbox/ # Per-session filesystem sandbox
│ ├── escalations/ # File-based IPC for human approval
│ ├── audit.jsonl # Per-session audit log
│ └── session.log # Diagnostics
└── workflow-runs/ # Shared-container workflow runs (see below)
```
Einzelsitzungsläufe (`ironcurtain start`, Mux-Tabs, Cron-Jobs) schreiben unter `sessions/`. Läufe des Shared-Container-Workflows schreiben stattdessen unter `workflow-runs/` — siehe den nächsten Abschnitt.
### Layout eines Workflow-Laufs
Eine Workflow-Definition kann einen gemeinsamen Docker-Container aktivieren, indem sie `settings.sharedContainer: true` in ihrer YAML setzt. In diesem Modus läuft jeder Agent-Zustand innerhalb desselben langlebigen Containers und teilt sich eine Instanz der Policy-Engine; zwischen den Zuständen tauscht der Orchestrator die aktive Policy im laufenden Betrieb aus, sodass jede Persona ihre eigenen Regeln sieht. Alle Artefakte des Laufs landen in einem einzigen Baum:
```
~/.ironcurtain/workflow-runs/<workflowId>/
├── audit.jsonl # Persona-tagged append-only audit
├── messages.jsonl # Orchestrator message log
├── workspace/ # Agent workspace (filesystem MCP root)
├── bundle/ # Shared container support (claude-state, orientation, sockets, escalations, system-prompt.txt)
├── states/
│ └── <stateId>.<visitCount>/ # session.log + session-metadata.json per invocation
└── proxy-control.sock # Coordinator UDS for policy hot-swap
```
Für einen Workflow-Lauf mit gemeinsamem Container werden keine sitzungsbezogenen Einträge unter `~/.ironcurtain/sessions/` erstellt. Die für Benutzer sichtbaren Befehle (`ironcurtain workflow start|resume|inspect|list`) bleiben unverändert. Siehe [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) für das Verfassen von Workflow-Definitionen und den vollständigen Lebenszyklus.
Konfiguration interaktiv bearbeiten:
```bash
ironcurtain config
```
Wichtige Konfigurationsbereiche: Modelle und API-Schlüssel, Ressourcenbudgets (Token-/Schritt-/Zeit-/Kostenlimits), automatische Genehmigungs-Eskalationen, Web-Suchanbieter, Audit-Redaktion und LLM-Einstellungen des Memory-Servers. Die vollständige Referenz finden Sie in [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md).
### Lokale LLM-Statistiken
Die inhaltsfreie Erfassung der LLM-Nutzung ist standardmäßig aktiviert. Sie zeichnet Token-Zahlen (Eingabe, Denken, Ausgabe und
Gesamtsummen), Zeitmessung, Protokoll-/Anbieter-/Modell-Routing, Ergebnisse, Ablehnungen und Kostenmetadaten auf, sofern Anbieter diese bereitstellen. Sie
speichert keine Prompts, Vervollständigungen, Denktexte, Tool-Payloads, Anfrage-/Antwortinhalte, Anmeldedaten oder beliebige
Header. Aus Benutzer-/Konfigurationsangaben abgeleitete Labels und nicht-öffentliche Routen werden mit einem lokalen HMAC-Schlüssel pseudonymisiert; begrenzte Modell- und
Anbieter-Identifikatoren bleiben für die Analyse lesbar.
Die Daten liegen in `~/.ironcurtain/statistics/llm-usage.sqlite3`; der Pseudonymisierungsschlüssel ist
`~/.ironcurtain/statistics/identity.key`. Die standardmäßige Aufbewahrungsfrist beträgt 90 Tage. Verwenden Sie `ironcurtain config` →
**LLM Statistics**, die Einstellungsansicht der Web-UI oder setzen Sie `"statistics": { "enabled": false }`, um die Erfassung abzulehnen. Setzen Sie
`retentionDays` auf `null`, um die automatische Bereinigung zu deaktivieren. Starten Sie einen langlaufenden Daemon nach dem Ändern dieser Einstellungen neu.
Manuelles Löschen ist mit `ironcurtain statistics delete --before <ISO-date-or-epoch-ms>` oder `--all` möglich.
Dies ist ein logisches Löschen von SQLite-Zeilen, keine sichere Löschung: Gelöschte Bytes können in freien Seiten, WAL-Dateien, Dateisystem-
Snapshots oder Backups verbleiben. Der Identitätsschlüssel wird durch diese Befehle weder rotiert noch gelöscht.
Um LLM-Datenverkehr über ein Gateway wie LiteLLM oder OpenRouter zu leiten (sowohl im Code Mode als auch im Docker Agent Mode), siehe [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md).
Leiten Sie Docker-Agenten über Modellanbieter-Profile (z. B. GLM-5.3 / GLM-5.3-Flash über OpenRouter, ohne Sidecar) mit `ironcurtain config` → Model Providers, und wählen Sie dann ein Profil unter `/new` oder mit `--provider-profile` — siehe [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md#first-class-openrouter).
## Integrierte Funktionen
IronCurtain wird mit sechs vorkonfigurierten MCP-Servern ausgeliefert. Alle Tool-Aufrufe (außer Memory) unterliegen Ihrer kompilierten Policy.
| Server | Tools | Hauptfunktionen |
| -------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Filesystem** | 14 | Dateien lesen, schreiben, bearbeiten, durchsuchen; Verzeichnisbaum; Verschieben; Diff-Berechnung |
| **Git** | 28 | Vollständiger Git-Workflow: Status, Diff, Log, Commit, Branch, Push/Pull/Fetch, Clone, Stash, Blame |
| **Fetch** | 2 | HTTP GET mit HTML-zu-Markdown-Konvertierung; Websuche (Brave, Tavily, SerpAPI, Parallel Search) |
| **GitHub** | 41 | Issues, PRs, Codesuche, Reviews über `ghcr.io/github/github-mcp-server`; erfordert ein GitHub Personal Access Token |
| **Google Workspace** | 128 | Gmail, Calendar, Drive, Docs, Sheets — erfordert OAuth-Einrichtung über `ironcurtain auth` |
| **Memory** | 5 | Persistentes semantisches Gedächtnis mit hybrider Vektor- und Stichwortsuche, LLM-Zusammenfassung und automatischer Kompaktierung. Aktiviert für Persona- und Cron-Sitzungen. |
Leseoperationen sind durch die Standard-Policy erlaubt; Mutationen (Schreibvorgänge, Pushes, PR-Erstellung) werden zur menschlichen Genehmigung eskaliert. Tools verwenden die Benennung `server.tool` (z. B. `filesystem.read_file`, `memory.recall`). Siehe [ADDING_MCP_SERVERS.md](https://github.com/provos/ironcurtain/blob/master/ADDING_MCP_SERVERS.md), um eigene hinzuzufügen.
### Netzwerk-Passthrough (Docker Agent Mode)
Im Docker Agent Mode hat der Container keinen Netzwerkzugriff — der gesamte Datenverkehr läuft über den MITM-Proxy von IronCurtain. Standardmäßig sind nur Domains von LLM-Anbietern erreichbar. Der Agent kann zur Laufzeit über den virtuellen MCP-Server `proxy` (`add_proxy_domain`) Zugriff auf zusätzliche Domains anfordern. Jede Anfrage erfordert eine menschliche Genehmigung über den Eskalationsablauf.
Genehmigte Domains erhalten einen **rohen Passthrough-Tunnel** — HTTP-, HTTPS- und WebSocket-Verbindungen werden ohne Inhaltsprüfung oder Credential-Injection weitergeleitet. Dies gibt dem Agenten mehr Nutzen (Aufrufen von Drittanbieter-APIs, Streamen von Daten aus externen Diensten), bedeutet aber, dass der Datenverkehr zu diesen Domains **unvermittelt** ist. Siehe [SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) Abschnitt 2b-i für das Bedrohungsmodell und [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) für Nutzungsdetails.
## Sicherheitsmodell
IronCurtain ist um ein bestimmtes Bedrohungsmodell herum konzipiert: **das LLM wird bösartig.** Dies kann durch Prompt-Injection geschehen (eine bösartige E-Mail oder Webseite kapert den Agenten) oder durch Multi-Turn-Drift (der Agent weicht im Laufe einer langen Sitzung allmählich von der Absicht des Benutzers ab).
### Was IronCurtain durchsetzt
- **Dateisystem-Eingrenzung** — Symlink-bewusste Pfadauflösung verhindert Path-Traversal- und Symlink-Escape-Angriffe.
- **Richtlinie pro Tool** — Jeder MCP-Tool-Aufruf wird gegen kompilierte Regeln bewertet. Die Policy-Engine klassifiziert Tool-Argumente nach Rolle (read-path, write-path, delete-path), um feingranulare Entscheidungen zu treffen.
- **Strukturelle Invarianten** — Bestimmte Schutzmaßnahmen sind fest codiert und können nicht durch die Konstitution überschrieben werden: Der Agent kann niemals seine eigenen Richtliniendateien, Audit-Logs oder Konfiguration ändern.
- **Menschliche Eskalation** — Wenn die Richtlinie „escalate" sagt, pausiert der Agent und der Benutzer muss ausdrücklich genehmigen oder ablehnen. Optional bearbeitet ein LLM-basierter Auto-Genehmiger eindeutige Fälle (siehe [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md)).
- **Audit-Trail** — Jeder Tool-Aufruf und jede Richtlinienentscheidung wird in einem append-only JSONL-Audit-Log protokolliert.
- **Ressourcenlimits** — Token-, Schritt-, Zeit- und Kostenbudgets verhindern außer Kontrolle geratene Sitzungen.
### Bekannte Einschränkungen
Dies ist ein Forschungsprototyp. Bekannte Lücken sind:
- **Treue der Richtlinienkompilierung** — Der LLM-basierte Compiler kann die Absicht der Konstitution falsch interpretieren. Die Verifikationspipeline fängt viele Fehler ab, ist aber nicht erschöpfend. Überprüfen Sie stets die kompilierte `compiled-policy.json`.
- **V8-Isolate-Grenzen** — Code Mode verwendet V8-Isolates, keine Virtualisierung auf Betriebssystemebene. Ein V8-Zero-Day könnte eine Flucht ermöglichen.
- **Keine Prüfung ausgehender Inhalte** — Ein Agent, dem das Schreiben von Dateien erlaubt ist, könnte sensible Daten kodieren, um inhaltsbasierte Kontrollen zu umgehen. Geplant: LLM-basierte Verständlichkeitsprüfungen für ausgehende Inhalte.
- **Eskalationsmüdigkeit** — Zu viele False-Positive-Eskalationen können zu gewohnheitsmäßiger Genehmigung führen. Stimmen Sie Ihre Konstitution ab, um unnötige Aufforderungen zu minimieren.
Siehe [docs/SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) für eine detaillierte Bedrohungsanalyse.
## Fehlerbehebung
| Problem | Hinweis |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Fehlender API-Schlüssel** | Setzen Sie die Umgebungsvariable (`ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY` oder `OPENAI_API_KEY`) oder fügen Sie den entsprechenden Schlüssel zu `~/.ironcurtain/config.json` hinzu. |
| **Sandbox nicht verfügbar** | OS-Level-Sandboxing erfordert `bubblewrap` und `socat`. Installieren Sie beide, oder setzen Sie `"sandboxPolicy": "warn"` in Ihrer MCP-Server-Konfiguration für die Entwicklung. |
| **Budget erschöpft** | Passen Sie die Limits in `~/.ironcurtain/config.json` unter `resourceBudget` an. Setzen Sie ein einzelnes Limit auf `null`, um es zu deaktivieren. |
---
[Read more](https://github.com/provos/ironcurtain)
Entdecken Sie die meistgenutzten Tools unserer Community.
Noch keine Beliebtheitsdaten.