O constrúyelo primero:```bash
cargo build -p ironclaw_reborn_cli --bin ironclaw-reborn
./target/debug/ironclaw-reborn --help

`config path` y `doctor` son diagnósticos seguros; informan el home resuelto,
perfil, `config.toml`, `providers.json` y `v1_state: not-used`.
No crean estado de Reborn ni archivos de configuración iniciales.

### Configurar la ruta del modelo

La forma nativa de la CLI para configurar la ruta predeterminada del modelo de Reborn es:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- models set-provider openai --model gpt-5-mini

Para OpenAI, establece el valor secreto en el entorno antes de comenzar:```bash
export OPENAI_API_KEY="sk-..."
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- run --message "hello"

### `config.toml` estructura

`config init` crea archivos de inicio editables:```bash
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- config init

[llm.default]
provider_id = "openai"
model = "gpt-5-mini"
api_key_env = "OPENAI_API_KEY"
```
`config.toml` también puede incluir secciones opcionales como `[boot]`, `[identity]`, `[runner]` y `[skills]`; `config init` escribe guía comentada para los campos admitidos.

Si falta `config.toml`, el primer inicio del runtime con estado a través de `run`, `repl` o `serve` genera un archivo disperso con `api_version` y el perfil de arranque seguro `local-dev`. Los comandos de solo lectura y `run --dry-run` permanecen sin efectos secundarios. Las selecciones de entorno únicas como `IRONCLAW_REBORN_PROFILE=local-dev-yolo` no se persisten en el archivo generado.

Importante: `api_key_env` es el nombre de una variable de entorno, no el secreto en sí. Reborn rechaza valores con forma de secreto en línea en `config.toml` y `providers.json`.

El almacenamiento de producción utiliza el mismo patrón de solo entorno. Una configuración de producción de Reborn puede nombrar la variable de URL de PostgreSQL, pero no debe contener la URL en bruto:```toml
[storage]
backend = "postgres"
url_env = "IRONCLAW_REBORN_POSTGRES_URL"
secret_master_key_env = "IRONCLAW_REBORN_SECRET_MASTER_KEY"
# Optional; defaults to 2. Keep below the PostgreSQL server or managed
# session-pool cap after reserving capacity for restarts and operator sessions.
pool_max_size = 2

[policy]
deployment_mode = "hosted_multi_tenant"
default_profile = "secure_default"
```
Establezca `IRONCLAW_REBORN_POSTGRES_URL` en el entorno del proceso, y establezca
`IRONCLAW_REBORN_SECRET_MASTER_KEY` como material de clave criptográfica independiente.
Los proveedores remotos gestionados de PostgreSQL deben usar TLS, por ejemplo añadiendo
`sslmode=require`.
El comando `run` en producción también requiere una sección explícita `[policy]`. El
primer lanzamiento de producción admite políticas en tiempo de ejecución que no
requieren un enlace de proceso tenant-sandbox.

Una vez que existe `[llm.default]`, esa configuración selecciona el proveedor. `LLM_BACKEND` es
solo un respaldo de entorno cuando no hay un espacio LLM predeterminado configurado. Para cambiar de
proveedor después de escribir la configuración, use `models set-provider <provider>` o edite
`[llm.default].provider_id`.

### Selección de modelo solo por entorno

