Ein sicherer, persistenter persönlicher Agent-Server in Rust. Ein Binärprogramm, isolierte Ausführung, Multi-Provider-LLMs, Sprache, Speicher, Telegram, WhatsApp, Discord, Teams und MCP-Tools. Sicherheitsorientiert, läuft auf Ihrer 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 — Ein sicherer, persistenter persönlicher Agent-Server in Rust
Eine einzige Binärdatei — sandboxed, sicher, gehört dir.
[](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)
[Installation](#installation) • [Vergleich](#comparison) • [Architektur](#architecture--crate-map) • [Sicherheit](#security) • [Funktionen](#features) • [So funktioniert es](#how-it-works) • [Mitwirken](https://github.com/moltis-org/moltis/blob/main/CONTRIBUTING.md)
</div>
---
Moltis hat kürzlich [die Startseite von Hacker News](https://news.ycombinator.com/item?id=46993587) erreicht. Bitte [eröffne ein Issue](https://github.com/moltis-org/moltis/issues) bei jeglichen Problemen. Ich konzentriere mich darauf, Moltis exzellent zu machen.
**Sicher 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. Eine einzige Rust-Binärdatei, kein Node.js, kein npm, keine Runtime.
**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-Schlüssel mit Host-Pinning in der Web-UI, ein Live-Inventar unter Einstellungen → Tools, Cursor-kompatibler Projektkontext und Bedrohungsscanning von Kontextdateien — alles integriert. Kein Plugin-Marketplace, über den man Opfer von Supply-Chain-Angriffen werden könnte.
**Auditierbar** — 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 auditieren kannst, mit 470+ Rust-Dateien, die Tests enthalten. Unsafe-Code ist auf FFI- und vorkompilierte Runtime-Grenzen beschränkt, nicht auf die Kern-Agent-Schleife.
## Installation
```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
```
## Vergleich
| | OpenClaw | Hermes Agent | **Moltis** |
|---|---|---|---|
| Primärer Stack | TypeScript + Swift/Kotlin-Begleit-Apps | Python + TypeScript-TUI/Web-Oberflächen | **Rust** |
| Laufzeit | Node.js + npm/pnpm/bun | Python + uv/pip, optionale Node-UI-Komponenten | **Einzelne Rust-Binary** |
| Größe des lokalen Checkouts\* | ~1,1 Mio. App-LoC | ~152K App-LoC | **~270K Rust-LoC** |
| Architektur | Breites Gateway-, Channel-, Node- und App-Ökosystem | CLI/Gateway-Agent mit Lernschleife und Research-Tooling | **Persistenter persönlicher Agent-Server mit modularen Crates** |
| Crates/Module | npm-Pakete, Erweiterungen, Apps | Python-Pakete, Plugins, Tools, TUI | **59 Rust-Workspace-Crates** |
| Sandbox/Backends | App-Level-Berechtigungen, Browser-/Node-Tools | Lokal, Docker, SSH, Daytona, Singularity, Modal | **Docker/Podman + Apple Container + WASM** |
| Auth/Zugriff | Pairing und lokale Gateway-Steuerung | CLI- und Messaging-Gateway-Einrichtung | **Passwort + Passkey + API-Schlüssel + Vault** |
| Sprach-E/A | Voice-Wake- und Talk-Modi | Voice-Memo-Transkription | **Integrierte STT- + TTS-Provider** |
| MCP | Plugin-/Integrationsunterstützung | MCP-Integration | **stdio + HTTP/SSE** |
| Skills | Mitgelieferte, verwaltete und Workspace-Skills | Selbstverbessernde Skills und Skills-Hub-Unterstützung | **Mitgelieferte/Workspace-Skills + autonome Verbesserung + OpenClaw-Import** |
| Memory/RAG | Plugin-gestütztes Memory und Context-Engine | Agent-kuratierte Memory, Session-Suche, User-Modeling | **SQLite + FTS + Vektor-Memory** |
\* LoC gemessen mit `tokei`, ohne `node_modules`, generierte Build-Ausgaben, `dist` und `target`.
> [Vollständiger Vergleich in der Dokumentation →](https://docs.moltis.org/comparison.html)
## Architektur — Crate-Übersicht
Aktueller Rust-Workspace: ~270K LoC über 59 Crates. Die folgende Tabelle gruppiert die wichtigsten Crates nach Rolle, damit die Architektur übersichtlich bleibt.
**Core-Runtime**:
| Crate | LoC | Rolle |
|-------|-----|------|
| `moltis-gateway` | 37.4K | HTTP/WS-Server, RPC, Auth, Startup-Verdrahtung |
| `moltis-tools` | 37.0K | Tool-Ausführung, Sandboxing, WASM-Tools |
| `moltis-providers` | 18.9K | LLM-Provider-Implementierungen |
| `moltis-agents` | 14.5K | Agent-Loop, Streaming, Prompt-Zusammenstellung |
| `moltis-chat` | 14.2K | Chat-Engine, Agent-Orchestrierung |
| `moltis-config` | 10.3K | Konfiguration, Validierung |
| `moltis-httpd` | 9.9K | HTTP-Server-Primitives und Middleware |
| `moltis` (CLI) | 4.7K | Einstiegspunkt, CLI-Befehle |
| `moltis-sessions` | 3.5K | Session-Persistenz |
| `moltis-common` | 1.5K | Gemeinsame Utilities |
| `moltis-service-traits` | 1.2K | Gemeinsame Service-Schnittstellen |
| `moltis-protocol` | 0.7K | Wire-Protocol-Typen |
**Feature- und Integrations-Crates**:
| Kategorie | Crates | Kombinierte LoC |
|----------|--------|-------------|
| Channels | `moltis-telegram`, `moltis-whatsapp`, `moltis-signal`, `moltis-discord`, `moltis-msteams`, `moltis-matrix`, `moltis-slack`, `moltis-nostr`, `moltis-channels` | 34.0K |
| Web und APIs | `moltis-web`, `moltis-graphql`, `moltis-webhooks` | 10.8K |
| Erweiterbarkeit | `moltis-mcp`, `moltis-mcp-agent-bridge`, `moltis-skills`, `moltis-plugins` | 11.5K |
| Memory und Kontext | `moltis-memory`, `moltis-qmd`, `moltis-code-index`, `moltis-projects` | 11.7K |
| Sprache und Browser | `moltis-voice`, `moltis-browser` | 9.2K |
| Auth und Sicherheit | `moltis-auth`, `moltis-oauth`, `moltis-vault`, `moltis-secret-store`, `moltis-network-filter`, `moltis-tls` | 8.5K |
| Scheduling und Automatisierung | `moltis-cron`, `moltis-caldav`, `moltis-auto-reply` | 4.7K |
| Setup und Import | `moltis-provider-setup`, `moltis-openclaw-import`, `moltis-onboarding` | 11.7K |
| Native- und Node-Hosts | `moltis-swift-bridge`, `moltis-node-host`, `moltis-courier` | 5.7K |
| WASM-Tools | `moltis-wasm-precompile`, `moltis-wasm-calc`, `moltis-wasm-web-fetch`, `moltis-wasm-web-search` | 1.4K |
| Unterstützende Crates | `moltis-media`, `moltis-metrics`, `moltis-tailscale`, `moltis-routing`, `moltis-canvas`, `moltis-schema-export`, `benchmarks` | 2.1K |
Verwende `--no-default-features --features lightweight` für ressourcenbeschränkte Geräte (Raspberry Pi usw.).
## Sicherheit
- **Kleine Unsafe-Oberfläche** — Kern-Agent-/Gateway-Code bleibt in sicherem Rust; unsafe ist auf Swift-FFI, lokale Modell-Wrapper und vorkompilierte WASM-Grenzen isoliert
- **Sandboxed-Ausführung** — Docker + Apple Container, Isolation pro Sitzung
- **Umgang mit Geheimnissen** — `secrecy::Secret`, beim Drop genullt, aus der Tool-Ausgabe redigiert
- **Authentifizierung** — Passwort + Passkey (WebAuthn), ratenbegrenzt, Drosselung pro IP
- **SSRF-Schutz** — DNS-aufgelöst, blockiert Loopback/private/link-local
- **Origin-Validierung** — lehnt Cross-Origin-WebSocket-Upgrades ab
- **Hook-Gating** — `BeforeToolCall`-Hooks können jeden Tool-Aufruf inspizieren/blockieren
- **Integrität der Lieferkette** — [Artefakt-Attestierungen](https://github.com/moltis-org/moltis/attestations), Sigstore-Keyless-Signierung, GPG-Signierung (YubiKey), SHA-256/SHA-512-Prüfsummen
Details siehe [Security Architecture](https://docs.moltis.org/security.html).
Verifiziere Releases mit `gh attestation verify <artifact> -R moltis-org/moltis` oder siehe [Release Verification](https://docs.moltis.org/release-verification.html).
## Features
- **Reasoning-Defaults** – Konfigurierbarer Standard-Denkaufwand für modelllose und neue Hauptsitzungen, mit expliziten Overrides pro Sitzung (Off oder Stufe)
- **AI-Gateway** — Multi-Provider-LLM-Unterstützung (OpenAI Codex, GitHub Copilot, Local), Streaming-Antworten, Agent-Loop mit Sub-Agent-Delegation, Sitzungsmodi, parallele Tool-Ausführung
- **Kommunikation** — Web-UI mit Command-Palette-Agent-Prompts und Markdown-Kopieren/Export, Telegram, Signal, Microsoft Teams, Discord, Slack mit nativen Live-Tool-Karten, Nostr-DMs + NIP-29-Gruppenchat (inkl. Block's Buzz-Kanäle), API-Zugriff, Sprach-I/O (8 TTS- + 7 STT-Provider), mobile PWA mit Push-Benachrichtigungen
- **Desktop-App** — Nativer Rust/gpui-Client, der sich lokal, über HTTPS oder durch einen SSH-Tunnel an einen laufenden Daemon anbindet; im Keychain gespeicherte bereichsbezogene API-Schlüssel, Zertifikats-Pinning, Streaming von nativem Markdown, Genehmigungen mit Systembenachrichtigungen
- **Memory & Recall** — Speicher-Workspaces pro Agent, embeddings-gestütztes Langzeitgedächtnis, hybride Vektor- + Volltextsuche, Sitzungspersistenz mit Auto-Kompaktierung, sitzungsübergreifender Recall, Cursor-kompatibler Projektkontext, Sicherheitsscan von Kontextdateien
- **Verwaltete Dateien** – Authentifizierte verschachtelte Dateiverwaltung in den Einstellungen, mit einem vom Agent angekündigten Host-Pfad und unabhängigen, standardmäßig schreibgeschützten Mounts für Docker-, Podman- und Apple-Container-Sandboxes
- **Sicheres Agent-Editieren** — Automatische Checkpoints vor integrierten Skill- und Memory-Mutationen, Wiederherstellungs-Tooling, Sitzungs-Branching
- **Erweiterbarkeit** — MCP-Server (stdio + HTTP/SSE), Skill-System, 15 Lifecycle-Hook-Events mit Circuit Breaker, Guard für destruktive Befehle
- **Agent Client Protocol** — steuert externe ACP-Agenten (`codex-acp`, `claude-agent-acp`, Cursor) und stellt Moltis für ACP-Clients über stdio via `moltis acp` bereit
- **Erster Start** — Öffnet das Onboarding im Browser mit vorausgefülltem Setup-Code, stellt zertifikatsfreies `http://localhost` bereit, bietet einmalig an, einer namensbeschränkten lokalen CA für LAN-HTTPS zu vertrauen, und pinnt die Web-UI-URL unterhalb der Terminal-Logs (mit einem `ssh -L`-Hinweis über SSH)
- **Sicherheit** — Verschlüsselungs-Vault im Ruhezustand (XChaCha20-Poly1305 + Argon2id), Passwort- + Passkey- + API-Key-Auth, Sandbox-Isolation, SSRF/CSWSH-Schutz
- **Betrieb** — Cron-Scheduling, dauerhaftes lokales CalDAV, Gmail, Himalaya-E-Mail und wiederverwendbare Slack/Discord/Matrix/Teams-Nachrichten-Datensätze, anbieterspezifische 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-Schlüssel, host-gepinnte Remote-Ziele, Live-Tool-Inventar in den Einstellungen und CLI/Web-Remote-Exec-Doctor-Flows
## Funktionsweise
Moltis ist ein **local-first persistenter Agent-Server** — eine einzelne Rust-Binary, die
zwischen dir und mehreren LLM-Providern sitzt, dauerhaften Sitzungszustand hält und
dir über verschiedene Kanäle begegnen kann, ohne deine Daten an einen Cloud-Relay zu übergeben.
```
┌─────────────┐ ┌─────────────┐ ┌─────────────┐
│ 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](https://docs.moltis.org/quickstart.html) für Details zu Gateway-Start, Nachrichtenfluss, Sitzungen und Speicher.
## Erste Schritte
### Bauen & Ausführen
Erfordert [just](https://github.com/casey/just) (Befehlsausführer) und Node.js (für 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
```
Für einen vollständigen Release-Build einschließlich der WASM-Sandbox-Tools:
```bash
just build-release-with-wasm # Builds WASM artifacts + 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-Oberfläche ein, um dein Passwort festzulegen oder einen Passkey zu registrieren.
Optionale Flags: `--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
```
Ö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](https://docs.moltis.org/docker.html)
für Details zu Podman, OrbStack, TLS-Vertrauen und Persistenz.
### Cloud-Bereitstellung
| Anbieter | Bereitstellen |
|----------|--------|
| 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"
```
Alle Cloud-Konfigurationen verwenden `--no-tls`, da der Anbieter die TLS-Terminierung übernimmt.
Weitere Informationen finden Sie in der [Cloud Deploy-Dokumentation](https://docs.moltis.org/cloud-deploy.html).
## Lizenz
MIT