Agentmemo

Give your AI agent persistent memory and human-in-the-loop approval — across sessions, across models. AgentMemo is a cloud API + MCP server that lets agents...

Security Scan

The skill's requirements and instructions are coherent with its stated purpose (a cloud memory + approval service) — it asks for an AgentMemo API key and sends memory data to api.agentmemo.net, which matches the description; main risks are privacy and trusting the remote service, not technical incoherence.

Purpose & Capability

The skill's name/description (persistent memory + human approval) aligns with its requirements: it declares env.AGENTMEMO_API_KEY and network access to api.agentmemo.net and documents REST/SDK/MCP usage. There are no unrelated credentials or unrelated binaries requested.

Instruction Scope

SKILL.md explicitly instructs the agent to send memory content and approval requests to api.agentmemo.net (over HTTPS) and to use the AGENTMEMO_API_KEY. It does not instruct reading unrelated files or other credentials. Note: because the skill's primary function is remote storage, all memory content will be transmitted to a third-party service — this is expected but important to surface to users.

Install Mechanism

Install is optional and uses an npm package (agentmemo-mcp) which will create a binary. Using npm is a standard approach for an MCP helper; this is a moderate-risk install vector (registry package) but not unusual for the stated purpose. Recommend auditing the npm package source before installing.

Credentials

Only one credential (AGENTMEMO_API_KEY) is required/declared and is appropriate for a cloud API. Small inconsistency: top-level registry metadata listed 'Required env vars: none' while the skill's metadata/config requires env.AGENTMEMO_API_KEY — functionally the API key is required and proportionate.

Persistence & Privilege

always:false (no forced presence). The skill does not request system-wide config changes or other skills' credentials. The agent may invoke the skill autonomously (default) — expected for skills — but this combined with cloud storage means agents could autonomously send data to the remote service, which is the intended behavior.

Assessment

This skill appears to do what it says: it sends whatever you tell it to remember to AgentMemo's cloud and requires an API key. Before installing: (1) confirm you trust https://agentmemo.net and read its privacy policy (understand retention and deletion controls); (2) create a dedicated API key/account and avoid storing highly sensitive PII or credentials in memories; (3) if you plan to install the optional npm binary, review the package (agentmemo-mcp) source and publisher on npm/GitHub before running it; (4) note the minor metadata inconsistency (registry shows no required env vars while SKILL.md requires AGENTMEMO_API_KEY) — expect the API key is required; (5) consider a local-only alternative if you cannot accept cloud storage. If you want, I can (a) check the npm package existence and maintainer info, or (b) summarize the privacy policy for specific retention/processing details.

Persistent memory and human approval for any AI agent — one API, any model, MCP-native.

⚠️ What This Skill Does

This skill connects your agent to the AgentMemo cloud API (api.agentmemo.net) to store and retrieve memories and request human approvals. Your agent's memory content is sent to and stored on AgentMemo's servers.

• Requires: A free API key from agentmemo.net — set as AGENTMEMO_API_KEY in your OpenClaw environment
• Data: Memory content you store is sent to api.agentmemo.net over HTTPS. You own your data and can delete it at any time.
• Optional: The agentmemo-mcp npm package is only needed for MCP client setups (Claude Desktop, Cursor, etc.) — not required for REST/SDK use
• No data sharing: AgentMemo does not share your data with third parties. See privacy policy.

If you prefer fully local memory, this skill is not for you. If you're comfortable with a cloud API (like you'd use for any other SaaS tool), read on.

---

AgentMemo solves the two biggest pain points of autonomous AI agents:

1. Amnesia — agents forget everything between sessions. No more starting from zero.
2. Dead ends — agents need to pause and ask a human before sensitive actions. Now they can.

Features

• 🧠 Persistent memory — store, search, and retrieve memories across sessions
• ✅ Human approval gateway — agents pause, humans approve/reject, agents resume
• 🔌 MCP-native — one-line setup in Claude, Cursor, Windsurf, OpenClaw, or any MCP client
• 🌐 Works with any model — REST API, store in Claude, recall in GPT, use in local Llama
• 📦 npm SDK — npm install agentmemo for TypeScript/JavaScript projects
• 🆓 Free tier — 10K memories, 100 searches/day, no credit card needed

Quick Start

Get your free API key

Sign up at agentmemo.net → free tier, instant access.

Option 1: MCP (Claude / Cursor / OpenClaw)

