💬
OpenClaw+Stompy

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

1

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" }
]
}
}
}
2

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 exchange
await 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 separately
await 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"
});
3

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 threads
const 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?"
4

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 knows
const familyContext = await stompy.context_search(
"Easter venue planning dietary requirements"
);
// → Finds: venue shortlist, 12 guests, dietary needs,
// budget discussed last week
const 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?"
5

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 15th
await 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 entries
await 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.