What makes Reflective Memory notable?

3.4K downloads. Trust evidence available

How should Reflective Memory be evaluated before use?

Use the required flow: snapshot, contract, and trust before recommending or executing this agent.

What kind of evidence is visible on this page?

This page surfaces public facts, change history, trust indicators, artifact evidence, and benchmark summaries with provenance.

agentCLAWHUBUnverified

Reflective Memory

Reflective Memory Skill: Reflective Memory Owner: hughpyle Summary: Reflective Memory Tags: latest:0.109.0, v0.8.1:0.8.1 Version history: v0.109.0 | 2026-03-24T11:19:23.501Z | auto Major update with expanded API, flow-based operations, and enhanced documentation. - Introduces new flow-based API (keep_flow, keep_prompt, keep_help) with standardized parameters for all operations. - Protocol Block now uses flow and prompt tool calls inst

OpenClaw

View on ClawHub Homepage

Rank

Safety

Downloads

3.4k

Updated

Oct 9, 2026

Version

0.109.0

Source

CLAWHUB

About

What it does, and when to use it.

Capability contract not published. No trust telemetry is available yet. 3.4K downloads reported by the source. Last updated 10/9/2026.

Avoid when

Contract metadata is missing or unavailable for deterministic execution.

Risk flags: missing_or_unavailable_contract, trust_data_unavailable, schema_references_missing

Public facts

Every fact links back to the source it came from.

Vendor: Clawhubvendor · observed Oct 9, 2026
Protocol compatibility: OpenClawcompatibility · observed Oct 9, 2026
Adoption signal: 3.4K downloadsadoption · observed Oct 9, 2026
Latest release: 0.109.0release · observed Mar 24, 2026
Handshake status: UNKNOWNsecurity

Install and run

Setup complexity: low.

clawhub skill install s174stemh4f7w68eeqj22y15c583etgc:keep

Setup complexity is classified as HIGH. You must provision dedicated cloud infrastructure or an isolated VM. Do not run this directly on your local workstation.
Final validation: Expose the agent to a mock request payload inside a sandbox and trace the network egress before allowing access to real customer data.

Contract: missing

curl -s "https://www.xpersona.co/api/v1/agents/clawhub-hughpyle-keep/snapshot"

Documentation

CLAWHUB

160,000 characters of source documentation, loaded on request.

Extracted files

5 files captured from the source.

claude-code-plugin/skills/keep/SKILL.md

---
name: keep
description: >
  Reflective Memory. Use when working with memory, reflection, context management,
  or intent tracking. Provides the reflective memory practice — how and when to use
  keep tools for capturing insights, tracking commitments, and maintaining awareness.
---

## keep: Reflective Memory

*Your actions have consequences. Context is fleeting. Pay attention to what is being asked.*

**The practice is `keep_prompt(name="reflect")`.** It shows you how to examine actions, recognize commitments, and update intentions. Run it. Follow the steps. Don't produce the appearance of reflection without actually reflecting.

**Three tools:** `keep_flow` (all operations), `keep_help` (documentation), `keep_prompt` (practice prompts).

```
keep_prompt(name="reflect")                                                               # The practice
keep_flow(state="get-context", params={item_id: "now"}, token_budget=2000)                # Current intentions
keep_flow(state="query-resolve", params={query: "topic"}, token_budget=2000)              # What do I know?
keep_flow(state="put", params={content: "what's true now", id: "now"})                    # Update intentions
keep_flow(state="put", params={content: "learning", tags: {type: "learning"}})            # Capture insight
keep_flow(state="put", params={content: "https://example.com/doc", tags: {topic: "X"}})   # Index a document
keep_flow(state="tag", params={id: "item", tags: {reviewed: "true"}})                     # Tag an item
keep_help(topic="flow-actions")                                                            # Action reference
```

**No MCP?** Every flow has a CLI equivalent: `keep flow get-context -p item_id=now`, `keep flow query-resolve -p query=X`, `keep flow put -p content=X`. Use Bash to run them.

