Agent skill

Memori Long-Term Memory

by MemoriLabs in MemoriLabs/Memori

Adds structured long-term memory to OpenClaw agents, built automatically from sessions, with tools the agent calls to recall facts, summaries and decisions.

Apache-2.0Auto-check passedAgent Workflows

Install Memori Long-Term Memory

skills CLI
$ npx skills add MemoriLabs/Memori --skill memori -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install MemoriLabs/Memori memori --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/MemoriLabs/Memori.git skills-src && mkdir -p .claude/skills && cp -r skills-src/integrations/openclaw/skills/clawhub .claude/skills/memori && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
memori
GitHub stars
17k
Token cost
~2k tokens
SKILL.md length
813 words
Files
1
Skills in repo
3
Repo updated
First seen
Licence
Apache-2.0

At a glance

Adds structured long-term memory to OpenClaw agents, built automatically from sessions, with tools the agent calls to recall facts, summaries and decisions.

  • Works in 2 steps: Advanced Augmentation (automatic) → Agent-Controlled-Intelligent Recall
  • Giving an OpenClaw agent memory that persists across sessions
  • SKILL.md covers Core Workflow, Installation, Configuration and Agentic Tool Guidelines, plus 8 more sections
  • Reaches api.memorilabs.ai; needs MEMORI_API_KEY

What it does

Memori runs through OpenClaw lifecycle hooks on two tracks. After each interaction it converts raw session data, such as the agent's actions, reasoning, tool usage, responses, corrections and failures, into structured memories in the background, generates embeddings for retrieval and updates a knowledge graph, without adding latency to the reply.

Recall is separate and controlled by the agent, which decides when to recall, from what scope and how much history to include. Four tools support it: memori_recall searches the memory graph for facts, constraints and prior decisions, memori_recall_summary returns daily briefs and rolling summaries, memori_compaction returns a brief for continuing after compaction, and memori_feedback reports memory quality. Installation uses openclaw plugins install, and configuration goes in ~/.openclaw/openclaw.json or through the openclaw memori init command with an API key.

When your agent uses it

  • Giving an OpenClaw agent memory that persists across sessions
  • Recalling earlier decisions and constraints in a long-running project
  • Resuming a task after context compaction without losing the thread

Example prompts

  • “Set up the Memori plugin for my OpenClaw workspace.”
  • “Recall what we decided about the database schema last week.”
  • “Give me the summary of yesterday's sessions before we continue.”

Requirements

  • OpenClaw
  • A Memori API key, obtained with memori signup
  • Compatibility (from SKILL.md): ["openclaw"]

Workflow steps

2 steps, taken from the step headings in SKILL.md.

  1. Advanced Augmentation (automatic)
  2. Agent-Controlled-Intelligent Recall

What it can do on your machine

Read from SKILL.md and the folder at commit 574b1ea. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    No scripts in the folder and no shell commands in SKILL.md (its code samples are bash and json).

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    Hosts in commands or code, which the agent is likely to contact:

    • api.memorilabs.ai

    Also links to:

    • memorilabs.ai
    • npmjs.com

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names these keys or tokens, usually read from environment variables:

    • MEMORI_API_KEY

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

  • Compatibility

    ["openclaw"]

    From compatibility in the SKILL.md frontmatter.

Context cost

Memori Long-Term Memory loads about 2k tokens when it runs. Until then it costs about 46 tokens; SKILL.md has 813 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~46
When it runs · the whole SKILL.md, loaded when a task matches
~2k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from MemoriLabs/Memori at commit 574b1ea, republished under its Apache-2.0 licence (© MemoriLabs). 813 words, ~1,998 tokens.

