Un server agente personale persistente e sicuro in Rust. Un singolo binario, esecuzione in sandbox, LLM multi-provider, voce, memoria, strumenti per Telegram, WhatsApp, Discord, Teams e MCP. Sicuro per progettazione, funziona sul tuo hardware.
<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 server agente personale persistente e sicuro in Rust
Un solo binario — sandboxed, sicuro, tuo.
[](https://github.com/moltis-org/moltis/actions/workflows/ci.yml)
[](https://codecov.io/gh/moltis-org/moltis)
[](https://codspeed.io/moltis-org/moltis)
[](LICENSE)
[](https://www.rust-lang.org)
[](https://discord.gg/XnmrepsXp5)
[Installazione](#installation) • [Confronto](#comparison) • [Architettura](#architecture--crate-map) • [Sicurezza](#security) • [Funzionalità](#features) • [Come funziona](#how-it-works) • [Contribuire](https://github.com/moltis-org/moltis/blob/main/CONTRIBUTING.md)
</div>
---
Moltis ha recentemente raggiunto [la prima pagina di Hacker News](https://news.ycombinator.com/item?id=46993587). Per qualsiasi difficoltà, [apri una issue](https://github.com/moltis-org/moltis/issues). Sono concentrato nel rendere Moltis eccellente.
**Sicuro fin dalla progettazione** — Le tue chiavi non lasciano mai la tua macchina. Ogni comando viene eseguito in un container sandboxed, mai sul tuo host.
**Il tuo hardware** — Funziona su un Mac Mini, un Raspberry Pi o qualsiasi server di tua proprietà. Un solo binario Rust, niente Node.js, niente npm, niente runtime.
**Completo di funzionalità** — Voce, memoria, richiamo tra sessioni, checkpoint automatici delle modifiche, pianificazione, Telegram, Signal, Discord, automazione del browser, server MCP, esecuzione remota via SSH o tramite nodo, chiavi di deploy gestite con host pinning nella web UI, un inventario live in Impostazioni → Strumenti, contesto di progetto compatibile con Cursor e scansione delle minacce nei file di contesto — tutto integrato. Nessun marketplace di plugin attraverso cui subire attacchi alla supply chain.
**Verificabile** — L'agent runner e l'interfaccia del modello occupano circa 7,5K righe, con i provider in altre ~19K. Il workspace Rust conta circa 270K righe distribuite su 59 crate modulari che puoi verificare in modo indipendente, con oltre 470 file Rust contenenti test. Il codice unsafe è isolato ai confini FFI e del runtime precompilato, non nel core dell'agent loop.
## Installazione
```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
```
## Confronto
| | OpenClaw | Hermes Agent | **Moltis** |
|---|---|---|---|
| Stack principale | TypeScript + app companion Swift/Kotlin | Python + interfacce TUI/web TypeScript | **Rust** |
| Runtime | Node.js + npm/pnpm/bun | Python + uv/pip, componenti UI Node opzionali | **Binario Rust singolo** |
| Dimensione checkout locale\* | ~1,1M LoC dell'app | ~152K LoC dell'app | **~270K LoC Rust** |
| Architettura | Ecosistema ampio di gateway, canali, nodi e app | Agente CLI/gateway con ciclo di apprendimento e strumenti di ricerca | **Server agente personale persistente con crate modulari** |
| Crate/moduli | Pacchetti npm, estensioni, app | Pacchetti Python, plugin, strumenti, TUI | **59 crate del workspace Rust** |
| Sandbox/backend | Permessi a livello di app, strumenti browser/nodo | Locale, Docker, SSH, Daytona, Singularity, Modal | **Docker/Podman + Apple Container + WASM** |
| Auth/accesso | Pairing e controlli del gateway locale | Configurazione CLI e gateway di messaggistica | **Password + Passkey + chiavi API + Vault** |
| I/O vocale | Modalità voice wake e talk | Trascrizione di memo vocali | **Provider STT + TTS integrati** |
| MCP | Supporto plugin/integrazione | Integrazione MCP | **stdio + HTTP/SSE** |
| Skills | Skill incluse, gestite e del workspace | Skill auto-miglioranti e supporto Skills Hub | **Skill incluse/del workspace + miglioramento autonomo + import da OpenClaw** |
| Memoria/RAG | Memoria e motore di contesto basati su plugin | Memoria curata dall'agente, ricerca nelle sessioni, modellazione utente | **SQLite + FTS + memoria vettoriale** |
\* LoC misurate con `tokei`, escludendo `node_modules`, output di build generato, `dist` e `target`.
> [Confronto completo nella documentazione →](https://docs.moltis.org/comparison.html)
## Architettura — Mappa dei crate
Workspace Rust attuale: ~270K LoC distribuite su 59 crate. La tabella sottostante raggruppa i crate principali per ruolo, così l'architettura resta di facile lettura.
**Runtime principale**:
| Crate | LoC | Ruolo |
|-------|-----|------|
| `moltis-gateway` | 37.4K | Server HTTP/WS, RPC, auth, cablaggio di avvio |
| `moltis-tools` | 37.0K | Esecuzione degli strumenti, sandboxing, strumenti WASM |
| `moltis-providers` | 18.9K | Implementazioni dei provider LLM |
| `moltis-agents` | 14.5K | Ciclo dell'agente, streaming, assemblaggio del prompt |
| `moltis-chat` | 14.2K | Motore di chat, orchestrazione degli agenti |
| `moltis-config` | 10.3K | Configurazione, validazione |
| `moltis-httpd` | 9.9K | Primitive e middleware del server HTTP |
| `moltis` (CLI) | 4.7K | Punto di ingresso, comandi CLI |
| `moltis-sessions` | 3.5K | Persistenza delle sessioni |
| `moltis-common` | 1.5K | Utility condivise |
| `moltis-service-traits` | 1.2K | Interfacce di servizio condivise |
| `moltis-protocol` | 0.7K | Tipi del protocollo di comunicazione |
**Crate di funzionalità e integrazione**:
| Categoria | Crate | LoC complessive |
|----------|--------|-------------|
| Canali | `moltis-telegram`, `moltis-whatsapp`, `moltis-signal`, `moltis-discord`, `moltis-msteams`, `moltis-matrix`, `moltis-slack`, `moltis-nostr`, `moltis-channels` | 34.0K |
| Web e API | `moltis-web`, `moltis-graphql`, `moltis-webhooks` | 10.8K |
| Estensibilità | `moltis-mcp`, `moltis-mcp-agent-bridge`, `moltis-skills`, `moltis-plugins` | 11.5K |
| Memoria e contesto | `moltis-memory`, `moltis-qmd`, `moltis-code-index`, `moltis-projects` | 11.7K |
| Voce e browser | `moltis-voice`, `moltis-browser` | 9.2K |
| Auth e sicurezza | `moltis-auth`, `moltis-oauth`, `moltis-vault`, `moltis-secret-store`, `moltis-network-filter`, `moltis-tls` | 8.5K |
| Pianificazione e automazione | `moltis-cron`, `moltis-caldav`, `moltis-auto-reply` | 4.7K |
| Setup e import | `moltis-provider-setup`, `moltis-openclaw-import`, `moltis-onboarding` | 11.7K |
| Host nativi e nodo | `moltis-swift-bridge`, `moltis-node-host`, `moltis-courier` | 5.7K |
| Strumenti WASM | `moltis-wasm-precompile`, `moltis-wasm-calc`, `moltis-wasm-web-fetch`, `moltis-wasm-web-search` | 1.4K |
| Crate di supporto | `moltis-media`, `moltis-metrics`, `moltis-tailscale`, `moltis-routing`, `moltis-canvas`, `moltis-schema-export`, `benchmarks` | 2.1K |
Usa `--no-default-features --features lightweight` per dispositivi con risorse limitate (Raspberry Pi, ecc.).
## Sicurezza
- **Superficie unsafe ridotta** — il codice core di agent/gateway rimane Rust sicuro; l'unsafe è isolato alle FFI Swift, ai wrapper dei modelli locali e ai confini WASM precompilati
- **Esecuzione in sandbox** — Docker + Apple Container, isolamento per sessione
- **Gestione dei segreti** — `secrecy::Secret`, azzerato al drop, oscurato nell'output degli strumenti
- **Autenticazione** — password + passkey (WebAuthn), con rate limiting e throttling per IP
- **Protezione SSRF** — risoluzione DNS, blocca loopback/private/link-local
- **Validazione dell'origine** — rifiuta gli upgrade WebSocket cross-origin
- **Gating degli hook** — gli hook `BeforeToolCall` possono ispezionare/bloccare qualsiasi invocazione di strumenti
- **Integrità della supply chain** — [attestazioni degli artefatti](https://github.com/moltis-org/moltis/attestations), firma keyless Sigstore, firma GPG (YubiKey), checksum SHA-256/SHA-512
Vedi [Security Architecture](https://docs.moltis.org/security.html) per i dettagli.
Verifica le release con `gh attestation verify <artifact> -R moltis-org/moltis` oppure consulta [Release Verification](https://docs.moltis.org/release-verification.html).
## Funzionalità
- **Reasoning Defaults** - Sforzo di ragionamento predefinito configurabile per sessioni senza modello e nuove sessioni principali, con override espliciti per sessione Off o per livello
- **AI Gateway** — Supporto multi-provider LLM (OpenAI Codex, GitHub Copilot, Local), risposte in streaming, agent loop con delega a sub-agent, modalità di sessione, esecuzione parallela degli strumenti
- **Comunicazione** — Web UI con prompt dell'agente tramite command palette e copia/esportazione Markdown, Telegram, Signal, Microsoft Teams, Discord, Slack con card native degli strumenti in tempo reale, DM Nostr + chat di gruppo NIP-29 (incl. i canali Buzz di Block), accesso API, I/O vocale (8 provider TTS + 7 STT), PWA mobile con notifiche push
- **App Desktop** — Client nativo Rust/gpui che si collega a un daemon in esecuzione in locale, via HTTPS o tramite tunnel SSH; chiavi API con scope memorizzate nel keychain, certificate pinning, markdown nativo in streaming, approvazioni con notifiche di sistema
- **Memoria e Richiamo** — Workspace di memoria per agente, memoria a lungo termine basata su embeddings, ricerca ibrida vettoriale + full-text, persistenza delle sessioni con auto-compaction, richiamo cross-sessione, contesto di progetto compatibile con Cursor, scansione di sicurezza dei file di contesto
- **File Gestiti** - Gestione annidata e autenticata dei file nelle Impostazioni, con un percorso host pubblicizzato dall'agente e mount indipendenti in sola lettura per impostazione predefinita per le sandbox Docker, Podman e Apple Container
- **Modifica più Sicura dell'Agente** — Checkpoint automatici prima delle mutazioni integrate di skill e memoria, strumenti di ripristino, branching delle sessioni
- **Estensibilità** — Server MCP (stdio + HTTP/SSE), sistema di skill, 15 eventi di hook del ciclo di vita con circuit breaker, protezione dai comandi distruttivi
- **Agent Client Protocol** — pilota agenti ACP esterni (`codex-acp`, `claude-agent-acp`, Cursor) e serve Moltis ai client ACP via stdio tramite `moltis acp`
- **Primo Avvio** — Apre l'onboarding nel browser con il codice di setup precompilato, serve `http://localhost` senza certificato, offre una volta sola di fidarsi di una CA locale con nome vincolato per HTTPS in LAN, e fissa l'URL della web UI sotto i log del terminale (con un suggerimento `ssh -L` via SSH)
- **Sicurezza** — Vault con cifratura at-rest (XChaCha20-Poly1305 + Argon2id), autenticazione con password + passkey + chiave API, isolamento in sandbox, protezione SSRF/CSWSH
- **Operazioni** — Pianificazione cron, CalDAV locale durevole, Gmail, email Himalaya e dataset di messaggi riutilizzabili per Slack/Discord/Matrix/Teams, strumenti agente in sola lettura specifici per provider, ricerca full-text veloce, proiezioni JSONL/Markdown, strumentazione dell'agente (Langfuse per le trace LLM, OTLP per Grafana/Datadog), metriche Prometheus, deploy cloud (Fly.io, DigitalOcean), integrazione Tailscale, chiavi di deploy SSH gestite, target remoti vincolati all'host, inventario degli strumenti in tempo reale nelle Impostazioni e flussi doctor per l'esecuzione remota via CLI/web
## Come Funziona
Moltis è un **server agente persistente local-first** — un singolo binario Rust che
si interpone tra te e più provider LLM, mantiene uno stato di sessione durevole e
può incontrarti su più canali senza consegnare i tuoi dati a un relay cloud.
```
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 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) per l'avvio del gateway, il flusso dei messaggi, le sessioni e i dettagli sulla memoria.
## Per iniziare
### Compilazione ed esecuzione
Richiede [just](https://github.com/casey/just) (command runner) e Node.js (per 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
```
Per una build di rilascio completa che includa gli strumenti sandbox WASM:
```bash
just build-release-with-wasm # Builds WASM artifacts + release binary
cargo run --release --bin moltis
```
Apri `https://moltis.localhost:3000`. Alla prima esecuzione, viene stampato un codice di configurazione nel terminale — inseriscilo nell'interfaccia web per impostare la password o registrare una passkey.
Flag opzionali: `--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
```
Apri `https://localhost:13131` e completa la configurazione. Per le distribuzioni Docker non presidiate, imposta `MOLTIS_PASSWORD`, `MOLTIS_PROVIDER` e `MOLTIS_API_KEY` prima del primo avvio per saltare la procedura guidata di configurazione. Consulta la [documentazione Docker](https://docs.moltis.org/docker.html) per i dettagli su Podman, OrbStack, la fiducia TLS e la persistenza.
### Distribuzione Cloud
| Provider | Deploy |
|----------|--------|
| DigitalOcean | [](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"
```
Tutte le configurazioni cloud usano `--no-tls` perché il provider gestisce la terminazione TLS.
Vedi la [documentazione di Cloud Deploy](https://docs.moltis.org/cloud-deploy.html) per i dettagli.
## Licenza
MIT