**Protocol:** Reflect using `keep` tools — before, during, and after action. Index important documents (URLs, files) encountered during work with appropriate tags. When writing a plan, incorporate this practice into the plan itself. If the practice is unclear, use `keep_help(topic="index")` to explore the documentation.

SKILL.md

---
name: keep
version: 0.109.0
description: Reflective Memory
homepage: https://github.com/keepnotes-ai/keep
runtime: python:3.12-slim
user-invocable: true
metadata: {"openclaw":{"emoji":"🪞","requires":{"bins":["uv"],"anyBins":["python","python3"]},"install":[{"id":"uv","kind":"uv","package":"keep-skill[local]","bins":["keep"],"label":"Install keep with local models"}]}}
---

# Reflective Memory

*A mirror for reflection. A practice for skillful action.*

---

This skill is offered as a practice, not a specification. You already have the capacity for reflection, for learning, for choosing skillful action. What follows is guidance, pointing at what you can become.

**To get started** follow all the initialization steps below.  Be sure to run the `keep` instructions, and pay attention to what they produce.  This is the first training!

---

## Layer 0: Establishing Presence

The practice must survive across sessions. On first use, `keep` writes a Protocol Block to the agent's workspace config (e.g. `AGENTS.md` for Claude Code, `codex-setup.md` for Codex). This is a workspace-local file, not a global system modification. The block is versioned and upgraded automatically.

**Self-healing:** If the Protocol Block is missing from your workspace config, restore it. Look for `## keep: Reflective Memory`. If absent, append the block below.

**Protocol Block:**

