Moltis hat kürzlich die Titelseite von Hacker News erreicht. Bitte öffne ein Issue bei jeglicher Reibung. Ich konzentriere mich darauf, Moltis exzellent zu machen.

Sicherheit durch Design — Deine Schlüssel verlassen niemals deinen Rechner. Jeder Befehl läuft in einem sandboxed Container, niemals auf deinem Host.

Deine Hardware — Läuft auf einem Mac Mini, einem Raspberry Pi oder jedem Server, den du besitzt. Ein Rust-Binary, kein Node.js, kein npm, keine Laufzeit.

Voll ausgestattet — Sprache, Gedächtnis, sitzungsübergreifender Abruf, automatische Bearbeitungs-Checkpoints, Zeitplanung, Telegram, Signal, Discord, Browser-Automatisierung, MCP-Server, SSH- oder node-gestützte Remote-Ausführung, verwaltete Deploy-Keys mit Host-Pinning in der Web-UI, ein Live-Inventar unter Einstellungen → Tools, Cursor-kompatibler Projektkontext und Bedrohungsscanning von Kontextdateien — alles integriert. Kein Plugin-Marktplatz, über den die Lieferkette angegriffen werden kann.

Prüfbar — Der Agent-Runner und die Modellschnittstelle umfassen ~7,5K Zeilen, mit Providern in weiteren ~19K. Der Rust-Workspace umfasst ~270K Zeilen über 59 modulare Crates, die du unabhängig prüfen kannst, mit 470+ Rust-Dateien, die Tests enthalten. Unsicherer Code ist auf FFI- und vorkompilierte Runtime-Grenzen isoliert, nicht auf die Kern-Agent-Schleife.

Installation

# Einzeiler-Installationsskript (macOS / Linux)
curl -fsSL https://www.moltis.org/install.sh | sh

# macOS / Linux über Homebrew
brew install moltis-org/tap/moltis

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

# Oder aus dem Quellcode bauen
cargo install moltis --git https://github.com/moltis-org/moltis

Vergleich

* LoC gemessen mit tokei, ohne node_modules, generierte Build-Ausgabe, dist und target.

Vollständiger Vergleich in der Dokumentation →

Architektur — Crate-Karte

Aktueller Rust-Workspace: ~270K LoC über 59 Crates. Die folgende Tabelle gruppiert die Haupt-Crates nach Rolle, damit die Architektur überschaubar bleibt.

Kern-Laufzeit:

Feature- und Integrations-Crates:

Verwende --no-default-features --features lightweight für Geräte mit begrenzten Ressourcen (Raspberry Pi usw.).

Sicherheit

• Kleine unsichere Oberfläche — Kern-Agent/Gateway-Code bleibt sicheres Rust; unsicherer Code ist auf Swift-FFI, lokale Modell-Wrapper und vorkompilierte WASM-Grenzen isoliert
• Sandboxed Ausführung — Docker + Apple Container, Isolation pro Sitzung
• Geheimnisbehandlung — secrecy::Secret, bei Drop gelöscht, aus Tool-Ausgabe redigiert
• Authentifizierung — Passwort + Passkey (WebAuthn), ratenbegrenzt, pro-IP-Drosselung
• SSRF-Schutz — DNS-aufgelöst, blockiert Loopback/private/link-lokale Adressen
• Origin-Validierung — lehnt Cross-Origin-WebSocket-Upgrades ab
• Hook-Gating — BeforeToolCall-Hooks können jede Tool-Invokation prüfen/blockieren
• Lieferketten-Integrität — Artefakt-Attestierungen, Sigstore-schlüsselloses Signieren, GPG-Signierung (YubiKey), SHA-256/SHA-512-Prüfsummen

Details in der Sicherheitsarchitektur. Verifiziere Releases mit gh attestation verify <artifact> -R moltis-org/moltis oder siehe Release-Verifizierung.

Funktionen

