Moltis
A secure persistent personal agent server in Rust. One binary, sandboxed execution, multi-provider LLMs, voice, memory, Telegram, WhatsApp, Discord, Teams, and MCP tools. Secure by design, runs on your hardware.
Last verified:
What is Moltis?
Moltis is a secure persistent personal agent server written in Rust that compiles an entire AI gateway—including web UI, LLM providers, tools, and all assets—into a single self-contained executable. It requires no Node.js runtime, no npm dependencies, and no node_modules to sync, eliminating V8 garbage collector latency spikes. The tool runs as a single binary that starts in milliseconds and provides a local-first AI assistant experience with long-term memory, sandboxed execution, and multi-channel access.
Key features include support for multiple LLM providers (Anthropic, OpenAI, Google Gemini, DeepSeek, Mistral, Groq, xAI, OpenRouter, Ollama, Local LLM, and more), streaming-first responses that appear as tokens arrive, sandboxed command execution in isolated Docker or Apple Container environments, and Model Context Protocol (MCP) server support for extended capabilities. Moltis offers multi-channel access through Web UI, Telegram, Discord, WhatsApp, Slack, Teams, and API with synchronized responses across all channels. Built-in features include long-term memory with embeddings-powered semantic search, cross-session recall, automatic checkpoints, voice I/O, scheduling, browser automation, and a hook system for observing/modifying/blocking actions at any lifecycle point.
Moltis is designed for developers, privacy-conscious users, and anyone wanting a self-hosted AI assistant that runs on their hardware. It targets users who want memory safety through Rust ownership, secure secret handling with zeroed memory on drop, compile-time safety catching misconfigurations via cargo check, and defense-in-depth security including password/passkey authentication, SSRF protection, origin validation, and no unsafe code workspace-wide. The tool is free for both personal and commercial use under the MIT license.
Moltis pricing
Pricing model: Freemium
Moltis is completely free under the MIT license for both personal and commercial use. There are no paid tiers, subscriptions, or premium features. The only costs are the user's own LLM API keys (Anthropic, OpenAI, Gemini, etc.) which must be obtained separately from the respective providers, or users can run free local LLMs via Ollama, LM Studio, or Local LLM provider. Web search requires a Brave API key (free tier available) or Perplexity API key. The tool itself has no licensing fees, no usage limits from Moltis, and no feature restrictions between different user types.
Moltis pros
- Single binary executable with no runtime dependencies
- No Node.js, npm, or node_modules to manage
- No V8 garbage collector causing latency spikes
- Millisecond startup time versus seconds for other solutions
- Memory safety through Rust ownership model
- Secrets zeroed on drop for secure secret handling
- Sandboxed execution in Docker or Apple Container
- Supports 15+ LLM providers including Anthropic, OpenAI, Gemini
- Streaming-first responses show tokens as they arrive
- Long-term memory with embeddings-powered hybrid search
- Cross-session recall searches earlier sessions for snippets
- Multi-channel access: Web UI, Telegram, Discord, WhatsApp, Slack, Teams, API
- Built-in voice I/O without additional plugins
- MCP (Model Context Protocol) server support included
- Automatic checkpoints restore skill and memory mutations without git
- Compile-time safety catches misconfigurations via cargo check
- Hook system allows observing, modifying, or blocking actions at any lifecycle point
- Remote execution targets: local, paired node, or SSH
- Context hardening loads CLAUDE.md, AGENTS.md, .cursorrules with safety scanning
- Password or passkey (WebAuthn) authentication for non-localhost access
- MIT license free for personal and commercial use
- No plugin marketplace to get supply-chain attacked through
- SSRF protection blocks requests to internal networks
- No unsafe code denied workspace-wide
Moltis cons
- Requires API keys for most LLM providers (user must obtain separately)
- Authentication setup required when accessing from non-localhost addresses
- Linux/macOS focused—Windows requires WSL for installation
- Sandboxed execution requires Docker or Apple Container runtime
- Web search requires Brave or Perplexity API key for full functionality
- Telegram/Discord/Slack channels require bot token setup
- Self-hosted—user must manage their own hardware/server
- No mobile app—access only through web UI or third-party channels
- DuckDuckGo fallback for web search may hit CAPTCHA/rate limits
- Homebrew tap required for macOS/Linux package installation
- Configuration via TOML files may be unfamiliar to non-developers
- Local LLM requires sufficient local hardware resources for GGUF models
Frequently asked questions about Moltis
What is Moltis?
Moltis is a secure persistent personal agent server written in Rust that compiles your entire AI gateway—web UI, LLM providers, tools, and all assets—into a single self-contained executable. It requires no Node.js runtime, no npm, and no node_modules. Moltis provides multi-provider LLM routing, long-term memory, sandboxed tool execution, voice I/O, MCP tools, and multi-channel access through web, Telegram, Discord, WhatsApp, Slack, Teams, and API.
How do I install Moltis?
On macOS/Linux, run the one-liner: curl -fsSL https://www.moltis.org/install.sh | sh. Alternatively, install via Homebrew with brew install moltis-org/tap/moltis. After installation, run 'moltis' in your terminal. On first launch, open the URL shown (e.g., http://localhost:13131) in your browser, add your LLM API key, and start chatting.
Do I need Node.js to run Moltis?
No. Moltis is written in Rust and compiles into a single binary with no runtime dependencies. There is no Node.js to babysit, no node_modules to sync, and no V8 garbage collector introducing latency spikes. This is one of Moltis's key advantages over other AI gateway solutions.
What LLM providers does Moltis support?
Moltis supports 15+ providers including Anthropic, OpenAI, Google Gemini, DeepSeek, Mistral, Groq, xAI (Grok), OpenRouter, Ollama, LM Studio, Local LLM (GGUF), Cerebras, MiniMax, Moonshot (Kimi), Venice, Z.AI, OAuth-based OpenAI Codex, and GitHub Copilot. Any OpenAI-compatible endpoint can also be added with a custom- prefix.
Is Moltis secure?
Yes. Moltis applies defense in depth with password or passkey (WebAuthn) authentication for non-localhost access, SSRF protection blocking requests to internal networks, secret handling using secrecy::Secret that zeroes memory on drop, sandboxed execution where commands never run on the host, origin validation preventing Cross-Site WebSocket Hijacking, and no unsafe code denied workspace-wide. Secrets are zeroed on drop rather than 'eventually collected' by garbage collection.
How does Moltis memory work?
Moltis uses long-term memory with embeddings-powered knowledge base and hybrid search. It supports cross-session recall to search earlier sessions for relevant snippets and prior decisions. Memory style can be configured as hybrid, prompt-only, search-only, or off. The system supports automatic checkpoints to restore built-in skill and memory mutations without touching git history, and user profile writes can be explicit-and-auto or explicit-only.
Can I use Moltis without internet access?
Yes, partially. You can run local LLMs via Ollama, LM Studio, or the Local LLM provider (GGUF models) without internet. However, you still need internet initially to download the binary and for API-based providers. Web search requires Brave or Perplexity API keys. Once installed and configured, local LLMs work completely offline on your hardware.
What is the sandbox feature?
Moltis runs commands in isolated containers (Docker or Apple Container) for security. Sandbox configuration supports modes 'off', 'non-main', or 'all', with scope options of 'command', 'session', or 'global'. Workspace mounts can be read-only, read-write, or none. The sandbox includes packages like curl, git, jq, tmux, python3, nodejs, npm, and golang-go. No-network mode is supported, and commands never run directly on the host machine.
How do I set up Telegram or Discord integration?
For Telegram, add [channels.telegram.my-bot] with your bot token and configure dm_policy (allowlist by default) with allowlist of Telegram user IDs or usernames. For Discord, add [channels.discord.my-bot] with your bot token, dm_policy, mention_mode, and allowlist of usernames. Both require creating a bot through the respective platform's developer portal and obtaining a bot token. Channel access is synchronized across all connected channels.
Is there a mobile app for Moltis?
No, Moltis does not have a native mobile app. Access is through the web UI at localhost:13131 (or your configured port/address), or through integrated channels like Telegram, Discord, WhatsApp, Slack, and Teams which have their own mobile apps. The web UI is responsive and can be accessed from mobile browsers when Moltis is exposed via Tailscale or a reverse proxy.