Moltis Documentation

Moltis is a secure, local-first, persistent agent server written in Rust. It acts as a single binary interface between a user and multiple LLM providers, providing a unified agent that can be accessed via various channels (Web UI, API, Telegram, Discord, WhatsApp, Teams, and voice).

Key capabilities include:

• Durable Sessions: Long-term memory with hybrid vector and full-text search, session recall, and branching.
• Tool Use: Support for MCP (Model Context Protocol), browser automation, and scheduling.
• Security: Sandboxed execution, encrypted vaults for secrets (passwords, passkeys, tokens), and filesystem isolation.
• Connectivity: A gateway server architecture that connects multiple frontends to a central agent loop, tools, and providers.

Moltis supports generic webhooks as a first-class feature for machine event ingress. Unlike channels (which are human-facing messaging surfaces), webhooks allow you to create named inbound HTTP endpoints that trigger AI agents in response to external events (e.g., GitHub PRs, Stripe payments, or CI/CD pipelines).

Each webhook acts as a public endpoint with a high-entropy identifier and is composed of:

• A source profile (defines authentication, event parsing, and response actions).
• A verification policy.
• An event filter.
• A delivery log.
• An execution target (an existing agent_id plus optional local overrides).

Webhooks are managed exclusively in Settings → Webhooks in the web UI.

Unsloth is an open-source framework for LLM fine-tuning and reinforcement learning (RL). It is designed to train, run, evaluate, and save models like Llama, DeepSeek, Qwen, Mistral, and Gemma 2x faster with 70% less VRAM.

Key Capabilities:

• Training Modes: Supports full-finetuning, pretraining, 4-bit, 16-bit, and 8-bit training.
• Model Support: Supports vision models, text-to-speech (TTS), BERT, and multimodal models. Any model compatible with transformers works in Unsloth.
• Reinforcement Learning: Highly efficient RL library using 80% less VRAM, supporting GRPO, GSPO, etc.
• Hardware Support: Works on Linux, Windows, Colab, Kaggle, NVIDIA, AMD, and Intel GPUs.
• Accuracy: Provides 0% loss in accuracy using exact methods (no approximations).

The ascii-video skill enables agents to build single-file Python renderers that convert various inputs (audio, video, images, text, or mathematical functions) into colored ASCII character video files (MP4/GIF/PNG).

Key capabilities:

• Output: Actual video files (not terminal escape codes) at 1080p 24fps by default.
• Rendering: Uses a pipeline of grid systems, font rasterization, shader chains, and ffmpeg encoding.
• Hardware: No GPU required; all computations are CPU-based.

The p5.js production pipeline is a workflow for creating interactive and generative visual art in the browser. It supports various modes including generative art, data visualization, interactive experiences, animation, 3D scenes, image processing, and audio-reactive visuals. The pipeline follows a 6-stage process:

1. CONCEPT: Articulate the creative vision (mood, color, motion).
2. DESIGN: Choose mode, canvas size, interaction model, and export format.
3. CODE: Write a single HTML file with inline p5.js using the structure: globals → preload() → setup() → draw() → helpers → classes → event handlers.
4. PREVIEW: Open in browser to verify visual quality and performance.
5. EXPORT: Capture output using saveCanvas(), saveGif(), saveFrames(), or Puppeteer.
6. VERIFY: Ensure the output matches the concept and is visually striking.

Moltis uses a unified authentication gate via the auth_gate middleware. All HTTP requests pass through this middleware, which calls check_auth() to determine access. This single source of truth ensures consistent authentication logic across all routes.

Authentication Flow:

1. Public paths (e.g., /health, /assets/*, /api/auth/*) are passed through.
2. If no credential store exists, requests pass through.
3. Otherwise, check_auth() is called:
   • Allowed: AuthIdentity is inserted into the request.
   • SetupRequired: Returns 401 (API/WS) or redirects to /onboarding (pages).
   • Unauthorized: Returns 401 (API/WS) or serves the SPA login page (pages).

WebSocket connections use check_auth() for the initial HTTP upgrade handshake. Post-upgrade, WebSockets support param-based authentication for clients unable to set HTTP headers.

Reinforcement Learning (RL) is a training method where an agent learns to make decisions by interacting with an environment and receiving feedback via rewards or penalties.

Key components include:

• Action: The output generated by the model (e.g., a sentence).
• Reward: A signal indicating the quality of the action (e.g., did the response follow instructions?).
• Environment: The task or scenario the model is performing (e.g., answering a user question).
• Reward Function: The logic used to assign rewards to specific outcomes (e.g., a function that rewards the answer '4' when asked 'What is 2 + 2?').

Unsloth provides efficient Reinforcement Learning (RL) capabilities to transform standard models into reasoning models.

Key capabilities include:

• Reasoning Model Transformation: With 15GB VRAM, you can transform models up to 17B parameters (e.g., Llama 3.1 8B, Phi-4 14B, Mistral 7B, or Qwen2.5 7B) into reasoning models.
• Vision/Multimodal Support: Unsloth supports RL for Vision/multimodal (VLM) models.
• Low VRAM Requirements: A minimum of 5GB VRAM is sufficient to train reasoning models for any model with 1.5B parameters or less.

Important Note: RL is most effective when starting from an already instruction-finetuned model. If the probability of a correct response is always 0, RL will not work because the model cannot find a signal to learn from.

Moltis is designed with a defense-in-depth security model to protect agents that have real permissions (code, files, credentials, and networks). Key security components include:

• Safer Foundation: Built in Rust for memory safety and a smaller runtime surface.
• Defense in Depth: Supports passkeys and passwords in the Web UI, sandboxed tool execution, and an encrypted vault with network protections.
• Safer Access: Designed for local-first deployment and supports Tailscale for private access paths to keep unauthorized users out.

Unsloth Dynamic 2.0 is a quantization method that allows running and fine-tuning quantized LLMs while preserving high accuracy.

Key features include:

• Intelligent Layer Selection: Dynamically adjusts quantization types for every layer based on the specific model architecture.
• Broad Compatibility: Works on all models, including both MoE (Mixture of Experts) and non-MoE architectures.
• Custom-Tailored Schemes: Each model (e.g., Gemma 3 vs. Llama 4) uses a unique quantization scheme optimized for its structure.
• Expanded Formats: Supports Q4_NL, Q5.1, Q5.0, Q4.1, and Q4.0 formats to maximize efficiency on Apple Silicon and ARM devices.
• Inference Engine Support: The resulting GGUF files can be used with llama.cpp, Ollama, Open WebUI, and other engines.