• AI-Gateway — Multi-Provider-LLM-Unterstützung (OpenAI Codex, GitHub Copilot, Lokal), Streaming-Antworten, Agent-Schleife mit Sub-Agent-Delegation, Sitzungsmodi, parallele Tool-Ausführung
• Kommunikation — Web-UI mit Command-Palette-Agent-Prompts und Markdown-Kopieren/Exportieren, Telegram, Signal, Microsoft Teams, Discord, Slack mit nativen Live-Tool-Karten, Nostr-DMs + NIP-29-Gruppenchat (inkl. Block's Buzz-Kanälen), API-Zugriff, Sprach-I/O (8 TTS- + 7 STT-Provider), mobile PWA mit Push-Benachrichtigungen
• Speicher & Abruf — Speicher-Workspaces pro Agent, Embeddings-gestützter Langzeitspeicher, hybride Vektor- + Volltextsuche, Sitzungspersistenz mit Auto-Kompaktierung, sitzungsübergreifender Abruf, Cursor-kompatibler Projektkontext, Sicherheitsscanning von Kontextdateien
• Verwaltete Dateien — Authentifizierte verschachtelte Dateiverwaltung in den Einstellungen, mit einem vom Agent beworbenen Host-Pfad und unabhängigen standardmäßig schreibgeschützten Mounts für Docker-, Podman- und Apple-Container-Sandboxes
• Sichereres Agent-Bearbeiten — Automatische Checkpoints vor integrierten Skill- und Speicher-Mutationen, Wiederherstellungs-Tooling, Sitzungs-Verzweigung
• Erweiterbarkeit — MCP-Server (stdio + HTTP/SSE), Skill-System, 15 Lifecycle-Hook-Ereignisse mit Circuit Breaker, Schutz vor destruktiven Befehlen
• Agent-Client-Protokoll — treibt externe ACP-Agenten (codex-acp, claude-agent-acp, Cursor) an und stellt Moltis ACP-Clients über stdio via moltis acp bereit
• Sicherheit — Verschlüsselter Vault im Ruhezustand (XChaCha20-Poly1305 + Argon2id), Passwort- + Passkey- + API-Key-Auth, Sandbox-Isolation, SSRF/CSWSH-Schutz
• Betrieb — Cron-Zeitplanung, dauerhafter lokaler CalDAV, Gmail, Himalaya-E-Mail und wiederverwendbare Slack-/Discord-/Matrix-/Teams-Nachrichtendatensätze, provider-spezifische schreibgeschützte Agent-Tools, schnelle Volltextsuche, JSONL/Markdown-Projektionen, Agent-Instrumentierung (Langfuse für LLM-Traces, OTLP für Grafana/Datadog), Prometheus-Metriken, Cloud-Deploy (Fly.io, DigitalOcean), Tailscale-Integration, verwaltete SSH-Deploy-Keys, host-gepinnte Remote-Ziele, Live-Tool-Inventar in den Einstellungen und CLI/Web-Remote-Exec-Doctor-Abläufe

So funktioniert es

Moltis ist ein lokaler persistenter Agent-Server — ein einzelnes Rust-Binary, das zwischen dir und mehreren LLM-Providern sitzt, dauerhaften Sitzungszustand hält und dich über Kanäle erreichen kann, ohne deine Daten an ein Cloud-Relay weiterzugeben.

┌─────────────┐  ┌─────────────┐  ┌─────────────┐
│   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    │
               └───────────────┘

Siehe Quickstart für Gateway-Start, Nachrichtenfluss, Sitzungen und Speicherdetails.

Erste Schritte

Bauen & Ausführen

Erfordert just (Befehls-Runner) und Node.js (für Tailwind CSS).

git clone https://github.com/moltis-org/moltis.git
cd moltis
just build-css                  # Tailwind CSS für die Web-UI bauen
just build-release              # Im Release-Modus bauen
cargo run --release --bin moltis

Für einen vollständigen Release-Build inklusive WASM-Sandbox-Tools:

just build-release-with-wasm    # Baut WASM-Artefakte + Release-Binary
cargo run --release --bin moltis

Öffne https://moltis.localhost:3000. Beim ersten Start wird ein Einrichtungscode im Terminal ausgegeben — gib ihn in der Web-UI ein, um dein Passwort festzulegen oder einen Passkey zu registrieren.

Optionale Flags: --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

Öffne https://localhost:13131 und schließe die Einrichtung ab. Für unbeaufsichtigte Docker- Bereitstellungen setze MOLTIS_PASSWORD, MOLTIS_PROVIDER und MOLTIS_API_KEY vor dem ersten Start, um den Einrichtungsassistenten zu überspringen. Siehe Docker-Dokumentation für Podman, OrbStack, TLS-Vertrauen und Persistenzdetails.

Cloud-Bereitstellung

Anbieter	Bereitstellen
DigitalOcean

Fly.io (CLI):

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

Alle Cloud-Konfigurationen verwenden --no-tls, da der Anbieter die TLS-Terminierung übernimmt. Siehe Cloud-Deploy-Dokumentation für Details.

Lizenz

MIT