Moltis ha recentemente raggiunto la prima pagina di Hacker News. Per favore apri un issue per qualsiasi attrito. Sono concentrato sul rendere Moltis eccellente.

Sicuro by design — 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 che possiedi. Un singolo binario Rust, niente Node.js, niente npm, niente runtime.

Completo di funzionalità — Voce, memoria, richiamo tra sessioni, checkpoint automatici di modifica, pianificazione, Telegram, Signal, Discord, automazione del browser, server MCP, esecuzione remota basata su SSH o node, chiavi di deploy gestite con pinning dell'host nella UI web, un inventario live Settings → Tools, contesto di progetto compatibile con Cursor, e scansione delle minacce dei file di contesto — tutto integrato. Nessun marketplace di plugin da cui essere attaccati tramite supply chain.

Auditabile — Il runner dell'agente e l'interfaccia del modello rientrano in ~7.5K righe, con i provider in ~19K righe aggiuntive. Il workspace Rust è di ~270K righe distribuite su 59 crate modulari che puoi auditare indipendentemente, con oltre 470 file Rust contenenti test. Il codice unsafe è isolato ai confini FFI e dei runtime precompilati, non al loop centrale dell'agente.

Installazione

# Script di installazione one-liner (macOS / Linux)
curl -fsSL https://www.moltis.org/install.sh | sh

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

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

# Oppure compila dal sorgente
cargo install moltis --git https://github.com/moltis-org/moltis

Confronto

* LoC misurati con tokei, escludendo node_modules, output di build generati, dist e target.

Confronto completo nella documentazione →

Architettura — Mappa dei Crate

Workspace Rust attuale: ~270K LoC distribuiti su 59 crate. La tabella seguente raggruppa i crate principali per ruolo così l'architettura resta scansionabile.

Runtime core:

Crate di funzionalità e integrazione:

Usa --no-default-features --features lightweight per dispositivi con risorse limitate (Raspberry Pi, ecc.).

Sicurezza

• Piccola superficie unsafe — il codice core agente/gateway resta Rust sicuro; unsafe è isolato a Swift FFI, wrapper di modelli locali e confini WASM precompilati
• Esecuzione sandboxed — Docker + Apple Container, isolamento per sessione
• Gestione segreti — secrecy::Secret, azzerato al drop, redatto dall'output degli strumenti
• Autenticazione — password + passkey (WebAuthn), rate-limited, throttle per IP
• Protezione SSRF — risolto tramite DNS, blocca loopback/privato/link-local
• Validazione origine — rifiuta upgrade WebSocket cross-origin
• Gating hook — gli hook BeforeToolCall possono ispezionare/bloccare qualsiasi invocazione di strumento
• Integrità supply chain — attestazioni artefatti, firma keyless Sigstore, firma GPG (YubiKey), checksum SHA-256/SHA-512

Vedi Architettura di Sicurezza per i dettagli. Verifica le release con gh attestation verify <artifact> -R moltis-org/moltis o vedi Verifica Release.

Funzionalità

• AI Gateway — Supporto LLM multi-provider (OpenAI Codex, GitHub Copilot, Local), risposte in streaming, loop agente con delega sub-agente, modalità sessione, esecuzione parallela degli strumenti
• Comunicazione — Web UI con prompt agente a command-palette e copia/esportazione Markdown, Telegram, Signal, Microsoft Teams, Discord, Slack con card strumenti live native, DM Nostr + chat di gruppo NIP-29 (incl. canali Buzz di Block), accesso API, I/O vocale (8 provider TTS + 7 STT), PWA mobile con notifiche push
• Memoria & Richiamo — Workspace di memoria per agente, memoria a lungo termine basata su embeddings, ricerca ibrida vettoriale + full-text, persistenza sessioni con auto-compattazione, richiamo tra sessioni, contesto di progetto compatibile con Cursor, scansione di sicurezza dei file di contesto
• File Gestiti — Gestione file nidificata autenticata in Settings, con percorso host annunciato dall'agente e mount indipendenti read-only-by-default per sandbox Docker, Podman e Apple Container
• Modifica Agente più Sicura — Checkpoint automatici prima delle mutazioni di skill e memoria integrate, tooling di ripristino, branching delle sessioni
• Estensibilità — Server MCP (stdio + HTTP/SSE), sistema di skill, 15 eventi hook del ciclo di vita con circuit breaker, guardia comandi distruttivi
• Protocollo Client Agente — guida agenti ACP esterni (codex-acp, claude-agent-acp, Cursor), e serve Moltis ai client ACP tramite stdio con moltis acp
• Sicurezza — Vault crittografato at-rest (XChaCha20-Poly1305 + Argon2id), auth password + passkey + API key, isolamento sandbox, protezione SSRF/CSWSH
• Operazioni — Pianificazione Cron, CalDAV locale durevole, Gmail, email Himalaya, e dataset di messaggi riutilizzabili Slack/Discord/Matrix/Teams, strumenti agente read-only specifici per provider, ricerca full-text veloce, proiezioni JSONL/Markdown, strumentazione agente (Langfuse per trace LLM, OTLP per Grafana/Datadog), metriche Prometheus, deploy cloud (Fly.io, DigitalOcean), integrazione Tailscale, chiavi di deploy SSH gestite, target remoti con pinning host, inventario strumenti live in Settings, e flussi doctor di remote-exec CLI/web

Come Funziona

Moltis è un server agente persistente local-first — un singolo binario Rust che si posiziona tra te e più provider LLM, mantiene stato di sessione durevole, e può incontrarti attraverso i 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    │
               └───────────────┘

Vedi Quickstart per avvio gateway, flusso messaggi, sessioni e dettagli sulla memoria.

Per Iniziare

Build & Run

Richiede just (command runner) e Node.js (per Tailwind CSS).

git clone https://github.com/moltis-org/moltis.git
cd moltis
just build-css                  # Build Tailwind CSS per la web UI
just build-release              # Build in modalità release
cargo run --release --bin moltis

Per una build release completa inclusi gli strumenti sandbox WASM:

just build-release-with-wasm    # Compila artefatti WASM + binario release
cargo run --release --bin moltis

Apri https://moltis.localhost:3000. Al primo avvio, un codice di setup viene stampato sul terminale — inseriscilo nella web UI per impostare la tua password o registrare una passkey.

Flag opzionali: --config-dir /path/to/config --data-dir /path/to/data

Docker

# 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 il setup. Per deploy Docker unattended, imposta MOLTIS_PASSWORD, MOLTIS_PROVIDER e MOLTIS_API_KEY prima del primo avvio per saltare la procedura guidata di setup. Vedi documentazione Docker per dettagli su Podman, OrbStack, trust TLS e persistenza.

Deploy Cloud

Provider	Deploy
DigitalOcean

Fly.io (CLI):

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 documentazione Cloud Deploy per i dettagli.

Licenza

MIT