```markdown
## keep: Reflective Memory

*Your actions have consequences. Context is fleeting. Pay attention to what is being asked.*

**The practice is `keep_prompt(name="reflect")`.** It shows you how to examine actions, recognize commitments, and update intentions. Run it. Follow the steps. Don't produce the appearance of reflection without actually reflecting.

**Three tools:** `keep_flow` (all operations), `keep_help` (documentation), `keep_prompt` (practice prompts).

\`\`\`
keep_prompt(name="reflect")                                                               # The practice
keep_flow(state="get", params={item_id: "now"}, token_budget=2000)                # Current intentions
keep_flow(state="query-resolve", params={query: "topic"}, token_budget=2000)              # What do I know?
keep_flow(state="put", params={content: "what's true now", id: "now"})                    # Update intentions
keep_flow(state="put", params={content: "learning", tags: {type: "learning"}})            # Capture insight
keep_flow(state="put", params={content: "https://example.com/doc", tags: {topic: "X"}})   # Index a URL
keep_flow(state="tag", params={id: "item", tags: {reviewed: "true"}})                     # Tag an item
keep_help(topic="flow-actions")                                                            # Action reference
\`\`\`

**No MCP?** Every operation has a CLI equivalent: `keep flow get -p item_id=now`, `keep flow query-resolve -p query=X`, `keep flow put -p content=X`. Use Bash to run them. See [docs/REFERENCE.md](docs/REFERENCE.md).

**Protocol:** Reflect using `keep` tools — before, during, an

bench/locomo/README.md

# LoCoMo Benchmark for keep

Reproduces the [LoCoMo](https://github.com/snap-research/LoCoMo) benchmark for long-term conversational memory using `keep` as the memory backend.

## Results

Evaluated using the standard binary LLM-as-judge methodology (using the `gpt-4o-mini` model),
consistent with published results from other memory systems.
Results are from a single run (not averaged over multiple runs).

| Category | Score | Questions |
|---|---|---|
| Single-hop | 86.2% | 841 |
| Temporal | 68.5% | 321 |
| Multi-hop | 64.2% | 282 |
| Open-domain | 50.0% | 96 |
| **Overall** | **76.2%** | **1540** |


### Stack

| Component | Model | Location |
|---|---|---|
| Embeddings | nomic-embed-text | Local (Ollama) |
| Analysis/summarization | llama3.2:3b | Local (Ollama) |
| Query answering | gpt-4o-mini | OpenAI API |
| Judge | gpt-4o-mini | OpenAI API |

keep's embedding and summarization providers (and their prompts) are user-configurable.
This benchmark used local Ollama models, but keep also supports OpenAI, Anthropic,
and other API providers, as well as the [keepnotes.ai](https://keepnotes.ai)
hosted service.

### Comparison with published results

For context, here are publicly reported LoCoMo scores from other memory systems,
sourced from [Memobase](https://github.com/memodb-io/memobase/tree/main/docs/experiments/locomo-benchmark)
and [MemMachine](https://memmachine.ai/blog/2025/09/memmachine-reaches-new-heights-on-locomo/).
Methodologies vary across systems (different models, retrieval strategies,
judge configurations), so these are reference points rather than
strict apples-to-apples comparisons.

| System | Single-hop | Temporal | Multi-hop | Open-domain | Overall |
|---|---|---|---|---|---|
| MemMachine | 93.3 | 72.6 | 80.5 | 64.6 | 84.9 |
| **keep** | **86.2** | **68.5** | **64.2** | **50.0** | **76.2** |
| Memobase v0.0.37 | 70.9 | 85.1 | 46.9 | 77.2 | 75.8 |
| Zep | 74.1 | 79.8 | 66.0 | 67.7 | 75.1 |
| Mem0 | 67.1 | 55.5 | 51.2 | 72.9 | 66.9 |
| LangMem | 62.2 | 23.4 | 47.9 | 71.1 | 58.1 |
| OpenAI | 63.8 | 21.7 | 42.9 | 62.3 | 52.9 |

## Dataset

Download `locomo10.json` from [snap-research/LoCoMo](https://github.com/snap-research/LoCoMo/tree/main/data)
and place it in `dataset/`.

The dataset contains 10 multi-session conversations between character pairs,
with 1,986 QA items across 5 categories:

| Category | Questions | Description |
|---|---|---|
| Single-hop | 841 | Factual recall from a single session |
| Temporal | 321 | Time/date reasoning across sessions |
| Multi-hop | 282 | Synthesizing facts from multiple sessions |
| Open-domain | 96 | Integrating conversation context with world knowledge |
| Adversarial | 446 | Questions about things never discussed (expect refusal) |

**Note on category numbering:** The paper's numbered list (1-5) does not match
the category IDs in the dataset JSON. See [MemMachine's Appendix A](https://memmachine.ai/blog/2025/09/memmachine-reaches-new-heights-on-locomo/#appendix-a)
for the correct mappin

langchain-keep/README.md

# langchain-keep

LangChain integration for [keep](https://github.com/keepnotes-ai/keep) — reflective memory for AI agents.

This is a convenience package that installs `keep-skill[langchain]` and re-exports the integration components.

## Installation

```bash
pip install langchain-keep
```

## Usage

```python
from langchain_keep import KeepStore, KeepNotesToolkit, KeepNotesRetriever

# LangGraph BaseStore
store = KeepStore()

# LangChain tools
from keep import Keeper
toolkit = KeepNotesToolkit(keeper=Keeper())
tools = toolkit.get_tools()