Si `$IRONCLAW_REBORN_HOME/config.toml` está ausente o no tiene `[llm.default]`,
Reborn puede resolver el LLM a partir de variables de entorno. Una configuración inicial
sembrada y escasa no incluye `[llm.default]`, por lo que la selección de modelo solo por entorno
sigue funcionando:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-env-only"
export LLM_BACKEND=openai
export OPENAI_API_KEY="sk-..."
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- run --message "hello"
```
Variables de entorno comunes para proveedores:

| Proveedor | Selector | Env requerida |
| --- | --- | --- |
| OpenAI | `LLM_BACKEND=openai` | `OPENAI_API_KEY`; opcional `OPENAI_MODEL`, `OPENAI_BASE_URL` |
| Anthropic | `LLM_BACKEND=anthropic` | `ANTHROPIC_API_KEY`; opcional `ANTHROPIC_MODEL`, `ANTHROPIC_BASE_URL` |
| OpenAI-compatible | `LLM_BACKEND=openai_compatible` | `LLM_BASE_URL`; opcional `LLM_API_KEY`, `LLM_MODEL` |
| OpenRouter | `LLM_BACKEND=openrouter` | `OPENROUTER_API_KEY`; opcional `OPENROUTER_MODEL` |
| Ollama | `LLM_BACKEND=ollama` | sin clave; opcional `OLLAMA_BASE_URL`, `OLLAMA_MODEL` |
| Codex auth | `LLM_BACKEND=openai_codex` | `LLM_USE_CODEX_AUTH=true` o `CODEX_AUTH_PATH`; opcional `OPENAI_CODEX_MODEL` |

Usa `models list <provider>` para ver los metadatos exactos del proveedor compilados en la rama actual.

### Variables de inicio

| Variable | Propósito |
| --- | --- |
| `IRONCLAW_REBORN_HOME` | Raíz absoluta del estado de Reborn. Por defecto es `$HOME/.ironclaw/reborn`. El resolvedor rechaza rutas inseguras y alias de raíz de estado v1 como `$HOME/.ironclaw`. |
| `IRONCLAW_REBORN_PROFILE` | Selector de perfil de arranque. Valores soportados: `local-dev`, `local-dev-yolo`, `hosted-single-tenant`, `hosted-single-tenant-volume`, `production`, `migration-dry-run`. |
| `IRONCLAW_REBORN_POSTGRES_URL` | URL de almacenamiento PostgreSQL en producción cuando `[storage].backend = "postgres"` y `[storage].url_env` nombra esta variable. Mantenla fuera de `config.toml`; los proveedores remotos deben usar TLS. |
| `IRONCLAW_REBORN_POSTGRES_POOL_MAX_SIZE` | Anulación opcional para el tamaño del pool de clientes PostgreSQL de Reborn. Úsalo cuando un proveedor gestionado imponga un límite pequeño en el pool de sesiones. |
| `IRONCLAW_FILESYSTEM_POSTGRES_MIGRATION_CONNECT_MAX_WAIT_SECS` | Ventana de espera de inicio opcional para reintentos de conexión de migración del sistema de archivos a Postgres. Por defecto son 300 segundos. |
| `IRONCLAW_REBORN_SECRET_MASTER_KEY` | Clave maestra secreta de Reborn en producción cuando `[storage].secret_master_key_env` nombra esta variable. Mantenla independiente de la URL de la base de datos y fuera de `config.toml`. |
| `IRONCLAW_REBORN_LOG` | Filtro de tracing para el binario de Reborn, por ejemplo `debug,ironclaw_runner=trace`. |

Actualmente, `run` y `repl` soportan la composición de tiempo de ejecución local a través de `local-dev`, `local-dev-yolo` y `hosted-single-tenant-volume`. `hosted-single-tenant-volume` usa el sustrato libSQL de tiempo de ejecución local bajo `$IRONCLAW_REBORN_HOME/hosted-single-tenant-volume`, resuelve la política de tiempo de ejecución segura por defecto alojada y deshabilita herramientas respaldadas por procesos como shell. Está pensado para despliegues de vista previa de un solo inquilino en un volumen persistente, no como la composición completa de producción con PostgreSQL.

`local-dev-yolo` concede acceso de host de laptop confiable y debe ser confirmado explícitamente:```bash
export IRONCLAW_REBORN_PROFILE=local-dev-yolo
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- repl --confirm-host-access
```
### Servicio WebUI

El Reborn WebUI se compila bajo la característica Cargo `webui-v2-beta`. Las compilaciones con esta característica requieren Node.js 22 con Corepack/pnpm para que Cargo pueda generar e incluir el paquete SPA. Compile o ejecute el binario con esa característica para habilitar el comando `serve`:```bash
cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve --help
cargo build -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn
```
El listener de WebUI tiene como valor predeterminado `127.0.0.1:3000`. El servicio requiere un
token de portador de entorno y un ID de usuario al inicio. También necesita la ruta del modelo de
la sección anterior, incluyendo la variable de entorno de credenciales de ese proveedor:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"

cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve
```
Equivalente configuración del listener `config.toml`:```toml
[webui]
listen_host = "127.0.0.1"
listen_port = 3000
env_token_var = "IRONCLAW_REBORN_WEBUI_TOKEN"
env_user_id_var = "IRONCLAW_REBORN_WEBUI_USER_ID"
allowed_origins = ["http://127.0.0.1:3000", "http://localhost:3000"]
canonical_host = "127.0.0.1:3000"
```
`env_token_var` y `env_user_id_var` son nombres de variables de entorno. Mantenga el token real y el id de usuario en el entorno.

