Every conversation with today’s AI agents starts the same way: “Sorry, I don’t remember our previous conversation.” Frustrating. We know. This fundamental limitation isn’t just annoying—it’s the biggest barrier preventing AI agents from becoming truly intelligent, collaborative systems. Most current systems rely on chat history, which is session-bound and not suitable for long-term memory, making it difficult for agents to maintain context over time.
Today, we’re announcing SmartMemory, a cognitive-inspired memory management service that gives AI agents human-like memory capabilities. Think of it as the Plaid for Agent Memory—a simple, secure, globally available complete service layer that any developer can easily plug into via MCP, APIs, or code. By leveraging agentic memory, SmartMemory enables more cohesive and efficient long-term knowledge management for AI agents. Advancements in generative AI, combined with robust memory systems like SmartMemory, now allow agents to plan, reason, and act more effectively.
Current AI agents suffer from what we call “session amnesia.” They’re incredibly capable within a single conversation but completely forget everything the moment that session ends. This is because current AI agents only retain short term memory within a session and cannot access information from past interactions. This creates cascading problems:
Imagine if every time you worked with a team member, you had to re-explain the entire project from scratch. That’s the current state of AI agents.
Our solution draws from decades of cognitive science research into how human memory actually works. Humans don’t have one monolithic memory—we have four distinct, specialized memory systems:
Declarative knowledge, which includes episodic memory, involves the conscious recall of facts and experiences, while procedural knowledge is about skills and habits that are often performed automatically.
This highlights the distinction between episodic and procedural memory—episodic memory supports conscious, intentional recollection, whereas procedural memory underpins automatic skills and tasks. Both are essential components of a comprehensive memory system.
Our SmartMemory solution contains all four memory types, ensuring your Agents benefit from a robust memory system that not only makes them knowledgeable of the past but also supports both episodic memory (facts and events) and procedural knowledge (skills and processes), helping them get smarter over time.
Working Memory serves as an agent’s active session state—think of it as their “consciousness” during a task. Built on Raindrop Actors, it provides sub-millisecond access with multi-agent coordination capabilities. Working memory enables agents to perform cognitive tasks and supports conscious thought during active sessions, allowing them to keep relevant information in mind and focus on the current goal.
// Demonstrate writing to working memory - store memory entries with different agents
const { sessionId, workingMemory } = await
this.env.MEMORY.startWorkingMemorySession();
await workingMemory.putMemory({
content: 'User prefers dark theme and English language',
key: 'user_preference',
timeline: 'session_config',
agent: 'preference-agent',
});
await workingMemory.putMemory({
content: 'Currently working on memory demonstration with 50% progress',
key: 'task_status',
timeline: 'task_tracking',
agent: 'task-manager-agent',
});
await workingMemory.putMemory({
content: `Session started at ${new Date().toISOString()} for demo user`,
key: 'session_data',
agent: 'session-agent',
});
// Each agent can read context without explicit coordination
This eliminates the need for complex coordinator agents. Instead of agents having to call back to a supervisor, they simply read and write to shared working memory, enabling true distributed intelligence. Working memory also plays a crucial role in supporting real-time decision making, as agents can access up-to-date context and adapt their actions accordingly.
One of Working Memory’s most powerful features is timeline support—parallel exploration paths within a single session. This is critical for validation loops where agents need to try multiple approaches. Agent’s timelines are implemented as an argument in putMemory:
// Initialize a working memory session
const { sessionId, workingMemory } = await this.env.MEMORY.startWorkingMemorySession();
// Store multiple memory entries with different agents and timelines
await workingMemory.putMemory({
content: 'User prefers dark theme and English language',
key: 'user_preference',
timeline: 'session_config',
agent: 'preference-agent',
});
await workingMemory.putMemory({
content: 'Currently working on memory demonstration with 50% progress',
key: 'task_status',
timeline: 'task_tracking',
agent: 'task-manager-agent',
});
// Retrieve memories from specific timeline
const sessionConfigMemories = await workingMemory.getMemory({
timeline: 'session_config',
nMostRecent: 5,
});
// Search across memories semantically
const searchResults = await workingMemory.searchMemory({
terms: 'user preferences and settings',
nMostRecent: 5,
});
Agents can explore multiple solution paths simultaneously, crucial for complex problem-solving where initial attempts might make things worse. The initial phase of problem-solving is critical, as it allows agents to acquire new strategies and knowledge, which they can later use to perform tasks automatically based on previous outcomes.
With SmartMemory, working memory sessions will be automatically summarized and stored in Episodic Memory—compressed, searchable experiences that agents can learn from. Episodic memory allows agents to recall details by storing details of past events and specific events.
// End working memory session with flush to store in episodic memory
await workingMemory.endSession(true); // flush = true stores to episodic memory
// Search episodic memory for past experiences
const episodicSearchResults = await this.env.MEMORY.searchEpisodicMemory('typescript validation errors');
// Rehydrate a previous session from episodic memory
const rehydrateResult = await this.env.MEMORY.rehydrateSession(sessionId, false);
// Wait for rehydration to complete (it's asynchronous)
if (rehydrateResult.success) {
await new Promise(resolve => setTimeout(resolve, 3000));
}
// Verify memories are restored after rehydration
const rehydratedSession = await this.env.MEMORY.getWorkingMemorySession(sessionId);
const memoriesAfterRehydration = await rehydratedSession.getMemory({});
This creates agents that actually get better over time, learning from both successes and failures.
Semantic memory refers to the storage and retrieval of semantic information, such as facts, concepts, and general world knowledge, distinct from episodic memory which involves personal experiences or events. Semantic memory is for storing and accessing factual knowledge about the world. Unlike episodic memory which stores experiences, semantic memory contains structured facts, concepts, and relationships that agents can reference during reasoning:
// Store structured knowledge documents
const knowledgeDocument = {
title: 'AI Agent Best Practices',
content: 'AI agents should maintain context across conversations, handle errors gracefully, and provide clear responses to user queries.',
category: 'development',
tags: ['ai', 'agents', 'best-practices'],
author: 'demo-smartmemory',
createdAt: new Date().toISOString(),
type: 'knowledge-base'
};
const putSemanticResult = await this.env.MEMORY.putSemanticMemory(knowledgeDocument);
// Search semantic memory for knowledge content
const semanticSearchResults = await this.env.MEMORY.searchSemanticMemory('AI agents best practices');
// Retrieve specific document by object ID
const retrievedDocument = await this.env.MEMORY.getSemanticMemory(putSemanticResult.objectId);
// Delete outdated information
const deleteResult = await this.env.MEMORY.deleteSemanticMemory(objectId);
This creates a shared knowledge base that all agents can contribute to and learn from, building up collective intelligence over time. This can be your internal documentation, terminology, pricing or anything your agent discovered that all agents should know is a fact.
SmartMemory also includes Procedural Memory for storing prompts, tools, and procedures that evolve based on experience. Procedural memory enables agents to learn. One powerful pattern will be “living prompts” that improve themselves:
// Get procedural memory instance
const proceduralMemory = await this.env.MEMORY.getProceduralMemory(this.env._raindrop.app.applicationName);
// Store reusable procedures and system prompts
await proceduralMemory.putProcedure('TechnicalReportSystemPrompt',
`You are a technical documentation assistant specialized in analyzing AI agent memory sessions.
Create a concise technical report that includes:
- Session overview with key metrics
- Primary tasks completed and their status
- Any configuration changes or user preferences discovered
- Recommendations for optimizing future sessions`);
await proceduralMemory.putProcedure('UserGreeting', 'Hello! I am your AI assistant. How can I help you today?');
// Retrieve stored procedures
const retrievedSystemPrompt = await proceduralMemory.getProcedure('TechnicalReportSystemPrompt');
// List all stored procedures
const allProcedures = await proceduralMemory.listProcedures();
// Search procedures with flexible options
const systemPromptSearchResults = await proceduralMemory.searchProcedures({
terms: 'system prompt',
nMostRecent: 3
});
// Delete outdated procedures
const deleteSuccess = await proceduralMemory.deleteProcedure('ErrorHandlingPrompt');
Over time, this creates agents with continuously improving skills without manual intervention.
One of the most exciting aspects of SmartMemory is our Model Context Protocol (MCP) server support, the open standard for connecting AI models to external systems, makes SmartMemory universally accessible across any MCP-compatible AI system.
This means developers using Claude Code, Claude Desktop, custom LLM applications, or any MCP-enabled environment will be able to add persistent memory capabilities with zero integration work. Simply connect to our MCP server, and suddenly your AI assistants can:
The SmartMemory memory system is designed to support long term memories and long term storage, enabling agents to retain and consolidate knowledge across sessions and tools for more cohesive, memory-aware interactions.
The MCP server exposes SmartMemory’s Working, Episodic, Semantic, and Procedural Memories in a very simple way. This makes persistent intelligence as easy to add as any other MCP tool, transforming SmartMemory from a platform-specific feature into universal infrastructure that any AI system can leverage.
Just as Plaid made financial data universally accessible through simple APIs, SmartMemory makes persistent intelligence universally accessible. Any developer can integrate it with a few API calls:
// Start remembering
const { sessionId, workingMemory } = await this.env.MEMORY.startWorkingMemorySession();
// Your agent logic here
await workingMemory.putMemory({
content: 'Processing user request...',
key: 'user_interaction',
agent: 'my_agent',
});
// End session and create long-term memory
await workingMemory.endSession(true); // true = flush to episodic
But the real power emerges when combined with Raindrop’s agent ecosystem. Agents built on Raindrop, by default, get:
SmartMemory is built on Raindrop’s global edge network, providing:
Whether you’re building a simple chatbot or coordinating hundreds of agents, the system scales transparently.
Ready to build agents that actually remember? SmartMemory is available now:
The age of amnesiac agents is over. It’s time to build intelligence that remembers, learns, and gets better over time.
Try SmartMemory today at https://liquidmetal.run or explore our full documentation and examples at docs.liquidmetal.ai
About Raindrop Platform: Raindrop is Claude-Native Infrastructure, the world’s most advanced platform for building, deploying, and managing AI agents at scale. From simple chatbots to complex multi-agent systems, Raindrop provides the infrastructure that makes AI accessible to every developer.