# I built a persistent memory API for AI agents — and it's free

> Source: <https://dev.to/nadeem_shaikh_5663bb224d1/i-built-a-persistent-memory-api-for-ai-agents-and-its-free-3b16>
> Published: 2026-06-18 09:24:00+00:00

Every AI agent has the same problem.

The moment a session ends, everything is gone. No memory of the

user. No context from last week. No continuity. Every conversation

starts from zero.

I built AgentMemo to fix this.

AgentMemo is a REST API that gives AI agents persistent memory.

Agents can store memories, retrieve them semantically, and forget

them when needed.

The key word is **semantically**. Not keyword search.

Meaning-based search.

Store: *"The customer prefers email over phone and is on the Pro plan."*

Query: *"How should we contact this user?"*

Result: ✅ Returns the memory with score 0.62 — zero keyword overlap,

pure semantic understanding.

Get a free API key instantly — no credit card, no email required:

```
# Get your API key
curl -X POST https://agentmemo.dev/signup \
  -H "Content-Type: application/json" \
  -d '{"name":"my-agent"}'

# Store a memory
curl -X POST https://agentmemo.dev/memory/store \
  -H "Authorization: Bearer YOUR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "user_id": "user_123",
    "agent_id": "support_bot",
    "content": "User prefers dark mode and works in TypeScript",
    "metadata": {"plan": "pro"}
  }'

# Retrieve relevant memories semantically
curl "https://agentmemo.dev/memory/retrieve?user_id=user_123&query=what+does+this+user+prefer" \
  -H "Authorization: Bearer YOUR_KEY"
```

**Semantic search** — memories retrieved by meaning not keywords.

Built on vector embeddings generated automatically on every store.

**Agent-native signup** — agents can self-register via POST /signup

with zero human involvement. No email. No verification. Key returned

instantly in JSON.

**MCP server** — works natively with Claude, Cursor, and any MCP

client. Add it in two lines:

```
{
  "mcpServers": {
    "agentmemo": {
      "url": "https://agentmemo.dev/mcp",
      "transport": "streamable-http",
      "headers": {
        "Authorization": "Bearer YOUR_KEY"
      }
    }
  }
}
```

**auth.md support** — AgentMemo publishes an auth.md file at

agentmemo.dev/auth.md so any auth.md-compatible agent can

discover and self-register automatically.

**TTL support** — set expiry on memories. Weather from yesterday?

Expires in 24 hours. User preferences? Keep forever.

**Namespaces** — organize memories by project, session, or topic.

Isolated memory spaces within one API key.

**Edge deployed** — sub-50ms globally. No cold starts.

No servers to manage.

The most powerful use case — building the context window:

``` js
// Get API key from signup
const key = "am_sk_your_key";

// Before calling Claude/GPT, fetch relevant memories
const res = await fetch(
  `https://agentmemo.dev/memory/retrieve?user_id=${userId}&query=${currentMessage}`,
  { headers: { Authorization: `Bearer ${key}` } }
);
const { memories } = await res.json();

// Inject into system prompt
const systemPrompt = `
You are a helpful assistant.

What you remember about this user:
${memories.map(m => `- ${m.content}`).join('\n')}

Use this context to give personalized responses.
`;

// Now call Claude/GPT with full context
const response = await anthropic.messages.create({
  model: "claude-sonnet-4-6",
  system: systemPrompt,
  messages: [{ role: "user", content: currentMessage }]
});

// Store what happened for next time
await fetch("https://agentmemo.dev/memory/store", {
  method: "POST",
  headers: { 
    Authorization: `Bearer ${key}`,
    "Content-Type": "application/json"
  },
  body: JSON.stringify({
    user_id: userId,
    agent_id: "assistant",
    content: `User asked: ${currentMessage}. Key outcome: ${summary}`
  })
});
```

I believe the next generation of software won't be used by humans —

it will be run by agents.

And every agent needs a memory.

The big AI labs are building memory inside their own walls.

Claude remembers — but only within Anthropic. GPT remembers —

but only within OpenAI.

Nobody was building the memory layer that works across ALL of them.

AgentMemo is that layer.

🔗 **Live:** [https://agentmemo.dev](https://agentmemo.dev)

📖 **Docs:** [https://agentmemo.dev/docs](https://agentmemo.dev/docs)

🔌 **MCP:** [https://agentmemo.dev/mcp.json](https://agentmemo.dev/mcp.json)

🤖 **auth.md:** [https://agentmemo.dev/auth.md](https://agentmemo.dev/auth.md)

Free during beta. No limits. No credit card.

Would love your feedback — especially if you're building

multi-agent systems. What memory features would make your

agents smarter?