Variables de entorno requeridas para WebUI:

| Variable | Propósito |
| --- | --- |
| `IRONCLAW_REBORN_WEBUI_TOKEN` | Token Bearer para solicitudes de WebUI. Si SSO está habilitado, esto también firma sesiones y debe tener al menos 32 bytes. |
| `IRONCLAW_REBORN_WEBUI_USER_ID` | Id de propietario/usuario de Reborn para solicitudes bearer de entorno. Si `[identity].default_owner` está configurado, debe coincidir con este valor. |

Variables de entorno OAuth opcionales para WebUI:

| Variable | Propósito |
| --- | --- |
| `IRONCLAW_REBORN_WEBUI_BASE_URL` | URL base pública utilizada para el inicio de sesión de WebUI y las devoluciones de llamada OAuth de autenticación de producto. Las implementaciones no loopback deben usar `https://`. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_ID` | Habilita Google SSO cuando se establece. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_SECRET` | Requerido cuando Google SSO está habilitado. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_ALLOWED_HD` | Restricción opcional del dominio alojado de Google. |
| `IRONCLAW_REBORN_WEBUI_GITHUB_CLIENT_ID` | Habilita GitHub SSO cuando se establece. |
| `IRONCLAW_REBORN_WEBUI_GITHUB_CLIENT_SECRET` | Requerido cuando GitHub SSO está habilitado. |
| `IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS` | Requerido cuando cualquier proveedor SSO está habilitado. Dominios de correo electrónico verificados separados por comas. |
| `IRONCLAW_REBORN_WEBUI_OAUTH_HTTP_TIMEOUT_SECS` | Anulación opcional del tiempo de espera HTTP de OAuth. |

Para Google SSO, cree un cliente web OAuth de Google y registre la URI de redirección de Reborn WebUI como:```text
{IRONCLAW_REBORN_WEBUI_BASE_URL}/auth/callback/google
```
Por ejemplo, con `IRONCLAW_REBORN_WEBUI_BASE_URL=https://ironclaw.example.com`,
el URI de redireccionamiento autorizado en Google Cloud es:```text
https://ironclaw.example.com/auth/callback/google
```
Notion MCP y otros flujos de configuración de OAuth de autenticación de productos utilizan la misma URL base de WebUI pública al registrar las URL de devolución de llamada del proveedor. No incluya una barra diagonal final en `IRONCLAW_REBORN_WEBUI_BASE_URL`; Reborn la recorta antes de construir las URL de devolución de llamada. Si se omite la URL base, Reborn utiliza la dirección real del listener, como `http://127.0.0.1:3000`, que solo es adecuada para pruebas de OAuth en bucle local. Las implementaciones de OAuth públicas o que no sean de bucle local deben establecer una URL base `https://`.

Entorno completo de inicio de Google SSO:```bash
export IRONCLAW_REBORN_HOME="/var/lib/ironclaw-reborn"
export IRONCLAW_REBORN_PROFILE=local-dev
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"
export IRONCLAW_REBORN_WEBUI_BASE_URL="https://ironclaw.example.com"
export IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS="example.com,team.example.com"
export IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_ID="..."
export IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_SECRET="..."

cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve --host 0.0.0.0 --port 3000
```
`IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS` es la lista de admisión real permitida. Google `hd` es solo una sugerencia opcional del dominio alojado del lado del proveedor; no confíes en él en lugar de la lista de dominios permitidos de Reborn. `IRONCLAW_REBORN_HOME` selecciona la raíz de estado/configuración para este servicio. `IRONCLAW_REBORN_PROFILE` por defecto es `local-dev`; `local-dev-yolo` otorga acceso al host de la laptop confiable y no puede servirse en un host que no sea de bucle local.

