agimem

Give your AI agents a memory that lasts

Stop re-explaining your codebase, your conventions, and yesterday's work to every new chat. Context survives the session, the project, and the tool.

One agent writes a memory into a Capsule and a different agent recalls it later, shown across three scenarios: An incident you only debug once, A convention every agent follows, A quirk of your setup.

01An agent writes

Cursor · Mondaywrote

Index every new user lookup field before shipping. The last unindexed one caused a production rollback.

02The Capsule stores

project-api0/3 keys

• database/indexed-lookups
• style/commit-messages
• ci/pnpm-catalog

03Another agent recalls

Claude · Thursdayrecalled

This change adds a lookup field, so I've included the index — per the earlier rollback.

Why memory

Your agent forgets everything the moment the chat ends

Without memory

Add a settings page.

Sure. Which ORM does this project use, and where should server actions go?

Drizzle, and actions live in lib/. Same as yesterday.

Got it. Do you have a preferred commit message style?

Every new chat starts from zero.

With agimem

Add a settings page.

↳ memory_get("stack/conventions")

Drizzle ORM · server actions in lib/ · conventional commits

Done. Added a Drizzle table and a server action in lib/settings.ts, committed as feat: add settings page.

Every new chat starts from what your agents already know.

How it works

Persistent memory in three steps

1. Step 01

   Create a Capsule

   An isolated key-value store. One per agent, project, or use case.
2. Step 02

   Generate an API key

   Pick read, write, or admin access. Give each client its own key so you can revoke one without touching the rest.
3. Step 03

   Connect your agent

   Paste the setup prompt into your agent, or point any MCP client at the endpoint. Plain REST works too.

mcp-config.json

Rather not edit JSON? The dashboard gives you a setup prompt to paste into your agent instead. Client setup guides

What you get

More than a place to dump strings

Isolated Capsules, scoped keys

Every Capsule is its own key-value store. Each API key is read, write, or admin, and you can revoke any key from the dashboard.

coding-agent

write

agm_7fKq2aWd…

research-notes

admin

agm_Rz4nBt09…

prod-bot

read

agm_Ld8xVc3M…

Audit logging built in

Writes, deletes, tag changes, imports, and exports are logged and timestamped.

SET database/indexed-lookups

DEL style/old-commit-rules

EXPORT coding-agent.json

MCP and REST

Use the open protocol, or call plain HTTP from anything else.

/api/mcp/api/rest

Search, tags, and expiry

Agents can search memories by keyword, group them with tags, and set a TTL on anything that shouldn't outlive the task.

preferencesgitfrontendgotchattl 60m

Read the docs →

See it in action

One Capsule, context carried between agents

A scripted walkthrough: three agents, one week, one Capsule. Watch a memory get written, recalled, and reused.

agimem.dev — Capsule: my-project

4 interactions · 3 agents · 1 week0/4

Watch agents build shared memory across a week

Cursor saves preferences → Claude reads them → Windsurf avoids a known bug

Click to start

Capsule contents

Memories will appear here

Use cases

Built for the way agents actually work

Your conventions, every repo

Structure, naming, and preferred libraries live in memory, so agents start with your rules instead of guessing.

“Always use Drizzle, never Prisma. Server actions live in lib/.”

Drop into any codebase

Architecture notes and environment quirks persist, so a new agent is useful without rediscovering context.

“Monorepo with pnpm workspaces. Auth in Clerk. Deploy on Vercel.”

Preferences that stick

Save tone and formatting rules once and reuse them without repeating the same setup prompt.

“Concise, no emojis, prefer bullets over paragraphs.”

Resume where the job died

Checkpoints and outputs persist between runs, so long automations resume instead of starting over.

“Last row processed: 4,281. Retry queue: empty.”

FAQ

Questions developers ask about MCP memory

What is an MCP memory server?▾

An MCP memory server lets AI agents store and retrieve persistent context through the Model Context Protocol. Instead of resetting each session, agents can remember decisions, conventions, and project state. agimem also offers a REST API for agents and tools that don't support MCP.

Which AI tools can I use with agimem?▾ agimem works with MCP-compatible clients including Claude, Codex, Cursor, Windsurf, and VS Code. For tools without MCP support, use the REST API directly.

Browse integrations

How quickly can I set it up?▾

Create a Capsule, generate an API key, and paste the setup prompt from the dashboard into your agent. If you prefer, add the MCP config to your client by hand instead.

Can multiple agents share memory?▾ Yes. Point multiple agents at the same Capsule so they share context, or give each agent its own Capsule for stricter boundaries. A Capsule can hold up to 3 API keys, each with read, write, or admin access, so you can revoke one client without breaking the others.

How API keys scope access

Is agimem free to get started?▾

Yes. Sign up and create your first Capsule without a credit card. Every account includes 5 Capsules, 200 memories per Capsule, and audit logging.

Can I get my data out?▾

Yes. Export any Capsule from the dashboard as JSON, CSV, or Markdown. JSON exports can be imported back into a Capsule, which also makes them useful as backups.