moltis

<div align="center">

<a href="https://moltis.org"><img src="https://raw.githubusercontent.com/moltis-org/moltis/main/website/favicon.svg" alt="Moltis" width="64"></a>

# Moltis — Un servidor de agentes personales persistente y seguro en Rust

Un solo binario — en sandbox, seguro, tuyo.

[![CI](https://github.com/moltis-org/moltis/actions/workflows/ci.yml/badge.svg)](https://github.com/moltis-org/moltis/actions/workflows/ci.yml)
[![codecov](https://codecov.io/gh/moltis-org/moltis/graph/badge.svg)](https://codecov.io/gh/moltis-org/moltis)
[![CodSpeed](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json&style=flat&label=CodSpeed)](https://codspeed.io/moltis-org/moltis)
[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
[![Rust](https://img.shields.io/badge/Rust-1.91+-orange.svg)](https://www.rust-lang.org)
[![Discord](https://img.shields.io/discord/1469505370169933837?color=5865F2&label=Discord&logo=discord&logoColor=white)](https://discord.gg/XnmrepsXp5)

[Instalación](#installation) • [Comparación](#comparison) • [Arquitectura](#architecture--crate-map) • [Seguridad](#security) • [Características](#features) • [Cómo funciona](#how-it-works) • [Contribuir](https://github.com/moltis-org/moltis/blob/main/CONTRIBUTING.md)

</div>

---

Moltis alcanzó recientemente [la portada de Hacker News](https://news.ycombinator.com/item?id=46993587). Por favor, [abre un issue](https://github.com/moltis-org/moltis/issues) ante cualquier fricción, por mínima que sea. Estoy centrado en hacer que Moltis sea excelente.

**Seguro por diseño** — Tus claves nunca salen de tu máquina. Cada comando se ejecuta en un contenedor en sandbox, nunca en tu host.

**Tu hardware** — Funciona en un Mac Mini, una Raspberry Pi o cualquier servidor que poseas. Un solo binario de Rust, sin Node.js, sin npm, sin runtime.

**Con todas las funciones** — Voz, memoria, recuerdo entre sesiones, puntos de control automáticos de edición, programación de tareas, Telegram, Signal, Discord, automatización del navegador, servidores MCP, ejecución remota por SSH o respaldada por nodos, claves de despliegue gestionadas con fijación de host en la interfaz web, un inventario en vivo en Ajustes → Herramientas, contexto de proyecto compatible con Cursor y escaneo de amenazas en archivos de contexto — todo integrado. Sin marketplace de plugins a través del cual sufrir ataques de cadena de suministro.

**Auditable** — El ejecutor del agente y la interfaz de modelos caben en ~7,5K líneas, con los proveedores en ~19K más. El workspace de Rust tiene ~270K líneas repartidas en 59 crates modulares que puedes auditar de forma independiente, con más de 470 archivos Rust que contienen tests. El código unsafe está aislado en los límites de FFI y del runtime precompilado, no en el bucle principal del agente.

## Instalación

```bash
# One-liner install script (macOS / Linux)
curl -fsSL https://www.moltis.org/install.sh | sh

# macOS / Linux via Homebrew
brew install moltis-org/tap/moltis

# Docker (multi-arch: amd64/arm64)
docker pull ghcr.io/moltis-org/moltis:latest

# Or build from source
cargo install moltis --git https://github.com/moltis-org/moltis
```

## Comparación

| | OpenClaw | Hermes Agent | **Moltis** |
|---|---|---|---|
| Stack principal | TypeScript + aplicaciones complementarias en Swift/Kotlin | Python + interfaces TUI/web en TypeScript | **Rust** |
| Entorno de ejecución | Node.js + npm/pnpm/bun | Python + uv/pip, piezas opcionales de UI en Node | **Binario único en Rust** |
| Tamaño del checkout local\* | ~1.1M LoC de la app | ~152K LoC de la app | **~270K LoC en Rust** |
| Arquitectura | Amplio ecosistema de gateway, canales, nodos y apps | Agente CLI/gateway con bucle de aprendizaje y herramientas de investigación | **Servidor de agente personal persistente con crates modulares** |
| Crates/módulos | Paquetes npm, extensiones, apps | Paquetes Python, plugins, herramientas, TUI | **59 crates del workspace de Rust** |
| Sandbox/backends | Permisos a nivel de app, herramientas de navegador/nodo | Local, Docker, SSH, Daytona, Singularity, Modal | **Docker/Podman + Apple Container + WASM** |
| Autenticación/acceso | Emparejamiento y controles del gateway local | Configuración de CLI y gateway de mensajería | **Contraseña + Passkey + claves API + Vault** |
| E/S de voz | Modos de activación por voz y conversación | Transcripción de notas de voz | **Proveedores STT + TTS integrados** |
| MCP | Soporte de plugins/integraciones | Integración MCP | **stdio + HTTP/SSE** |
| Skills | Skills incluidas, gestionadas y del workspace | Skills de auto-mejora y soporte de Skills Hub | **Skills incluidas/del workspace + mejora autónoma + importación de OpenClaw** |
| Memoria/RAG | Memoria y motor de contexto respaldados por plugins | Memoria curada por el agente, búsqueda de sesiones, modelado del usuario | **SQLite + FTS + memoria vectorial** |

\* LoC medido con `tokei`, excluyendo `node_modules`, salida de compilación generada, `dist` y `target`.

> [Comparación completa en la documentación →](https://docs.moltis.org/comparison.html)

## Arquitectura — Mapa de crates

Workspace actual de Rust: ~270K LoC en 59 crates. La siguiente tabla agrupa los crates principales por rol para que la arquitectura siga siendo fácil de escanear.

**Runtime principal**:

| Crate | LoC | Rol |
|-------|-----|------|
| `moltis-gateway` | 37.4K | Servidor HTTP/WS, RPC, autenticación, cableado de arranque |
| `moltis-tools` | 37.0K | Ejecución de herramientas, sandboxing, herramientas WASM |
| `moltis-providers` | 18.9K | Implementaciones de proveedores LLM |
| `moltis-agents` | 14.5K | Bucle del agente, streaming, ensamblado de prompts |
| `moltis-chat` | 14.2K | Motor de chat, orquestación de agentes |
| `moltis-config` | 10.3K | Configuración, validación |
| `moltis-httpd` | 9.9K | Primitivas y middleware del servidor HTTP |
| `moltis` (CLI) | 4.7K | Punto de entrada, comandos CLI |
| `moltis-sessions` | 3.5K | Persistencia de sesiones |
| `moltis-common` | 1.5K | Utilidades compartidas |
| `moltis-service-traits` | 1.2K | Interfaces de servicio compartidas |
| `moltis-protocol` | 0.7K | Tipos del protocolo de comunicación |

**Crates de funcionalidades e integraciones**:

| Categoría | Crates | LoC combinadas |
|----------|--------|-------------|
| Canales | `moltis-telegram`, `moltis-whatsapp`, `moltis-signal`, `moltis-discord`, `moltis-msteams`, `moltis-matrix`, `moltis-slack`, `moltis-nostr`, `moltis-channels` | 34.0K |
| Web y APIs | `moltis-web`, `moltis-graphql`, `moltis-webhooks` | 10.8K |
| Extensibilidad | `moltis-mcp`, `moltis-mcp-agent-bridge`, `moltis-skills`, `moltis-plugins` | 11.5K |
| Memoria y contexto | `moltis-memory`, `moltis-qmd`, `moltis-code-index`, `moltis-projects` | 11.7K |
| Voz y navegador | `moltis-voice`, `moltis-browser` | 9.2K |
| Autenticación y seguridad | `moltis-auth`, `moltis-oauth`, `moltis-vault`, `moltis-secret-store`, `moltis-network-filter`, `moltis-tls` | 8.5K |
| Programación y automatización | `moltis-cron`, `moltis-caldav`, `moltis-auto-reply` | 4.7K |
| Configuración e importación | `moltis-provider-setup`, `moltis-openclaw-import`, `moltis-onboarding` | 11.7K |
| Hosts nativos y de nodo | `moltis-swift-bridge`, `moltis-node-host`, `moltis-courier` | 5.7K |
| Herramientas WASM | `moltis-wasm-precompile`, `moltis-wasm-calc`, `moltis-wasm-web-fetch`, `moltis-wasm-web-search` | 1.4K |
| Crates de soporte | `moltis-media`, `moltis-metrics`, `moltis-tailscale`, `moltis-routing`, `moltis-canvas`, `moltis-schema-export`, `benchmarks` | 2.1K |

Usa `--no-default-features --features lightweight` para dispositivos con recursos limitados (Raspberry Pi, etc.).

## Seguridad

- **Pequeña superficie insegura** — el código central del agente/gateway permanece en Rust seguro; lo inseguro está aislado en la FFI de Swift, los wrappers de modelos locales y los límites de WASM precompilado
- **Ejecución en sandbox** — Docker + Apple Container, aislamiento por sesión
- **Manejo de secretos** — `secrecy::Secret`, se pone a cero al liberarse, redactado de la salida de herramientas
- **Autenticación** — contraseña + passkey (WebAuthn), con límite de tasa, limitación por IP
- **Protección SSRF** — resuelto por DNS, bloquea loopback/privadas/link-local
- **Validación de origen** — rechaza upgrades de WebSocket de origen cruzado
- **Control por hooks** — los hooks `BeforeToolCall` pueden inspeccionar/bloquear cualquier invocación de herramienta
- **Integridad de la cadena de suministro** — [atestaciones de artefactos](https://github.com/moltis-org/moltis/attestations), firma sin clave con Sigstore, firma GPG (YubiKey), sumas de verificación SHA-256/SHA-512

Consulta [Arquitectura de Seguridad](https://docs.moltis.org/security.html) para más detalles.
Verifica las versiones con `gh attestation verify <artifact> -R moltis-org/moltis` o consulta [Verificación de Versiones](https://docs.moltis.org/release-verification.html).

## Características

- **Valores predeterminados de razonamiento** - Esfuerzo de pensamiento predeterminado configurable para sesiones principales sin modelo y nuevas, con anulaciones explícitas por sesión de Desactivado o de nivel
- **Gateway de IA** — Soporte de LLM multiproveedor (OpenAI Codex, GitHub Copilot, Local), respuestas en streaming, bucle de agente con delegación a subagentes, modos de sesión, ejecución paralela de herramientas
- **Comunicación** — Interfaz web con prompts de agente mediante paleta de comandos y copia/exportación de Markdown, Telegram, Signal, Microsoft Teams, Discord, Slack con tarjetas de herramientas nativas en vivo, DMs de Nostr + chat grupal NIP-29 (incl. canales Buzz de Block), acceso por API, E/S de voz (8 proveedores TTS + 7 STT), PWA móvil con notificaciones push
- **Aplicación de escritorio** — Cliente nativo Rust/gpui que se conecta a un daemon en ejecución localmente, por HTTPS o mediante un túnel SSH; claves API con alcance almacenadas en el llavero, fijación de certificados, markdown nativo en streaming, aprobaciones con notificaciones del sistema
- **Memoria y recuperación** — Espacios de trabajo de memoria por agente, memoria a largo plazo impulsada por embeddings, búsqueda híbrida de vectores + texto completo, persistencia de sesión con autocompactación, recuperación entre sesiones, contexto de proyecto compatible con Cursor, escaneo de seguridad de archivos de contexto
- **Archivos gestionados** - Gestión de archivos anidados autenticada en Ajustes, con una ruta de host anunciada por el agente y montajes independientes de solo lectura por defecto para los sandboxes de Docker, Podman y Apple Container
- **Edición de agente más segura** — Puntos de control automáticos antes de mutaciones de habilidades y memoria integradas, herramientas de restauración, ramificación de sesiones
- **Extensibilidad** — Servidores MCP (stdio + HTTP/SSE), sistema de habilidades, 15 eventos de hook de ciclo de vida con circuit breaker, protección contra comandos destructivos
- **Agent Client Protocol** — controla agentes ACP externos (`codex-acp`, `claude-agent-acp`, Cursor), y sirve Moltis a clientes ACP por stdio mediante `moltis acp`
- **Primera ejecución** — Abre la incorporación en tu navegador con el código de configuración prerrellenado, sirve `http://localhost` sin certificado, ofrece una vez confiar en una CA local con nombre restringido para HTTPS en LAN, y fija la URL de la interfaz web debajo de los registros del terminal (con una sugerencia de `ssh -L` por SSH)
- **Seguridad** — Bóveda de cifrado en reposo (XChaCha20-Poly1305 + Argon2id), autenticación por contraseña + passkey + clave API, aislamiento en sandbox, protección SSRF/CSWSH
- **Operaciones** — Programación cron, CalDAV local duradero, Gmail, correo Himalaya, y conjuntos de datos de mensajes reutilizables de Slack/Discord/Matrix/Teams, herramientas de agente de solo lectura específicas del proveedor, búsqueda de texto completo rápida, proyecciones JSONL/Markdown, instrumentación de agente (Langfuse para trazas de LLM, OTLP para Grafana/Datadog), métricas de Prometheus, despliegue en la nube (Fly.io, DigitalOcean), integración con Tailscale, claves de despliegue SSH gestionadas, objetivos remotos fijados al host, inventario de herramientas en vivo en Ajustes, y flujos de doctor de ejecución remota por CLI/web

## Cómo funciona

Moltis es un **servidor de agente persistente local-first** — un único binario en Rust que
se sitúa entre tú y múltiples proveedores de LLM, mantiene estado de sesión duradero, y
puede encontrarse contigo a través de distintos canales sin entregar tus datos a un relay en la nube.

```
┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│   Web UI    │  │  Telegram   │  │  Discord    │
└──────┬──────┘  └──────┬──────┘  └──────┬──────┘
       │                │                │
       └────────┬───────┴────────┬───────┘
                │   WebSocket    │
                ▼                ▼
        ┌─────────────────────────────────┐
        │          Gateway Server         │
        │   (Axum · HTTP · WS · Auth)     │
        ├─────────────────────────────────┤
        │        Chat Service             │
        │  ┌───────────┐ ┌─────────────┐  │
        │  │   Agent   │ │    Tool     │  │
        │  │   Runner  │◄┤   Registry  │  │
        │  └─────┬─────┘ └─────────────┘  │
        │        │                        │
        │  ┌─────▼─────────────────────┐  │
        │  │    Provider Registry      │  │
        │  │  Multiple providers       │  │
        │  │  (Codex · Copilot · Local)│  │
        │  └───────────────────────────┘  │
        ├─────────────────────────────────┤
        │  Sessions  │ Memory  │  Hooks   │
        │  (JSONL)   │ (SQLite)│ (events) │
        └─────────────────────────────────┘
                       │
               ┌───────▼───────┐
               │    Sandbox    │
               │ Docker/Apple  │
               │  Container    │
               └───────────────┘
```

Consulta [Quickstart](https://docs.moltis.org/quickstart.html) para obtener detalles sobre el inicio del gateway, el flujo de mensajes, las sesiones y la memoria.

## Primeros pasos

### Compilar y ejecutar

Requiere [just](https://github.com/casey/just) (ejecutor de comandos) y Node.js (para Tailwind CSS).

```bash
git clone https://github.com/moltis-org/moltis.git
cd moltis
just build-css                  # Build Tailwind CSS for the web UI
just build-release              # Build in release mode
cargo run --release --bin moltis
```

Para una compilación de versión completa que incluya las herramientas del sandbox WASM:

```bash
just build-release-with-wasm    # Builds WASM artifacts + release binary
cargo run --release --bin moltis
```

Abre `https://moltis.localhost:3000`. En la primera ejecución, se imprime un código de configuración en la terminal — ingrésalo en la interfaz web para establecer tu contraseña o registrar una passkey.

Flags opcionales: `--config-dir /path/to/config --data-dir /path/to/data`

### Docker

```bash
# Docker / OrbStack
docker run -d \
  --name moltis \
  -p 13131:13131 \
  -p 13132:13132 \
  -p 1455:1455 \
  -v moltis-config:/home/moltis/.config/moltis \
  -v moltis-data:/home/moltis/.moltis \
  -v /var/run/docker.sock:/var/run/docker.sock \
  ghcr.io/moltis-org/moltis:latest
```

Abre `https://localhost:13131` y completa la configuración. Para despliegues de Docker sin supervisión, establece `MOLTIS_PASSWORD`, `MOLTIS_PROVIDER` y `MOLTIS_API_KEY` antes del primer arranque para omitir el asistente de configuración. Consulta la [documentación de Docker](https://docs.moltis.org/docker.html) para obtener detalles sobre Podman, OrbStack, la confianza TLS y la persistencia.

### Despliegue en la nube

| Proveedor | Desplegar |
|----------|--------|
| DigitalOcean | [![Deploy to DO](https://www.deploytodo.com/do-btn-blue.svg)](https://cloud.digitalocean.com/apps/new?repo=https://github.com/moltis-org/moltis/tree/main) |

**Fly.io** (CLI):

```bash
fly launch --image ghcr.io/moltis-org/moltis:latest
fly secrets set MOLTIS_PASSWORD="your-password"
```

Todas las configuraciones de la nube usan `--no-tls` porque el proveedor gestiona la terminación de TLS.
Consulte la [documentación de Cloud Deploy](https://docs.moltis.org/cloud-deploy.html) para más detalles.

## Licencia

MIT