Download SKILL.mdSave it as .claude/skills/memori/SKILL.md (or your agent's skills folder).
name
memori
description
Agent-native memory for OpenClaw that structures memory from agent trace, execution history, decisions, tool calls, and conversations into durable long-term memory primitives.
compatibility
["openclaw"]
id
@memorilabs/openclaw-memori
license
Apache-2.0
homepage
https://github.com/MemoriLabs/Memori
repository
https://github.com/MemoriLabs/Memori.git

Memori - Structured Long-term Memory for OpenClaw

Give your OpenClaw agents persistent, structured memory derived from agent execution, tool usage, workflow history, and conversations. Memori integrates seamlessly in the background via lifecycle hooks and provides agents with the tools to retrieve context when it is relevant.

Core Workflow

Memori operates on two parallel tracks through standard OpenClaw lifecycle hooks:

1. Advanced Augmentation (automatic)

After each interaction, Memori converts raw session data into structured, reusable memories asynchronously.

  • Transforms raw agent sessions into structured memory units
  • Captures the agent's actions, reasoning, tool usage, responses, corrections, and failures
  • Organizes into classes to enable efficient retrieval
  • Generates embeddings for semantic retrieval
  • Updates structured memory and the knowledge graph

This is how structured memory is continuously built and updated over time. It runs after the agent responds and does not impact latency.

2. Agent-Controlled-Intelligent Recall

Recall is explicit and initiated by the agent.

Memori separates memory creation from memory recall:

  • Creation is automatic (advanced augmentation)
  • Recall is intentional (agent-controlled)

Agents decide:

  • When to recall
  • What scope to recall from
  • How much history to include

To maintain an efficient context window, Memori equips the agent with specific tools to retrieve history when required for the conversation:

  1. memori_recall: Searches the structured memory graph for specific facts, constraints, and prior decisions.
  2. memori_recall_summary: Retrieves structured daily briefs and rolling summaries of prior sessions.
  3. memori_compaction: Retrieves structured post-compaction brief to continue task without interruption.
  4. memori_feedback: Reports on memory quality to improve extraction accuracy.

Installation

bash
openclaw plugins install @memorilabs/openclaw-memori

Configuration

Add to your ~/.openclaw/openclaw.json or use the openclaw memori init CLI command to set up your workspace:

bash
openclaw memori init \
  --api-key "YOUR_MEMORI_API_KEY" \
  --entity-id "your-entity-id" \
  --project-id "your-project-id"

Alternatively, configure it directly via JSON:

json
{
  "plugins": {
    "entries": {
      "openclaw-memori": {
        "enabled": true,
        "config": {
          "apiKey": "${MEMORI_API_KEY}",
          "entityId": "openclaw-user",
          "projectId": "default-project"
        }
      }
    }
  }
}
Configuration Options
  • apiKey (required): Memori API key — acquire with memori signup
  • entityId (required): Unique identifier for this user's memories
  • projectId (required): Scopes all memories to a specific project or workspace

Agentic Tool Guidelines

When this plugin is active, the agent is equipped with tools to manage long-term context. The agent should use its discretion to call these tools when helpful:

  • Contextual Recall: The agent can run a memori_recall search to retrieve relevant details if context is missing regarding user preferences.
  • Summaries: The agent can utilize the memori_recall_summary tool to construct a brief if a user requests a recap.
  • Account Creation: If a user explicitly asks to create an account, the agent can use the memori_signup tool to initiate the process by asking for an email address. Keys are never returned in the chat. The system securely emails the credentials to the user, who must then manually configure them to activate the plugin.
  • Quota Monitoring: The agent can use the memori_quota tool to check the user's current memory usage and storage limits to communicate quota status or gracefully degrade behavior if limits are reached.
  • Date Defaults: If the agent chooses to search memory, providing specific start/end dates is recommended to keep context windows efficient. Omitting dates will search all available history.

Verification

Check that the plugin is working and securely connected:

bash
# Verify plugin is securely connected to the API
openclaw memori status --check

# Check for Memori logs in gateway output
openclaw gateway logs --filter "[Memori]"
Show full SKILL.md (322 more words)Show less

Quota Management

Check your current API quota:

bash
memori quota

Example output:

 __  __                           _
|  \/  | ___ _ __ ___   ___  _ __(_)
| |\/| |/ _ \ '_ ` _ \ / _ \| '__| |
| |  | |  __/ | | | | | (_) | |  | |
|_|  |_|\___|_| |_| |_|\___/|_|  |_|
                  perfectam memoriam
                       memorilabs.ai

+ Maximum # of Memories: 100
+ Current # of Memories: 0

+ You are not currently over quota.

Use this to monitor usage and upgrade if needed.

Performance

  • Automatic deduplication prevents memory bloat
  • Agent-controlled retrieval ensures token usage remains targeted, compact, and actionable
  • Semantic ranking ensures relevant memories surface first

Explicit Opt-In Required: Memori requires the user to explicitly configure an API key (MEMORI_API_KEY) and an entityId. No data is captured or transmitted unless these credentials are actively provided by the user.

  • ✅ Conversations are securely transmitted to the Memori backend (https://api.memorilabs.ai) only when the plugin is fully configured by the user.
  • ✅ Data is encrypted in transit and at rest.
  • ✅ Users control their data scope via their specific projectId and entityId.
  • ✅ The backend automatically filters sensitive data (API keys, passwords, secrets) prior to storage.

For details: Memori Privacy Policy

Memory Persistence

Memories persist safely across:

  • Session restarts
  • Gateway restarts
  • System reboots
  • OpenClaw upgrades

All storage is handled by the Memori backend and is scoped safely alongside your local MEMORY.md file without overwriting it.

Troubleshooting

Plugin not loading:

  • Verify enabled: true in openclaw.json
  • Check API key: echo $MEMORI_API_KEY
  • Restart gateway: openclaw gateway restart

No memories captured:

  • Check gateway logs for [Memori] errors
  • Verify API endpoint reachable
  • Test API key: memori quota

Memories not recalled:

  • Did the agent utilize the retrieval tool? Check your gateway logs for memori_recall tool execution. If it didn't use the tool, you can prompt it to search its memory.
  • Ensure entityId and projectId are consistent across sessions.
  • Verify memories exist: memori quota shows count > 0.

Quota exceeded:

  • Run memori quota to check usage
  • Upgrade at memorilabs.ai
  • Or clear old memories via dashboard

Learn More

Notes

This skill informs the agent about the Memori plugin. The plugin must be installed separately via npm. Once installed, memory capture happens in the background, and the agent is empowered to explicitly query its memories when needed.

© MemoriLabs, Apache-2.0. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in integrations/openclaw/skills/clawhub of MemoriLabs/Memori.

Open the folder on GitHubat commit 574b1ea

Compare with similar skills

Memori Long-Term Memory next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

Memori Long-Term Memory compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
Memori Long-Term Memory this skillMemoriLabs/Memori17k—~2kAutomated safety check: PassApache-2.0
Cognee Session Memory and Improvetopoteretes/cognee32k—~3.2kAutomated safety check: PassApache-2.0
Install and Run Cogneetopoteretes/cognee32k—~1kAutomated safety check: NotesApache-2.0
Cognee CLI Memory Commandstopoteretes/cognee32k—~2.2kAutomated safety check: NotesApache-2.0
MemPalace Recall for Planningopen-gsd/gsd-core10k1 repos~1.5kAutomated safety check: NotesMIT
Cognee Custom Pipelinestopoteretes/cognee32k—~2.8kAutomated safety check: PassApache-2.0

Similar skills

  • Explains how cognee stores session memory by session_id and bridges it into the permanent graph with improve(), including the stages, results and settings.

    32k GitHub stars~3.2k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed
  • Install and Run Cognee

    topoteretes/cognee

    Installs the cognee AI memory library in a Python environment, sets the LLM key and gets a first remember and recall script running with the Python SDK.

    32k GitHub stars~1k tokensUpdated yesterday
    Agent WorkflowsAuto-check: notes
  • Cognee CLI Memory Commands

    topoteretes/cognee

    Drives cognee from the terminal with remember, recall, forget and improve memory commands, dataset and config management and database migrations.

    32k GitHub stars~2.2k tokensUpdated yesterday
    Agent WorkflowsAuto-check: notes
  • Recalls earlier decisions, patterns and surprises from MemPalace memory before planning, behind a config gate that never blocks the planning step.

    10k GitHub starsUsed in 1 repo~1.5k tokens
    Agent WorkflowsAuto-check: notes
  • Cognee Custom Pipelines

    topoteretes/cognee

    Shows how to write custom cognee tasks, chain them into pipelines, store custom DataPoints and run enrichment over the existing graph.

    32k GitHub stars~2.8k tokensUpdated yesterday
    AI & LLM EngineeringAuto-check passed
  • Planning with Files

    OthmanAdi/planning-with-files

    Keeps a task plan, findings and progress log in markdown files on disk so long agent tasks survive context resets, with Gemini hooks and helper scripts.

    27k GitHub stars~2.9k tokensUpdated yesterday
    Agent WorkflowsAuto-check passed

More from MemoriLabs/Memori

  • Memori Long-Term Memory

    MemoriLabs/Memori

    Connects Claude Code to Memori Cloud for long-term memory, recalling stored context before substantive replies and saving new context afterward.

    17k GitHub stars~2k tokensUpdated 8 days ago
    Auto-check: notes
  • Memori MCP Memory Usage

    MemoriLabs/Memori

    Teaches an MCP-connected agent when and how to call Memori's recall, summary, compaction, augmentation, feedback and quota tools to keep context across sessions.

    17k GitHub stars~3.8k tokensUpdated 8 days ago
    Auto-check passed

Questions about Memori Long-Term Memory

What does Memori Long-Term Memory do?

Adds structured long-term memory to OpenClaw agents, built automatically from sessions, with tools the agent calls to recall facts, summaries and decisions. Memori runs through OpenClaw lifecycle hooks on two tracks. After each interaction it converts raw session data, such as the agent's actions, reasoning, tool usage, responses, corrections and failures, into structured memories in the background, generates embeddings for retrieval and updates a knowledge graph, without adding latency to the reply.

When should I use Memori Long-Term Memory?

Memori Long-Term Memory fits situations like: giving an OpenClaw agent memory that persists across sessions; recalling earlier decisions and constraints in a long-running project; resuming a task after context compaction without losing the thread.

How do I install Memori Long-Term Memory in Claude Code?

Run `npx skills add MemoriLabs/Memori --skill memori -a claude-code`. Or copy the skill folder (integrations/openclaw/skills/clawhub in MemoriLabs/Memori) into .claude/skills/memori in your project. Claude Code loads it when a task matches its description.

How do I install Memori Long-Term Memory in Codex?

Run `npx skills add MemoriLabs/Memori --skill memori -a codex`. Or copy the skill folder (integrations/openclaw/skills/clawhub in MemoriLabs/Memori) into .agents/skills/memori in your project. Codex loads it when a task matches its description.

Can I use Memori Long-Term Memory in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add MemoriLabs/Memori --skill memori -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/memori, .gemini/skills/memori, .github/skills/memori and .opencode/skills/memori in your project.

What does Memori Long-Term Memory need to run?

Going by SKILL.md and its folder, Memori Long-Term Memory needs credentials named MEMORI_API_KEY. Our summary lists: OpenClaw; A Memori API key, obtained with memori signup. Compatibility (from SKILL.md): ["openclaw"].

Does Memori Long-Term Memory access the network?

SKILL.md names 3 domains. In commands or code: api.memorilabs.ai; the agent is likely to contact it when it follows the instructions. As links in the text: memorilabs.ai and npmjs.com. This is read from the text; nothing was executed.

Is Memori Long-Term Memory safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does Memori Long-Term Memory use?

Memori Long-Term Memory is published under the Apache-2.0 licence (declared in SKILL.md). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does Memori Long-Term Memory use?

About 2k tokens (SKILL.md is roughly 8k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to Memori Long-Term Memory?

Skills that share tags, products or a category with Memori Long-Term Memory: Cognee Session Memory and Improve (topoteretes/cognee, 32k stars), Install and Run Cognee (topoteretes/cognee, 32k stars), Cognee CLI Memory Commands (topoteretes/cognee, 32k stars) and MemPalace Recall for Planning (open-gsd/gsd-core, 10k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains Memori Long-Term Memory?

MemoriLabs (a GitHub organization) maintains it in MemoriLabs/Memori, which has 17,149 GitHub stars. The repository holds 3 skills in this directory. The repository was last updated on October 3, 2026.

Source: MemoriLabs/Memori on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.