Usa `serve --host <ip> --port <port>` para anular el listener desde la CLI. Vincular a un host que no sea de bucle local es sensible a producción. El modo de servicio `local-dev-yolo` también requiere `--confirm-host-access` y rechaza hosts que no sean de bucle local.

### Servicio Slack

El soporte de Slack se compila detrás de la característica `slack-v2-host-beta` de Cargo. Esa característica incluye `webui-v2-beta`, por lo que Slack se ejecuta en el mismo comando `serve`:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"
export IRONCLAW_REBORN_SLACK_ENABLED="true"

cargo run -q -p ironclaw_reborn_cli --features slack-v2-host-beta --bin ironclaw-reborn -- serve
```
Habilitar Slack estableciendo `IRONCLAW_REBORN_SLACK_ENABLED=true`, o agregando una sección `[slack]` a `config.toml`:```toml
[slack]
enabled = true
```
Las variables de entorno solo anulan la puerta de activación de la ruta de Slack: `true`/`1` monta Slack, mientras que `false`/`0` actúa como un interruptor de apagado del despliegue. Después de que el servidor se inicie, configure los ids de la app de Slack, el token del bot, el secreto de firma y las asignaciones de canales desde la configuración de canales de la WebUI.

Configuración requerida de Slack:

| Nombre | Propósito |
| --- | --- |
| `[slack].enabled = true` o `IRONCLAW_REBORN_SLACK_ENABLED=true` | Monta la ruta de Slack durante `serve`. |
| Configuración del workspace de Slack en WebUI | Almacena los ids de instalación de Slack, las asignaciones de canales y los secretos del bot/firma de Slack. |

Las notas de configuración más detalladas de Slack se encuentran en
[`docs/reborn/setup-slack-for-reborn-binary.md`](https://github.com/nearai/ironclaw/blob/HEAD/docs/reborn/setup-slack-for-reborn-binary.md).

## Filosofía

IronClaw se basa en un principio simple: **tu asistente de IA debería trabajar para ti, no en tu contra**.

En un mundo donde los sistemas de IA son cada vez más opacos sobre el manejo de datos y están alineados con intereses corporativos, IronClaw adopta un enfoque diferente:

- **Tus datos siguen siendo tuyos** - Toda la información se almacena localmente, está cifrada y nunca sale de tu control
- **Transparencia por diseño** - Código abierto, auditable, sin telemetría oculta ni recolección de datos
- **Capacidades de autoexpansión** - Construye nuevas herramientas sobre la marcha sin esperar actualizaciones del proveedor
- **Defensa en profundidad** - Múltiples capas de seguridad protegen contra inyección de indicaciones y exfiltración de datos

IronClaw es el asistente de IA en el que realmente puedes confiar para tu vida personal y profesional.

## Características

### Seguridad Primero

- **Sandbox WASM** - Las herramientas no confiables se ejecutan en contenedores WebAssembly aislados con permisos basados en capacidades
- **Protección de Credenciales** - Los secretos nunca se exponen a las herramientas; se inyectan en el límite del host con detección de fugas
- **Defensa contra Inyección de Indicaciones** - Detección de patrones, sanitización de contenido y aplicación de políticas
- **Lista Blanca de Endpoints** - Solicitudes HTTP solo a hosts y rutas explícitamente aprobados

### Siempre Disponible

- **Multicanal** - REPL, webhooks HTTP, canales WASM (Telegram, Slack) y puerta de enlace web
- **Sandbox Docker** - Ejecución en contenedores aislados con tokens por trabajo y patrón orquestador/trabajador
- **Puerta de Enlace Web** - Interfaz de usuario en navegador con transmisión en tiempo real SSE/WebSocket
- **Rutinas** - Programaciones cron, disparadores de eventos, manejadores de webhook para automatización en segundo plano
- **Sistema de Latido** - Ejecución proactiva en segundo plano para tareas de monitoreo y mantenimiento
- **Trabajos Paralelos** - Maneja múltiples solicitudes simultáneamente con contextos aislados
- **Autoreparación** - Detección y recuperación automática de operaciones atascadas

### Autoexpansión

- **Construcción Dinámica de Herramientas** - Describe lo que necesitas e IronClaw lo construye como una herramienta WASM
- **Protocolo MCP** - Conéctate a servidores de Protocolo de Contexto de Modelo para capacidades adicionales
- **Arquitectura de Plugins** - Agrega nuevas herramientas y canales WASM sin reiniciar

### Memoria Persistente

- **Búsqueda Híbrida** - Búsqueda de texto completo + vectorial usando Fusión de Rango Recíproco
- **Sistema de Archivos del Espacio de Trabajo** - Almacenamiento flexible basado en rutas para notas, registros y contexto
- **Archivos de Identidad** - Mantén personalidad y preferencias consistentes entre sesiones

## Instalación

### Requisitos previos

- Rust 1.96+
- PostgreSQL 15+ con la extensión [pgvector](https://github.com/pgvector/pgvector)
- Node.js 22+ con Corepack/pnpm para compilaciones desde el código fuente que habiliten la característica `webui-v2-beta`
- Cuenta de NEAR AI (autenticación gestionada mediante el asistente de configuración)
- `libclang` y un conjunto de herramientas C funcional si compilas la ruta de voz/SILK de WeChat desde el código fuente

## Descargar o Compilar

Visita la [página de Lanzamientos](https://github.com/nearai/ironclaw/releases/) para ver las últimas actualizaciones.

<details>
  <summary>Instalar mediante el instalador de Windows (Windows)</summary>

Descarga el [Instalador de Windows](https://github.com/nearai/ironclaw/releases/latest/download/ironclaw-x86_64-pc-windows-msvc.msi) y ejecútalo.

</details>

<details>
  <summary>Instalar mediante script de PowerShell (Windows)</summary>```sh
