Messaging agents that remember every conversation
Because your WhatsApp agent shouldn't greet your mum like a stranger every morning
The Problem
OpenClaw elegantly solves the messaging gateway problem. One open-source layer that bridges WhatsApp, Telegram, Discord, and iMessage to your AI agents. Bindings route specific users and groups to specialized agentsâa family group assistant on WhatsApp, a project manager bot on Discord, a personal assistant on Telegram. The architecture is beautiful.
The memory isn't.
Sessions reset daily. Or on idle timeout. Or when the platform decides it's time. Your agent wakes up blank. The family assistant that knew everyone's dietary restrictions, birthdays, and the ongoing debate about where to go for Easter? Gone. The project bot that tracked three sprints of context? Tabula rasa.
OpenClaw has a "silent memory flush" mechanismâa band-aid that gracefully handles the reset so users don't see an error. But gracefully forgetting is still forgetting.
Here's what makes this particularly painful: messaging is the most intimate channel. People don't text their AI assistant like they're filing a support ticket. They text it like a friend. They share context gradually, across dozens of short messages, over days and weeks. "Remember that restaurant I mentioned last Tuesday?" "How's the thing with the project going?"
The friend has amnesia. Every. Single. Morning.
And it gets worse with multi-agent routing. When OpenClaw routes from a generalist to a specialist agent, the specialist starts cold. All the context the generalist gathered? Not passed along. The user has to repeat themselves to every new agent in the chain.
Your messaging agents are brilliant conversationalists with the memory of a goldfish.
How Stompy Helps
Stompy gives your OpenClaw agents persistent memory that survives every session reset, idle timeout, and platform restart.
Here's how your messaging agents become truly persistent:
- **Session-reset survival**: When the daily reset hits, the agent wakes up and recalls its handover summary from Stompy. The user never notices. Continuity is seamless. - **Per-binding isolation**: Each OpenClaw binding maps to its own Stompy project. Your family WhatsApp assistant has its own memory space, completely isolated from the Discord project bot. No context bleed between relationships. - **Cross-agent context**: When OpenClaw routes from a generalist to a specialist agent, the specialist searches Stompy for everything the generalist learned. No context lost in the handoff. - **Semantic conversation search**: "What did they say about the venue last week?" Stompy finds it by meaning, not keyword. Across days and weeks of conversations. - **Relationship memory that compounds**: Over weeks, your agent learns names, preferences, recurring topics, communication style. Not through explicit configurationâthrough natural conversation, stored and retrieved semantically.
The session resets still happen. OpenClaw's architecture doesn't change. But the amnesia? That's cured.
Your messaging agents remember every conversation. Every preference. Every relationship. The daily reset becomes invisible.
Integration Walkthrough
Add Stompy as MCP server in OpenClaw config
Configure your OpenClaw agent to connect to Stompy via MCP. Add the Stompy server to your agent configuration so every binding has access to persistent memory.
// ~/.openclaw/openclaw.json{"agents": {"family-assistant": {"model": "claude-sonnet-4-20250514","system_prompt": "You are a helpful family group assistant...","mcpServers": {"stompy": {"type": "sse","url": "https://mcp.stompy.ai/sse","headers": {"Authorization": "Bearer {STOMPY_API_KEY}"}}},"bindings": [{ "platform": "whatsapp", "target": "Family Group" },{ "platform": "telegram", "target": "@family_bot" }]}}}
Agent saves conversation context after each interaction
After meaningful exchanges, the agent locks what it learned into Stompy. User preferences, family names, ongoing topicsâall persisted with structured topic names per user or group.
// Agent saves context after a meaningful exchangeawait stompy.lock_context({topic: "user_mum_whatsapp_context",content: `User Profile: Mum (Margaret)- Prefers vegetarian restaurants- Birthday: March 15th- Currently planning Easter gathering- Ongoing: looking for a venue that fits 12 people- Mentioned nephew Jake is now gluten-free- Preferred communication: short direct messages`,priority: "important",tags: "family,whatsapp,preferences"});// Save group-level context separatelyawait stompy.lock_context({topic: "group_family_whatsapp_context",content: `Family Group Context (updated)- Easter planning: shortlist down to 3 venues- Jake's birthday party: April 2nd, theme TBD- Recurring: Sunday dinner coordination- Dietary needs: Margaret (vegetarian), Jake (gluten-free),Dad (no shellfish)`,priority: "important",tags: "family,group,ongoing"});
Agent recalls context on session restart
When the daily session reset hits, the agent's system prompt pulls context from Stompy. The user gets a seamless continuationâno "who are you again?" moments.
// On session start (after daily reset or idle timeout)const userContext = await stompy.recall_context("user_mum_whatsapp_context");const groupContext = await stompy.recall_context("group_family_whatsapp_context");// Search for recent conversation threadsconst recentTopics = await stompy.context_search("Easter venue planning family");// Agent's first message after reset:// "Morning! Just picking up where we left offâhave you// had a chance to check if The Garden Room can do// gluten-free options for Jake?"// NOT: "Hello! I'm your family assistant. How can I help?"
Multi-agent handoff with shared memory
When OpenClaw routes from a generalist agent to a specialist (e.g., a travel-planning agent), the specialist searches Stompy for everything the generalist already learned. Zero context lost.
// Specialist "travel-planner" agent receives handoff// from generalist "family-assistant" agent// Search for what the generalist already knowsconst familyContext = await stompy.context_search("Easter venue planning dietary requirements");// â Finds: venue shortlist, 12 guests, dietary needs,// budget discussed last weekconst userPrefs = await stompy.recall_context("user_mum_whatsapp_context");// â Finds: Margaret prefers vegetarian, short messages// Specialist continues seamlessly:// "I've looked into The Garden Roomâthey confirmed they// can handle vegetarian mains and gluten-free options.// Shall I check availability for the 19th?"// NOT: "Hi! I'm the travel planning assistant.// What are you looking for?"
Relationship memory compounds over weeks
After weeks of conversations, the agent knows the family deeplyânot from configuration files, but from natural interactions stored in Stompy. Delta evaluation prevents redundant storage.
// After 6 weeks of daily conversations, Stompy holds:// Week 1: Basic preferences and names// Week 2: Dietary requirements, communication styles// Week 3: Easter planning begins, venue research// Week 4: Jake's birthday planning overlaps// Week 6: Agent handles both events seamlessly// The agent naturally knows:await stompy.context_search("Margaret preferences");// â vegetarian, prefers The Garden Room, likes window seats,// always orders dessert, birthday March 15thawait stompy.context_search("family events upcoming");// â Easter: April 20th, The Garden Room confirmed (12 ppl)// Jake's birthday: April 2nd, bowling + pizza// Dad's golf tournament: April 12th// Delta evaluation: when saving updated context,// Stompy compares against existing and only stores// what's actually newâno redundant entriesawait stompy.lock_context({topic: "user_mum_whatsapp_context",content: "Updated: Margaret mentioned she's trying vegan options now",tags: "family,whatsapp,preferences"});// â Stompy merges with existing context, doesn't duplicate
What You Get
- Session-reset survival: Memory persists across daily resets and idle timeoutsâusers never notice the restart
- Per-binding isolation: Each user or group gets its own Stompy project, keeping family chat context completely separate from work channels
- Cross-agent context: When routing between generalist and specialist agents, all learned context transfers seamlessly via Stompy
- Semantic conversation search: Find relevant context by meaning across weeks of messaging history, not just keyword matching
- Relationship memory: Names, preferences, ongoing topics, and communication styles compound naturally over weeks of interaction
Ready to give OpenClaw a memory?
Join the waitlist and be the first to know when Stompy is ready. Your OpenClaw projects will never forget again.