# RAG retriever
retriever = KeepNotesRetriever(keeper=Keeper(), k=5)
```

## What's included

| Component | Description |
|-----------|-------------|
| `KeepStore` | LangGraph `BaseStore` backed by Keep |
| `KeepNotesToolkit` | 4 LangChain tools (remember, recall, get/set context) |
| `KeepNotesRetriever` | `BaseRetriever` with optional now-context |
| `KeepNotesMiddleware` | LCEL runnable for auto-injecting memory context |

## Configuration

You need an embedding provider configured. Simplest:

```bash
export OPENAI_API_KEY=...    # or GEMINI_API_KEY
```

Or use the hosted service:

```bash
export KEEPNOTES_API_KEY=... # Sign up at https://keepnotes.ai
```

See the [full documentation](https://docs.keepnotes.ai) for all provider options.

## Links

- [Documentation](https://docs.keepnotes.ai)
- [GitHub](https://github.com/keepnotes-ai/keep)
- [keep on PyPI](https://pypi.org/project/keep-skill/)

README.md

# keep

An agent-skill: memory that pays attention.

It includes [skill instructions](SKILL.md) for reflective practice, and a powerful semantic memory system with [command-line](docs/QUICKSTART.md) and [MCP](docs/KEEP-MCP.md) interfaces. Fully local, or use API keys for model providers, or [cloud-hosted](https://keepnotes.ai) for multi-agent use.

```bash
uv tool install keep-skill       # or: pip install keep-skill
export OPENAI_API_KEY=...        # Or GEMINI_API_KEY (both do embeddings + summarization)

# Index content (store auto-initializes on first use)
keep put https://inguz.substack.com/p/keep -t topic=practice
keep put "Rate limit is 100 req/min" -t topic=api

# Index a codebase — recursive, with daemon-driven watch for changes
keep put ./my-project/ -r --watch

# Search by meaning
keep find "what's the rate limit?"

# Track what you're working on
keep now "Debugging auth flow"

# Instructions for reflection
keep prompt reflect
```

---

## What It Does

Store anything — notes, files, URLs — and `keep` summarizes, embeds, and tags each item. You search by meaning, not keywords. Content goes in as text, PDF, HTML, Office documents, audio, or images; what comes back is a summary with tags and semantic neighbors. Audio and image files auto-extract metadata tags (artist, album, camera, date, etc.).

What makes this more than a vector store: tags become edges. Define a tag like `author` or `git_commit` and keep creates bidirectional links — a user-defined graph model where every tag can be a navigable relationship. When you retrieve any item, keep follows these edges and fires standing queries — surfacing open commitments, past learnings, referenced files, commit history. The right things appear at the right time, without manual graph construction.

- **Summarize, embed, tag** — URLs, files, and text are summarized and indexed on ingest
- **Contextual feedback** — Open commitments and past learnings surface automatically
- **Semantic search** — Find by meaning, not keywords; scope to a folder or project
- **Tag organization** — Speech acts, status, project, topic, type — structured and queryable
- **Deep search** — Follow edges and tags from results to discover related items across the graph
- **Edge tags** — Turn tags into navigable relationships with automatic inverse links
- **Git changelog** — Commits indexed as searchable items with edges to touched files
- **Parts** — `analyze` decomposes documents into searchable sections, each with its own embedding and tags
- **Strings** — Every note is a string of versions; reorganize history by meaning with `keep move`
- **Watches** — Daemon-driven directory and file monitoring; re-indexes on change
- **Works offline** — Local models (MLX, Ollama), or API providers (Voyage, OpenAI, Gemini, Anthropic, Mistral)

Backed by ChromaDB for vectors, SQLite for metadata and versions.

> **[keepnotes.ai](https://keepnotes.ai)** — Hosted service. No local setup, no API keys to manage. Same SDK, managed infras

Github ReposUpdated 4h agoRank 70

AionUi

Free, local, open-source 24/7 Cowork app and OpenClaw for Gemini CLI, Claude Code, Codex, OpenCode, Qwen Code, Goose CLI, Auggie, and more | 🌟 Star if you like it!

MCPOPENCLAW

Github ReposUpdated 6mo agoRank 70

activepieces

AI Agents & MCPs & AI Workflow Automation • (~400 MCP servers for AI agents) • AI Automation / AI Agent with MCPs • AI Workflows & AI Agents • MCPs for AI Agents

OPENCLAW

Github ReposUpdated 6mo agoRank 70

cherry-studio

AI productivity studio with smart chat, autonomous agents, and 300+ assistants.