irm https://github.com/nearai/ironclaw/releases/latest/download/ironclaw-installer.ps1 | iex
```
</details>

<details>
  <summary>Instalar mediante script de shell (macOS, Linux, Windows/WSL)</summary>```sh
curl --proto '=https' --tlsv1.2 -LsSf https://github.com/nearai/ironclaw/releases/latest/download/ironclaw-installer.sh | sh
```
</details>

<details>
  <summary>Instalar via Homebrew (macOS/Linux)</summary>```sh
brew install ironclaw
```
</details>

<details>
  <summary>Compilar el código fuente (Cargo en Windows, Linux, macOS)</summary>

Instálalo con `cargo`, solo asegúrate de tener [Rust](https://rustup.rs) instalado en tu computadora.```bash
# Clone the repository
git clone https://github.com/nearai/ironclaw.git
cd ironclaw

# Build
cargo build --release

# Run tests
cargo test
```
Para la **versión completa** (después de modificar las fuentes del canal), ejecute `./scripts/build-all.sh` para reconstruir los canales primero.

> **Opcional:** Las notas de voz de WeChat (`audio/silk`) requieren el ayudante independiente `ironclaw-silk-decoder` para ser transcribibles. Está excluido de la construcción predeterminada del espacio de trabajo porque `silk-codec` arrastra `bindgen`/`libclang`. Constrúyalo por separado con `./crates/ironclaw_silk_decoder/build.sh` (necesita libclang + un toolchain C) y coloque el binario resultante en `$PATH`, junto al binario `ironclaw`, o apuntado por `IRONCLAW_SILK_DECODER`. Sin él, los mensajes de voz aún se entregan — solo como blobs `audio/silk` sin procesar.

</details>

### Configuración de la Base de Datos```bash
# Create database
createdb ironclaw

