Memory Pro System

Enhanced AI memory system — vector store, document-level MSA, knowledge graph, collision engine, executable skills, and closed-loop skill evolution.

Security Scan

The skill's description matches a memory system, but its runtime instructions ask you to pull and install arbitrary code from an external GitHub repo and to read OpenClaw auth files and LLM API keys that were not declared — this mismatch and the implicit ability to generate executable skills/webhooks is concerning.

Purpose & Capability

The skill claims to be a memory/knowledge system (vectors, KG, skill proposer). That purpose would legitimately need an LLM key and local code to run — but the registry metadata declared no required env vars or install steps, while SKILL.md/setup.md explicitly require Python + cloning and pip-installing an external repo and LLM API keys. The metadata and declared requirements are inconsistent with the instructions.

Instruction Scope

setup.md instructs cloning a GitHub repo into ~/.openclaw/workspace and pip installing it, configuring OPENROUTER_API_KEY/XAI_API_KEY or reading OpenClaw auth-profiles.json, and enabling scheduled tasks/Telegram channels. The instructions explicitly reference OpenClaw config files (auth-profiles.json, openclaw.json) and writing daily log files and post-remember hooks — actions that read and modify environment/config outside the skill's declared scope.

Install Mechanism

There is no built-in install spec in the registry; setup.md directs the user to git clone https://github.com/FluffyAIcode/openclaw-memory-pro-system and run pip install -e ., which will execute arbitrary Python package code from that repository. The GitHub repo is not pinned to a commit or release and there are no checksums — downloading and installing unpinned code is a moderate-to-high risk.

Credentials

The skill text expects LLM API keys (OPENROUTER_API_KEY or XAI_API_KEY) and will auto-detect keys in OpenClaw's auth-profiles.json. The registry metadata lists no required env vars or config paths; reading auth-profiles.json would access other OpenClaw credentials and is disproportionate to what the registry declared. The skill also suggests configuring Telegram via openclaw.json, which may expose channel tokens.

Persistence & Privilege

The system clones into the user's OpenClaw workspace (~/.openclaw/workspace), writes daily logs, can run scheduled jobs, and the architecture describes auto-generating draft skills with executable bindings (prompt_template/tool_call/webhook). That capability to create executable skills/webhooks and schedule periodic tasks increases privilege and persistence and could enable execution of new behaviors without close review.

Scan Findings in Context

[scanner:none] unexpected: The regex scanner found no code files to analyze (this is an instruction-only package). That absence is not evidence of safety: setup.md instructs fetching and installing code from an external GitHub repo which the scanner did not fetch or inspect.

What to consider before installing

This skill is not outright malicious, but several red flags mean you should proceed cautiously. Before installing or running it: 1) Review the remote GitHub repository (FluffyAIcode/openclaw-memory-pro-system) — inspect setup.py/pyproject.toml and all source files for unexpected network calls, credential harvesting, or shell execs. 2) Avoid installing directly into your primary environment — run the install in an isolated VM or container. 3) Do NOT point it at your production OpenClaw auth-profiles.json or reuse sensitive API keys; create limited-scope/test LLM keys and separate Telegram/test channels. 4) Prefer a pinned commit or official release with checksums rather than cloning an unpinned repo. 5) Audit and control scheduled tasks and any auto-generated skills/webhooks; disable automatic skill activation until you’ve reviewed what it proposes. 6) If you lack capacity to audit the repo, treat this as untrusted code and avoid installing it.

OpenClaw Memory Pro System

An AI memory assistant that turns fragmented notes and conversations into searchable long-term memory, auto-distills actionable skills via a closed-loop feedback pipeline, and proactively reminds you.

When to Use

Goal	Command
Store a memory	memory-cli remember "Learned X today" --tag thought -i 0.8
Assembled recall (skills + KG + evidence)	memory-cli recall "X"
Deep multi-hop reasoning	memory-cli deep-recall "complex question"
Inspiration collision (7 strategies)	memory-cli collide
Daily briefing	memory-cli briefing
List skills with utility stats	memory-cli skills
KG contradiction detection	memory-cli contradictions
KG blind spot scan	memory-cli blindspots
Thought threads	memory-cli threads
Skill feedback	memory-cli skill-feedback <id> success

When Not to Use

• For ephemeral throwaway messages that don't need persistence.
• For real-time streaming data (this is a batch/on-demand system).

Architecture

Fragments --> [Ingest + Tag] --> Unified Corpus (Memora vectors + MSA documents)
                                        |
                              +---------+-----------+
                              v         v           v
                          [KG Weave] [Distill]  [Collide]
                          structural compression  novelty
                           _gain      _value      (1-5)
                              |         |           |
                              +----+----+-----+-----+
                                   |    v     |
                              [Skill Proposer]     <-- triggered when 2-of-3 scores pass
                                   v
                            [Skill Registry]       <-- utility tracking + feedback loop
                           (draft -> active -> deprecated)
                                   |
                         +---------+-----------+
                         v         v           v
                    [Question-   [Scheduled  [Nebius
                     Driven       Push]       Fine-
                     Recall]                  Tuning]
                         |
             +-----------+-----------+
             v           v           v
         [Skills]   [KG Relations] [Evidence]   <-- three-layer assembled output
             |
             v
        Use -> Feedback -> utility update -> low-utility auto-rewrite

Subsystems

Layer	Module	Role
Corpus	Memora	Primary vector store (nomic-embed-text, JSONL). All content enters here.
	MSA	Document-level storage for long text (>=100 words) or high importance (>=0.85). LLM-powered multi-hop interleave.
Intelligence	Second Brain	KG weaving, distillation, collision (7 strategies with attention focus + recency weighting).
	Skill Proposer	Auto-generates draft skills when 2-of-3 scores meet thresholds.
Skill	Skill Registry	Versioned skills with utility tracking, feedback loop, executable action bindings (prompt_template / tool_call / webhook).
Training	Chronos	Replay buffer, personality profile generation, training data export.

Ingestion Routing

• All content -> Memora (always)
• Long text (>=100 words) OR high importance (>=0.85) -> also MSA
• High importance (>=0.85) -> also Chronos
• Always writes daily log file
• Post-remember hooks: KG extraction, access tracking

Recall

Three-layer assembled response with token budget control (default 4000 tokens):

1. Skills (score 1.0) — active skills matched by vector similarity, with executable prompts
2. KG Relations (score 0.9) — knowledge graph nodes + logical edges
3. Evidence (score 0.0-1.0) — Memora snippets + MSA documents

Collision Engine

7 strategies with attention-aware anchor selection:

• RAG-based: Semantic Bridge, Dormant Revival, Temporal Echo, Chronos Cross-Ref, Digest Bridge
• KG-driven: Contradiction-Based, Blind Spot-Based

Before each round, extracts 3-5 focus keywords from recent memories. Anchor selection biased toward current focus topics with recency weighting.

Requirements

• Python 3.9+
• macOS (Apple Silicon) or Linux
• LLM API key: OpenRouter (preferred) or xAI (fallback)

Setup

See setup.md for installation instructions.

Source

GitHub: FluffyAIcode/openclaw-memory-pro-system