
Un runtime* seguro para agentes de IA autónomos. Política a partir de constituciones en inglés sencillo. (*https://ironcurtain.dev)
# IronCurtain
[](https://github.com/provos/ironcurtain/actions/workflows/ci.yml)
[](https://www.npmjs.com/package/@provos/ironcurtain)
[](LICENSE)
[](https://ironcurtain.dev)
**Un runtime seguro\* para agentes de IA autónomos, donde la política de seguridad se deriva de una constitución legible por humanos.**
_\*Cuando alguien escribe "seguro", deberías ser inmediatamente escéptico. [¿Qué entendemos por seguro?](https://ironcurtain.dev)_
> [!WARNING]
> **Prototipo de investigación.** IronCurtain es un proyecto de investigación en fase temprana que explora cómo hacer que los agentes de IA sean lo suficientemente seguros como para ser genuinamente útiles. Las APIs, los formatos de configuración y la arquitectura pueden cambiar. Las contribuciones y los comentarios son bienvenidos.
## Demo
<p align="center">
<img src="https://assets.kitploit.com/production/public/readmes/42102/cf5f5cc847e63acad65eccf1c7fb33bacd782a5d592249cfea60e5f32830ac07.gif" alt="Demo de IronCurtain mux: la entrada de confianza desde el modo comando permite la aprobación automática de git clone y git push" width="800">
</p>
Se le pide al agente que clone un repositorio y suba los cambios. Tanto `git_clone` como `git_push` son escalados por el motor de políticas, pero el auto-aprobador los aprueba automáticamente — la entrada de confianza del usuario desde el modo comando (Ctrl-A) proporcionó una intención clara, por lo que no se necesitó `/approve` manual.
## El problema
Los agentes de IA autónomos pueden gestionar archivos, ejecutar comandos git, enviar mensajes e interactuar con APIs en tu nombre. Pero los frameworks de agentes actuales le otorgan al agente los mismos privilegios que el usuario, como acceso completo al sistema de archivos, a las credenciales y a la red. Los investigadores de seguridad llaman a esto **autoridad ambiental**, y significa que una sola inyección de prompt o una deriva multiturno puede provocar que un agente elimine archivos, exfiltre datos o suba código malicioso.
La respuesta habitual es restringir a los agentes a un sandbox estrecho (limitando su utilidad) o pedir al usuario que apruebe cada acción (limitando su autonomía). Ninguna de las dos es satisfactoria.
## El enfoque
IronCurtain toma un camino diferente: **expresa tu intención de seguridad en inglés sencillo y deja que el sistema se encargue de la aplicación.**
Escribes una **constitución**, que es un documento breve que describe lo que tu agente puede y no puede hacer. IronCurtain compila esto en una política de seguridad determinista usando un pipeline de LLM, valida las reglas compiladas contra escenarios de prueba generados y luego aplica la política en tiempo de ejecución en cada llamada a herramientas. El resultado es un agente que puede trabajar de forma autónoma dentro de los límites que defines en lenguaje natural.
Las ideas clave:
- **El agente no es de confianza.** IronCurtain asume que el LLM puede estar comprometido por inyección de prompt o deriva. La seguridad no depende de que el modelo "se porte bien".
- **Inglés de entrada, aplicación de salida.** Escribes la intención ("ninguna operación git destructiva sin aprobación"); el sistema la compila en reglas deterministas que se aplican sin más intervención del LLM en tiempo de ejecución.
- **Interposición semántica.** En lugar de darle al agente acceso directo al sistema, todas las interacciones pasan por servidores [MCP](https://modelcontextprotocol.io/) (sistema de archivos, git, etc.). Cada llamada a herramientas pasa por un motor de políticas que puede **permitir**, **denegar** o **escalar** al usuario para su aprobación.
- **Defensa en profundidad.** El código del agente se ejecuta en un aislamiento de V8 sin acceso directo al host. La única salida es a través de llamadas a herramientas MCP semánticamente significativas, y cada una se verifica contra la política.
## Arquitectura
IronCurtain admite dos modos de sesión con diferentes modelos de confianza:
- **Agente integrado (Modo Código)** — el propio agente LLM de IronCurtain escribe fragmentos de TypeScript que se ejecutan en un sandbox de V8. IronCurtain controla el agente, el sandbox y el motor de políticas. Cada llamada a herramientas sale del sandbox como una solicitud MCP estructurada, pasa por el motor de políticas (permitir / denegar / escalar) y solo entonces llega al servidor MCP real.
- **Modo de agente Docker** — Un agente externo (Claude Code, Goose, Codex) se ejecuta dentro de un contenedor sin acceso directo a la red pública. IronCurtain media los efectos externos: las llamadas a la API del LLM pasan por un proxy MITM que termina TLS (lista de hosts permitidos, intercambio de clave falsa por real), las llamadas a herramientas MCP pasan por el mismo motor de políticas, y las instalaciones de paquetes compatibles pasan por proxies de paquetes con validación.
El [Docker anidado](https://github.com/provos/ironcurtain/blob/master/CONFIG.md#nested-docker-workloads) opcional proporciona a las sesiones de desarrollador un daemon privado y efímero sin exponer el socket de Docker del host. Los perfiles implementados cubren Apple Container y Docker Desktop en macOS, y WSL2 con Docker Desktop en amd64. Sus modos `offline`, `images` y `packages` separan el uso local de imágenes, las descargas públicas de imágenes mediadas y las compilaciones de paquetes compatibles. El motor nativo de Linux no está admitido para el anidamiento; consulte la referencia de configuración para conocer los requisitos previos y las limitaciones.
En ambos modos, el agente es **no confiable**. La seguridad no depende de que el modelo siga instrucciones — se aplica en el límite.
Consulte [SANDBOXING.md](https://github.com/provos/ironcurtain/blob/master/SANDBOXING.md) para ver la arquitectura completa con diagramas, el análisis de confianza capa por capa y las notas sobre la plataforma macOS.
## Inicio rápido
### Requisitos previos
- Node.js 24 o 26 — las líneas principales de numeración par que IronCurtain prueba. Ambas instalan binarios `isolated-vm` precompilados. Node 25 no es compatible ni está probado.
- Docker — no es obligatorio pero **se recomienda encarecidamente** para el Modo de agente Docker, que proporciona el aislamiento más sólido. En macOS 26+ (Apple silicon), [Apple `container`](https://github.com/apple/container) funciona como backend alternativo (VM por contenedor; se usa automáticamente cuando sus servicios están en ejecución — consulte `containerRuntime` en `ironcurtain config`)
- Una clave de API para al menos un proveedor de LLM (Anthropic, Google u OpenAI)
### Instalación
**Como herramienta CLI global (usuarios finales):**
```bash
npm install -g @provos/ironcurtain
```
**Desde el código fuente (desarrollo):**
```bash
git clone https://github.com/provos/ironcurtain.git
cd ironcurtain
npm install
```
### Configuración inicial única
**1. Establece tu clave de API:**
```bash
export ANTHROPIC_API_KEY=sk-ant-...
```
También puedes colocar las claves en un archivo `.env` en la raíz del proyecto (cargado automáticamente mediante `dotenv`), o añadirlas a `~/.ironcurtain/config.json` mediante `ironcurtain config`. Las variables de entorno tienen prioridad sobre los valores del archivo de configuración. Compatibles: `ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY`, `OPENAI_API_KEY`.
**2. Ejecuta el asistente de primer inicio** (ejecútalo explícitamente antes de usar la ruta mux recomendada; también se ejecuta automáticamente en el primer `ironcurtain start` que no sea mux):
```bash
ironcurtain setup
```
Te guía a través de la configuración del token de GitHub, el proveedor de búsqueda web, la selección de modelo y otros ajustes. Crea `~/.ironcurtain/config.json` con tus elecciones.
## Ejecutar IronCurtain
IronCurtain se distribuye con una política predeterminada orientada a la experiencia del desarrollador: las operaciones de solo lectura están permitidas, las mutaciones (escrituras, pushes, creación de PR) se escalan para aprobación humana. Puedes empezar a usarlo inmediatamente después de la configuración.
### Multiplexor de terminal (recomendado)
La forma recomendada de usar IronCurtain. Te brinda todo el poder de la TUI interactiva de tu agente (Claude Code o Goose) mientras IronCurtain media cada llamada a herramientas a través de su motor de políticas, todo en una única terminal.
```bash
ironcurtain mux
```
**Capacidades clave:**
- **TUI de agente completa** — El agente se ejecuta en un PTY dentro de un contenedor Docker sin acceso a la red. Interactúas con él exactamente como si se ejecutara localmente.
- **Manejo de escalado en línea** — Cuando una llamada a herramienta requiere aprobación, un selector de escalado se superpone a la vista con acciones de una sola tecla (a/d/w para aprobar/denegar/lista blanca). Usa `/approve+ N` para añadir un dominio o ruta a la lista blanca durante el resto de la sesión.
- **Entrada de usuario confiable** — El texto escrito en modo comando (Ctrl-A) se captura en el lado del host antes de entrar en el contenedor. Esto crea una señal de intención verificada que el auto-aprobador puede usar — p. ej., escribir "push my changes to origin" aprobará automáticamente un escalado posterior de `git_push`.
- **Gestión de pestañas** — Genera múltiples sesiones concurrentes (`/new`), cambia entre ellas (`/tab N`, Alt-1..9), ciérralas (`/close`). Múltiples instancias de mux pueden ejecutarse en paralelo.
Consulta [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) para el recorrido completo: modos de entrada, modelo de seguridad de entrada confiable, flujo de trabajo de escalado y referencia de teclado.
### Sesiones sin mux
Usa `ironcurtain start` para tareas rápidas de un solo uso, scripts, o cuando quieras explícitamente el agente integrado local. Para el trabajo interactivo normal con el agente Docker, usa `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
```
### Otros modos de ejecución
IronCurtain también admite la reanudación de sesiones (`--resume <session-id>`), un modo heredado de PTY/debug sin procesar, un transporte de mensajería Signal para aprobación móvil y un modo daemon para trabajos cron programados. El daemon tiene una [interfaz web](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#web-ui) opcional (`--web-ui`) para monitoreo basado en navegador y gestión de escalaciones. Consulte [RUNNING_MODES.md](https://github.com/provos/ironcurtain/blob/master/RUNNING_MODES.md) para más detalles.
### Flujos de trabajo multiagente
IronCurtain orquesta múltiples agentes de IA mediante flujos de trabajo estructurados. El flujo de trabajo integrado de **descubrimiento de vulnerabilidades** busca errores de seguridad de memoria y de lógica en código nativo a través de una canalización de arneses por niveles (Nivel 1 función aislada → Nivel 2 multicomponente → Nivel 3 compilación completa) con control de cobertura de libFuzzer/AFL++, estados `discover`/`triage` guiados por hipótesis y una compuerta final de revisión de informes por parte de humanos. El flujo de trabajo de **diseño y código** ejecuta ciclos de planificación / diseño / implementación / revisión, también con compuertas humanas. Cada agente se ejecuta en su propio contenedor Docker con límites de política específicos de su rol; el motor gestiona automáticamente las transiciones de estado, el paso de artefactos y los puntos de control para reanudación tras fallos. Es de código abierto, se ejecuta completamente en su máquina, aplica políticas de seguridad por agente mediante el motor de políticas basado en la constitución y funciona con cualquier agente contenedorizado en Docker —comparable en alcance a Amazon Kiro y Google Jules para tareas de programación, pero con seguridad de primer nivel y un formato de definición de flujos de trabajo extensible.

**La interfaz web es la interfaz prevista para las ejecuciones de flujos de trabajo.** Inicie el daemon, abra la URL impresa y dirija las ejecuciones desde la página Workflows —el grafo de la máquina de estados mostrado arriba es interactivo, la línea de tiempo de mensajes de los agentes se transmite con renderizado de markdown, las revisiones de compuertas incluyen un navegador de espacio de trabajo y artefactos, y las ejecuciones anteriores permanecen listadas.
```bash
ironcurtain daemon --web-ui
```
El acceso a la CLI está disponible para scripting, automatización y depuración:
```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"
```
Consulta [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) para la documentación completa.
## Personalizar tu política
La política predeterminada funciona bien para el desarrollo general, pero puedes adaptarla a tu flujo de trabajo:
**1. Personaliza tu constitución** (opcional pero recomendado):
```bash
ironcurtain customize-policy
```
Una conversación asistida por LLM que genera una constitución adaptada a tu flujo de trabajo, guardada en `~/.ironcurtain/constitution-user.md`. También puedes editar este archivo directamente.
**2. Compila la política:**
```bash
ironcurtain compile-policy
```
Traduce tu constitución a reglas deterministas, genera escenarios de prueba y los verifica. Los artefactos compilados se guardan en `~/.ironcurtain/generated/`.
### Personas
Las personas son perfiles de políticas con nombre: cada una agrupa una constitución, una política compilada, un espacio de trabajo persistente y memoria semántica. Úsalas para ejecutar agentes con distintos roles o niveles de acceso.
```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"
```
En modo mux, `/new my-assistant` genera una pestaña usando esa persona. Las personas también se pueden asignar a tareas cron. Consulta [DAEMON.md](https://github.com/provos/ironcurtain/blob/master/DAEMON.md) para la configuración de tareas programadas.
Las personas también se pueden gestionar desde la [interfaz web](https://github.com/provos/ironcurtain/blob/master/DAEMON.md#persona-policy-management): explorar, crear, editar constituciones y compilar políticas con progreso en vivo. Dado que una política es un límite de seguridad, los controles de mutación de la interfaz web son de solo lectura a menos que el daemon se inicie con `--allow-policy-mutation` (desactivado por defecto).
### Skills
Coloca paquetes SKILL.md en `~/.ironcurtain/skills/<name>/` para que la guía específica de propósito (scripts auxiliares, comprobaciones deterministas, conocimiento del dominio) esté disponible para cada sesión de agente Docker. El conjunto fusionado se prepara en un directorio host por bundle y se monta mediante bind **en modo de solo lectura** dentro del contenedor en la ruta que recorre el descubrimiento nativo del agente activo: Claude Code se apunta al directorio de preparación mediante `--add-dir`, Goose escanea `~/.config/goose/skills/<name>/SKILL.md`. El agente los descubre automáticamente y decide cuándo leerlos según la descripción del frontmatter de cada skill. El _formato_ de SKILL.md es el estándar abierto adoptado por Claude Code, Goose y Codex; solo la _ruta de descubrimiento_ difiere según el agente. Los flujos de trabajo pueden incluir skills por estado dentro del paquete del flujo de trabajo; consulta [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md#skills).
## Política: Constitución → Aplicación
Escribes la intención en inglés sencillo; IronCurtain la compila en reglas deterministas:
```
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. **Anotar** — Clasificar los argumentos de cada herramienta MCP por rol (ruta de lectura, ruta de escritura, ruta de eliminación, ninguno).
2. **Compilar** — Traducir la constitución en inglés a reglas deterministas de tipo si/entonces. Las referencias categóricas ("sitios de noticias importantes", "mis contactos") se emiten como referencias simbólicas `@list-name`.
3. **Resolver listas** — Resolver las listas simbólicas a valores concretos mediante el conocimiento del LLM o el uso de herramientas MCP (por ejemplo, consultando una base de datos de contactos). Se escriben en `dynamic-lists.json`, editable por el usuario. Se omite cuando no hay listas presentes.
4. **Generar escenarios** — Crear escenarios de prueba a partir de la constitución, además de pruebas invariantes obligatorias escritas a mano.
5. **Verificar y reparar** — Ejecutar los escenarios contra el motor de políticas real. Un juez LLM analiza los fallos y genera reparaciones específicas (hasta 2 rondas). La compilación falla si la política no puede verificarse.
Todos los artefactos se almacenan en caché por hash de contenido — solo las entradas modificadas desencadenan una recompilación.
### Cómo se ven las reglas compiladas
Una cláusula de la constitución como:
```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.
```
compila a:
```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" }
]
```
Cualquier llamada que no coincida con una regla explícita `allow` o `escalate` es **denegada por defecto**.
```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
```
Revise el archivo generado `~/.ironcurtain/generated/compiled-policy.json` — estas son las reglas exactas que se aplican en tiempo de ejecución.
## Configuración
IronCurtain almacena la configuración y los datos de sesión en `~/.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)
```
Las ejecuciones de sesión única (`ironcurtain start`, pestañas de mux, trabajos cron) escriben bajo `sessions/`. Las ejecuciones de flujo de trabajo con contenedor compartido escriben bajo `workflow-runs/` en su lugar — véase la siguiente sección.
### Estructura de una ejecución de flujo de trabajo
Una definición de flujo de trabajo puede optar por un contenedor Docker compartido estableciendo `settings.sharedContainer: true` en su YAML. En ese modo, cada estado de agente se ejecuta dentro del mismo contenedor de larga duración y comparte una única instancia del motor de políticas; entre estados, el orquestador intercambia en caliente la política activa para que cada persona vea sus propias reglas. Todos los artefactos de la ejecución se depositan en un único árbol:
```
~/.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
```
No se crean entradas por sesión en `~/.ironcurtain/sessions/` para una ejecución de flujo de trabajo con contenedor compartido. Los comandos visibles para el usuario (`ironcurtain workflow start|resume|inspect|list`) no cambian. Consulte [WORKFLOWS.md](https://github.com/provos/ironcurtain/blob/master/WORKFLOWS.md) para la creación de definiciones de flujo de trabajo y el ciclo de vida completo.
Edite la configuración de forma interactiva:
```bash
ironcurtain config
```
Áreas clave de configuración: modelos y claves de API, presupuestos de recursos (límites de tokens/pasos/tiempo/costo), escalaciones de aprobación automática, proveedor de búsqueda web, redacción de auditoría y ajustes del LLM del servidor de memoria. Consulte [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md) para la referencia completa.
### Estadísticas del LLM local
La recopilación de uso del LLM sin contenido está habilitada por defecto. Registra recuentos de tokens (entrada, razonamiento, salida y
totales), tiempos, enrutamiento de protocolo/proveedor/modelo, resultados, rechazos y metadatos de costos cuando los proveedores los exponen. No
almacena prompts, completaciones, texto de razonamiento, cargas útiles de herramientas, cuerpos de solicitud/respuesta, credenciales ni cabeceras
arbitrarias. Las etiquetas derivadas del usuario/configuración y las rutas no públicas se pseudonimizan con una clave HMAC local; los identificadores
acotados de modelo y proveedor permanecen legibles para su análisis.
Los datos residen en `~/.ironcurtain/statistics/llm-usage.sqlite3`; la clave de pseudonimización es
`~/.ironcurtain/statistics/identity.key`. El período de retención predeterminado es de 90 días. Use `ironcurtain config` →
**LLM Statistics**, la vista Settings de la interfaz web, o establezca `"statistics": { "enabled": false }` para optar por no participar. Establezca
`retentionDays` en `null` para deshabilitar la purga automática. Reinicie un daemon en ejecución prolongada después de cambiar estos ajustes.
La eliminación manual está disponible con `ironcurtain statistics delete --before <ISO-date-or-epoch-ms>` o `--all`.
Se trata de una eliminación lógica de filas de SQLite, no de un borrado seguro: los bytes eliminados pueden permanecer en páginas libres, archivos WAL, instantáneas
del sistema de archivos o copias de seguridad. La clave de identidad no se rota ni se elimina con estos comandos.
Para enrutar el tráfico del LLM a través de una puerta de enlace como LiteLLM u OpenRouter (tanto en Code Mode como en Docker Agent Mode), consulte [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md).
Enrute los agentes Docker a través de perfiles de proveedor de modelos (p. ej., GLM-5.3 / GLM-5.3-Flash vía OpenRouter, sin sidecar) con `ironcurtain config` → Model Providers, luego elija un perfil en `/new` o con `--provider-profile` — consulte [MODEL_ROUTING.md](https://github.com/provos/ironcurtain/blob/master/MODEL_ROUTING.md#first-class-openrouter).
## Capacidades integradas
IronCurtain se distribuye con seis servidores MCP preconfigurados. Todas las llamadas a herramientas (excepto memoria) se rigen por su política compilada.
| Servidor | Herramientas | Capacidades clave |
| -------------------- | ----- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Filesystem** | 14 | Leer, escribir, editar, buscar archivos; árbol de directorios; mover; cálculo de diferencias |
| **Git** | 28 | Flujo de trabajo completo de git: status, diff, log, commit, branch, push/pull/fetch, clone, stash, blame |
| **Fetch** | 2 | HTTP GET con conversión de HTML a markdown; búsqueda web (Brave, Tavily, SerpAPI, Parallel Search) |
| **GitHub** | 41 | Issues, PRs, búsqueda de código, revisiones vía `ghcr.io/github/github-mcp-server`; requiere un token de acceso personal de GitHub |
| **Google Workspace** | 128 | Gmail, Calendar, Drive, Docs, Sheets — requiere configuración de OAuth vía `ironcurtain auth` |
| **Memory** | 5 | Memoria semántica persistente con búsqueda híbrida de vectores+palabras clave, resumen por LLM y compactación automática. Habilitada para sesiones de persona y cron. |
Las operaciones de solo lectura están permitidas por la política predeterminada; las mutaciones (escrituras, pushes, creación de PRs) escalan para aprobación humana. Las herramientas usan la nomenclatura `server.tool` (p. ej., `filesystem.read_file`, `memory.recall`). Consulte [ADDING_MCP_SERVERS.md](https://github.com/provos/ironcurtain/blob/master/ADDING_MCP_SERVERS.md) para agregar las suyas propias.
### Paso directo de red (Docker Agent Mode)
En el modo Docker Agent, el contenedor no tiene acceso a la red: todo el tráfico pasa por el proxy MITM de IronCurtain. De forma predeterminada, solo son accesibles los dominios de los proveedores de LLM. El agente puede solicitar acceso a dominios adicionales en tiempo de ejecución a través del servidor MCP virtual `proxy` (`add_proxy_domain`). Cada solicitud requiere la aprobación humana mediante el flujo de escalado.
Los dominios aprobados obtienen un **túnel de paso directo sin procesar**: las conexiones HTTP, HTTPS y WebSocket se reenvían sin inspección de contenido ni inyección de credenciales. Esto otorga al agente una mayor utilidad (llamar a API de terceros, transmitir datos desde servicios externos), pero implica que el tráfico hacia esos dominios queda **sin mediación**. Consulte la sección 2b-i de [SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) para conocer el modelo de amenazas y [DEVELOPER_GUIDE.md](https://github.com/provos/ironcurtain/blob/master/DEVELOPER_GUIDE.md) para obtener detalles de uso.
## Modelo de seguridad
IronCurtain está diseñado en torno a un modelo de amenazas específico: **el LLM se vuelve malicioso.** Esto puede ocurrir mediante inyección de prompts (un correo electrónico o una página web maliciosos secuestran al agente) o mediante una deriva multiturno (el agente se desvía gradualmente de la intención del usuario a lo largo de una sesión prolongada).
### Qué aplica IronCurtain
- **Contención del sistema de archivos**: la resolución de rutas con reconocimiento de enlaces simbólicos evita ataques de recorrido de rutas y de escape mediante enlaces simbólicos.
- **Política por herramienta**: cada llamada a una herramienta MCP se evalúa según reglas compiladas. El motor de políticas clasifica los argumentos de las herramientas por rol (ruta de lectura, ruta de escritura, ruta de eliminación) para tomar decisiones detalladas.
- **Invariantes estructurales**: ciertas protecciones están codificadas de forma rígida y no pueden ser anuladas por la constitución: el agente nunca puede modificar sus propios archivos de políticas, registros de auditoría ni configuración.
- **Escalado humano**: cuando la política indica "escalar", el agente se detiene y el usuario debe aprobar o denegar explícitamente. De forma opcional, un autoaprobador basado en LLM gestiona los casos inequívocos (consulte [CONFIG.md](https://github.com/provos/ironcurtain/blob/master/CONFIG.md)).
- **Registro de auditoría**: cada llamada a una herramienta y cada decisión de política se registran en un registro de auditoría JSONL de solo adición.
- **Límites de recursos**: los presupuestos de tokens, pasos, tiempo y coste evitan sesiones descontroladas.
### Limitaciones conocidas
Este es un prototipo de investigación. Las carencias conocidas incluyen:
- **Fidelidad de la compilación de políticas**: el compilador basado en LLM puede interpretar erróneamente la intención de la constitución. La canalización de verificación detecta muchos errores, pero no es exhaustiva. Revise siempre el archivo `compiled-policy.json` compilado.
- **Límites de los aislamientos de V8**: el modo de código utiliza aislamientos de V8, no virtualización a nivel de sistema operativo. Un zero-day de V8 podría permitir un escape.
- **Sin inspección del contenido saliente**: un agente autorizado a escribir archivos podría codificar datos sensibles para eludir los controles a nivel de contenido. Está previsto: comprobaciones de inteligibilidad basadas en LLM sobre el contenido saliente.
- **Fatiga de escalado**: demasiados escalados falsos positivos pueden llevar a una aprobación por costumbre. Ajuste su constitución para minimizar las solicitudes innecesarias.
Consulte [docs/SECURITY_CONCERNS.md](https://github.com/provos/ironcurtain/blob/master/docs/SECURITY_CONCERNS.md) para obtener un análisis detallado de amenazas.
## Solución de problemas
| Problema | Orientación |
| --------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| **Falta la clave de API** | Establezca la variable de entorno (`ANTHROPIC_API_KEY`, `GOOGLE_GENERATIVE_AI_API_KEY` u `OPENAI_API_KEY`) o añada la clave correspondiente a `~/.ironcurtain/config.json`. |
---
[Read more](https://github.com/provos/ironcurtain)