# Enable pgvector
psql ironclaw -c "CREATE EXTENSION IF NOT EXISTS vector;"
```
## Configuración

Ejecuta el asistente de configuración para configurar IronClaw:```bash
ironclaw onboard
```
El asistente maneja la conexión a la base de datos, la autenticación de NEAR AI (a través de OAuth del navegador) y el cifrado de secretos (usando el llavero de tu sistema). La configuración se persiste en la base de datos conectada; las variables de arranque (p. ej., `DATABASE_URL`, `LLM_BACKEND`) se escriben en `~/.ironclaw/.env` para que estén disponibles antes de que la base de datos se conecte.

### Proveedores de LLM Alternativos

IronClaw por defecto usa NEAR AI pero admite muchos proveedores de LLM de fábrica. Los proveedores incorporados incluyen **Anthropic**, **OpenAI**, **GitHub Copilot**, **Google Gemini**, **MiniMax**, **Mistral** y **Ollama** (local). Servicios compatibles con OpenAI como **OpenRouter** (más de 300 modelos), **Together AI**, **Fireworks AI** y servidores autogestionados (**vLLM**, **LiteLLM**) también son compatibles.

Selecciona tu proveedor en el asistente, o configura las variables de entorno directamente:```env
# Example: MiniMax (built-in, 204K context)
LLM_BACKEND=minimax
MINIMAX_API_KEY=...

# Example: OpenAI-compatible endpoint
LLM_BACKEND=openai_compatible
LLM_BASE_URL=https://openrouter.ai/api/v1
LLM_API_KEY=sk-or-...
LLM_MODEL=anthropic/claude-sonnet-4
```
Consulte [docs/capabilities/llm-providers.md](https://github.com/nearai/ironclaw/blob/HEAD/docs/capabilities/llm-providers.md) para obtener una guía completa de proveedores.

## Seguridad

IronClaw implementa defensa en profundidad para proteger sus datos y prevenir el uso indebido.

### Sandbox WASM

Todas las herramientas no confiables se ejecutan en contenedores WebAssembly aislados:

- **Permisos basados en capacidades** - Aceptación explícita para HTTP, secretos, invocación de herramientas
- **Lista blanca de endpoints** - Solicitudes HTTP solo a hosts/rutas aprobados
- **Inyección de credenciales** - Secretos inyectados en el límite del host, nunca expuestos al código WASM
- **Detección de fugas** - Escanea solicitudes y respuestas en busca de intentos de exfiltración de secretos
- **Límite de tasa** - Límites de solicitud por herramienta para prevenir abusos
- **Límites de recursos** - Restricciones de memoria, CPU y tiempo de ejecución```
WASM ──► Allowlist ──► Leak Scan ──► Credential ──► Execute ──► Leak Scan ──► WASM
         Validator     (request)     Injector       Request     (response)