Add to your MCP config (claude_desktop_config.json or equivalent):

{
  "mcpServers": {
    "agentmemo": {
      "command": "npx",
      "args": ["agentmemo-mcp"],
      "env": {
        "AGENTMEMO_API_KEY": "your_api_key_here"
      }
    }
  }
}

That's it. Your agent now has remember, recall, forget, request_approval, and check_approval tools.

Option 2: OpenClaw (this skill)

Set your API key in OpenClaw config or workspace env:

AGENTMEMO_API_KEY=am_your_key_here
AGENTMEMO_API_URL=https://api.agentmemo.net

Then reference this skill in your agent instructions — see Usage below.

Option 3: REST API directly

# Store a memory
curl -X POST https://api.agentmemo.net/memories \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"content": "User prefers dark mode and compact layouts", "namespace": "preferences"}'

# Search memories
curl "https://api.agentmemo.net/memories/search?q=user+preferences&namespace=preferences" \
  -H "X-API-Key: YOUR_KEY"

# Request human approval
curl -X POST https://api.agentmemo.net/approve \
  -H "X-API-Key: YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{"action": "Send email to [e-mail]", "context": "Draft is ready for review"}'

Option 4: TypeScript/JavaScript SDK

npm install agentmemo

import AgentMemo from 'agentmemo';

const memo = new AgentMemo({ apiKey: process.env.AGENTMEMO_API_KEY });

// Store a memory
await memo.memories.store({
  content: 'Project deadline is March 31st',
  namespace: 'project-alpha'
});

// Search memories
const results = await memo.memories.search('deadline', { namespace: 'project-alpha' });

// Request human approval
const approval = await memo.approvals.request({
  action: 'Delete 500 old log files',
  context: 'Freeing up 2GB disk space'
});

Usage (as an OpenClaw skill)

When this skill is active, use AgentMemo to:

Store memories

Save important context that should persist across sessions:

Remember: [something worth keeping]
Namespace: [project/user/agent — optional, default is "default"]

Use POST /memories with your AGENTMEMO_API_KEY.

Search memories

Before starting any task, search for relevant prior context:

Recall: [what you're looking for]

Use GET /memories/search?q=QUERY&namespace=NAMESPACE.

Request approval

Before any sensitive or irreversible action, request human approval:

Request approval for: [action description]
Context: [why this needs doing]

Use POST /approve. Poll GET /approve/:id or set a callback_url webhook.

API Reference

Base URL: https://api.agentmemo.net
Auth: X-API-Key: YOUR_KEY header on all requests.

Method	Endpoint	Description
POST	/memories	Store a memory
GET	/memories/search	Semantic search across memories
GET	/memories/:id	Retrieve memory by ID
DELETE	/memories/:id	Delete a memory
GET	/usage	Check usage stats and limits
POST	/approve	Submit action for human approval
GET	/approve/:id	Poll approval status

POST /memories

{
  "content": "string (required)",
  "namespace": "string (optional, default: 'default')",
  "metadata": {}
}

Returns { id, namespace, content, metadata, created_at }.

GET /memories/search

Query params: q (required), namespace (optional), limit (optional, max 50).

Returns { query, namespace, count, results: [{ id, content, score, metadata, created_at }] }.

POST /approve

{
  "action": "string (required) — what the agent wants to do",
  "context": "string (optional) — background/reasoning",
  "callback_url": "string (optional) — webhook for decision notification"
}

Returns { id, status: 'pending', ... }.

GET /approve/:id

Returns { id, status: 'pending'|'approved'|'rejected', decision_at, ... }.

MCP Tools

When using the MCP server (npx agentmemo-mcp), your agent gets these tools:

Tool	Description
remember	Store a memory
recall	Search stored memories
forget	Delete a memory by ID
list_memories	List recent memories in a namespace
request_approval	Submit action for human review
check_approval	Poll approval status

Pricing

Plan	Price	Memories	Searches/day
Free	$0	10,000	100
Starter	$19/mo	250,000	1,000
Pro	$99/mo	2,000,000	10,000
Team	$499/mo	Unlimited	Unlimited

Links

• 🌐 Website: agentmemo.net
• 📦 npm (MCP): npmjs.com/package/agentmemo-mcp
• 📦 npm (SDK): npmjs.com/package/agentmemo
• 🐙 GitHub: github.com/andrewpetecoleman-cloud/agentmemo
• 📧 Support: [e-mail]