Memory: Moltis vs OpenClaw

This page provides a detailed comparison of the memory systems in Moltis and OpenClaw. Both projects share the same core architecture for long-term memory, but differ in implementation details, tool surface, and configuration.

Overview

Both systems follow the same fundamental approach: plain Markdown files are the source of truth for agent memory, indexed for semantic search using hybrid vector + keyword retrieval. The agent reads from memory via search tools and writes to memory via file-writing tools (either dedicated or general-purpose).

Feature Comparison

Storage and Indexing

Embedding Providers

Memory Files

Agent Tools

This is where the two systems differ most significantly in approach.

How “Remember X” Works

When a user says “remember that I prefer dark mode”, here is how each system handles it:

Moltis: The agent calls the memory_save tool directly:

{
  "content": "User prefers dark mode.",
  "file": "MEMORY.md",
  "append": true
}

The memory_save tool validates the path, writes the file, and re-indexes it so the content is immediately searchable. The agent does not need shell access or a generic file-writing tool.

OpenClaw: The agent calls the generic write_file tool (which is also used for writing code, configs, and any other file):

{
  "path": "MEMORY.md",
  "content": "User prefers dark mode.",
  "append": true
}

The system prompt instructs the agent which paths are for memory. The tool itself has no special memory awareness – it is a general-purpose file writer. The memory indexer’s file watcher detects the change and re-indexes asynchronously (1.5s debounce).

Key difference: Moltis uses a purpose-built memory_save tool with built-in path validation (only MEMORY.md and memory/*.md are writable) and immediate re-indexing. OpenClaw uses a general-purpose write_file tool that can write anywhere, relying on the system prompt to guide the agent to memory paths and the file watcher to re-index.

Session Memory and Compaction

Pre-Compaction Memory Flush: Detailed Comparison

Both systems run a hidden LLM turn before compaction to persist important context. The implementation differs:

Moltis:

• The gateway detects that compaction is needed
• A run_silent_memory_turn() call creates a temporary agent loop with a write_file tool backed by MemoryWriter
• The MemoryWriter trait is implemented by MemoryManager, which validates paths and re-indexes after writing
• The LLM’s response text is discarded
• Written file paths are returned to the caller for logging

OpenClaw:

• A soft threshold (default 4000 tokens below compaction trigger) activates the flush
• The flush executes as a regular turn with NO_REPLY prefix to suppress user-facing output
• The agent writes memory files via the same write_file tool used during normal conversation
• Flush state is tracked in sessions.json (memoryFlushAt, memoryFlushCompactionCount) to run once per compaction cycle
• Skipped for read-only workspaces

Write Path Security

Search Features

Configuration

CLI Commands

Architecture

What Moltis Has That OpenClaw Does Not

• Dedicated memory_save tool with path validation and immediate re-indexing, reducing reliance on the system prompt for write guidance
• Ollama embedding support as a provider option
• Custom OpenAI-compatible embedding endpoints
• Circuit breaker with automatic fallback chain for embedding providers
• Web UI for memory configuration (Settings > Memory page)
• Pure Rust implementation with zero external runtime dependencies

What OpenClaw Has That Moltis Does Not (Yet)

• Manual /compact command with user-specified instructions
• CLI memory commands (status, index, search) for debugging
• Session pruning (cache-TTL based trimming of old tool results)
• Gemini and Voyage embedding providers
• Per-agent memory isolation for multi-agent setups
• Automatic re-indexing on embedding provider/model change (fingerprint detection)
• Memory plugin slot allowing third-party memory implementations
• Flush-once-per-compaction tracking to avoid redundant silent turns
• Configurable flush threshold (soft threshold tokens before compaction)

Summary

The two systems are architecturally equivalent – both use Markdown files, hybrid search, and pre-compaction memory flushes. The main differences are:

1. Tool approach: Moltis provides a purpose-built memory_save tool with security validation; OpenClaw uses a general-purpose write_file tool guided by the system prompt.

2. Write safety: Moltis validates write paths at the tool level (allowlist

   • traversal checks); OpenClaw relies on workspace-level access control.

3. Implementation: Moltis is pure Rust with a MemoryWriter trait abstraction; OpenClaw is TypeScript with direct file I/O through a plugin system.

4. Maturity: OpenClaw has more CLI tooling and configuration knobs for advanced memory management; Moltis has a simpler, more opinionated setup with a web UI.