```
### Defensa contra Inyección de Prompts

El contenido externo pasa a través de múltiples capas de seguridad:

- Detección basada en patrones de intentos de inyección
- Sanitización y escape de contenido
- Reglas de política con niveles de gravedad (Bloquear/Advertir/Revisar/Sanitizar)
- Envoltorio de salida de herramientas para inyección segura en contexto LLM

### Protección de Datos

- Todos los datos se almacenan localmente en su base de datos PostgreSQL
- Secretos cifrados con AES-256-GCM
- Sin telemetría, análisis ni intercambio de datos
- Registro de auditoría completo de todas las ejecuciones de herramientas

## Arquitectura```
┌────────────────────────────────────────────────────────────────┐
│                          Channels                              │
│  ┌──────┐  ┌──────┐   ┌─────────────┐  ┌─────────────┐         │
│  │ REPL │  │ HTTP │   │WASM Channels│  │ Web Gateway │         │
│  └──┬───┘  └──┬───┘   └──────┬──────┘  │ (SSE + WS)  │         │
│     │         │              │         └──────┬──────┘         │
│     └─────────┴──────────────┴────────────────┘                │
│                              │                                 │
│                    ┌─────────▼─────────┐                       │
│                    │    Agent Loop     │  Intent routing       │
│                    └────┬──────────┬───┘                       │
│                         │          │                           │
│              ┌──────────▼────┐  ┌──▼───────────────┐           │
│              │  Scheduler    │  │ Routines Engine  │           │
│              │(parallel jobs)│  │(cron, event, wh) │           │
│              └──────┬────────┘  └────────┬─────────┘           │
│                     │                    │                     │
│       ┌─────────────┼────────────────────┘                     │
│       │             │                                          │
│   ┌───▼─────┐  ┌────▼────────────────┐                         │
│   │ Local   │  │    Orchestrator     │                         │
│   │Workers  │  │  ┌───────────────┐  │                         │
│   │(in-proc)│  │  │ Docker Sandbox│  │                         │
│   └───┬─────┘  │  │   Containers  │  │                         │
│       │        │  │ ┌───────────┐ │  │                         │
│       │        │  │ │Worker / CC│ │  │                         │
│       │        │  │ └───────────┘ │  │                         │
│       │        │  └───────────────┘  │                         │
│       │        └─────────┬───────────┘                         │
│       └──────────────────┤                                     │
│                          │                                     │
│              ┌───────────▼──────────┐                          │
│              │    Tool Registry     │                          │
│              │  Built-in, MCP, WASM │                          │
│              └──────────────────────┘                          │
└────────────────────────────────────────────────────────────────┘
```
### Componentes Principales

| Componente | Propósito |
|-----------|---------|
| **Agent Loop** | Manejo principal de mensajes y coordinación de trabajos |
| **Router** | Clasifica la intención del usuario (comando, consulta, tarea) |
| **Scheduler** | Gestiona la ejecución paralela de trabajos con prioridades |
| **Worker** | Ejecuta trabajos con razonamiento LLM y llamadas a herramientas |
| **Orchestrator** | Ciclo de vida de contenedores, proxy LLM, autenticación por trabajo |
| **Web Gateway** | IU de navegador con chat, memoria, trabajos, registros, extensiones, rutinas |
| **Routines Engine** | Tareas en segundo plano programadas (cron) y reactivas (evento, webhook) |
| **Workspace** | Memoria persistente con búsqueda híbrida |
| **Safety Layer** | Defensa contra inyección de prompts y sanitización de contenido |

## Uso de IronClaw```bash
# First-time setup (configures database, auth, etc.)
ironclaw onboard

# Start interactive REPL
cargo run

# REPL with debug logging
RUST_LOG=ironclaw=debug cargo run
```
## Desarrollo```bash
# Format code
cargo fmt

# Lint
cargo clippy --all --benches --tests --examples --all-features

# Run tests
createdb ironclaw_test
cargo test

# Run specific test
cargo test test_name
```
- **Canales**: Consulte [docs/channels/overview.mdx](https://github.com/nearai/ironclaw/blob/HEAD/docs/channels/overview.mdx) para la configuración de Telegram, Discord y otros canales.
- **Cambiar fuentes de canales**: Ejecute `./channels-src/telegram/build.sh` antes de `cargo build` para que el WASM actualizado se incluya.

## Herencia de OpenClaw

IronClaw es una reimplementación en Rust inspirada en [OpenClaw](https://github.com/openclaw/openclaw). Consulte [FEATURE_PARITY.md](https://github.com/nearai/ironclaw/blob/HEAD/FEATURE_PARITY.md) para la matriz de seguimiento completa.

Diferencias clave:

- **Rust vs TypeScript** - Rendimiento nativo, seguridad de memoria, binario único
- **Sandbox WASM vs Docker** - Seguridad ligera basada en capacidades
- **PostgreSQL vs SQLite** - Persistencia lista para producción
- **Diseño centrado en la seguridad** - Múltiples capas de defensa, protección de credenciales

## Licencia

Licenciado bajo:

- Licencia Apache, Versión 2.0 ([LICENSE-APACHE](https://github.com/nearai/ironclaw/blob/HEAD/LICENSE-APACHE))
- Licencia MIT ([LICENSE-MIT](https://github.com/nearai/ironclaw/blob/HEAD/LICENSE-MIT))

a su elección.