agentmemo（agentmemo 搜索）

AgentMemo

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 client@example.com", "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.

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:

Pricing

Links

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