An MCP server gives an agent tools. The model can decide to search, create, update, or traverse records, which is exactly what you want for explicit work such as storing a decision or connecting a task to an artifact.
Automatic memory has a different job. It must run at moments the model does not control:
- recall before the prompt is finalized;
- capture only after a turn completes successfully;
- preserve the last bounded episode before compression;
- rotate or clear state when sessions change;
- flush pending writes during session end and shutdown.
A tool call cannot guarantee those transitions. A native connector can, because it participates directly in the host runtime lifecycle. The new RushDB connectors make that lifecycle plane automatic while leaving MCP available as the knowledge plane.
| Package | Runtime | Role |
|---|
@rushdb/openclaw-memory | OpenClaw | Additive plugin for automatic recall and completed-turn capture |
rushdb-hermes-memory | Hermes Agent | Native MemoryProvider with recall, turn sync, compression, and session hooks |
@rushdb/agent-memory-contract | TypeScript and custom runtimes | Shared AgentMemoryEvent v1 types, identity helpers, scoped client, schema, and fixture |
At a high level, both native connectors follow the same path:
Before inference
host metadata -> authorized scope -> RushDB semantic recall -> untrusted context
After a successful turn
latest user/assistant pair -> local outbox -> idempotent RushDB upsert -> EPISODE
During degraded operation
short timeout -> continue the host turn -> replay pending writes later
This is memory designed around agent execution rather than a generic transcript archive.
The OpenClaw connector supplements the runtime's existing Markdown and SQLite memory. It does not claim an exclusive memory slot or disable local behavior. The plugin searches RushDB before prompt construction and projects the latest successful user/assistant pair to an EPISODE after agent_end.
Install the published package and expose a RushDB project key to the gateway:
openclaw plugins install @rushdb/openclaw-memory
export RUSHDB_API_KEY="your-project-api-key"
Automatic recall and capture are enabled by default. A minimal explicit configuration looks like this:
{
"plugins": {
"entries": {
"rushdb-memory": {
"enabled": true,
"config": {
"profileId": "default",
"autoRecall": true,
"autoCapture": true,
"recallTimeoutMs": 300
}
}
}
}
}Only eligible private or local conversations receive automatic RushDB memory. Sandboxed, shared-group, automation, heartbeat, hook, and subagent contexts fail closed. The plugin also ignores system messages, full transcripts, tool calls, command output, secrets, and local paths during automatic capture.
Completed events first enter a mode-0600 outbox under ~/.openclaw/rushdb-memory/outbox. If RushDB is temporarily unavailable, OpenClaw still replies, its local memory remains active, and the pending event can replay after restart. The OpenClaw connector guide documents the full configuration and verification flow.
OpenClaw currently maps completed turns to EPISODE. Its existing local memory path remains the right owner for explicit “remember this” behavior; use RushDB MCP when the model needs to create intentional graph records.
The Hermes connector implements the runtime's native MemoryProvider interface. It prefetches scoped memory, synchronizes successful primary-agent turns, captures the latest eligible episode before compression, reacts to session switches, and performs bounded flushes at session end and shutdown.
Install the provider into the same Python environment as Hermes:
pip install rushdb-hermes-memory
export RUSHDB_API_KEY="your-project-api-key"
hermes memory setup
Hermes discovers the rushdb provider through its Python entry-point system. Once selected, the provider owns automatic lifecycle recall and persistence without requiring the model to call a database tool.
Hermes also exposes a trusted native memory-write surface. Supported add and replace events become active MEMORY_FACT records, so an explicit preference or rule can be recalled independently from conversational episodes.
The local outbox lives under $HERMES_HOME/rushdb-memory/outbox, preserving profile isolation. Subagents and other non-primary contexts do not write automatic memory. See the Hermes provider guide for lifecycle details and environment options.
The connectors share AgentMemoryEvent v1 instead of inventing an OpenClaw schema and a separate Hermes schema. The contract defines two canonical record types:
| Label | Semantic property | Meaning |
|---|
EPISODE | summary | One bounded completed turn or lifecycle observation |
MEMORY_FACT | text | A curated preference, rule, or fact with active/version state |
Every canonical record carries the same authorization scope:
agentId
profileId
privacyScope
participantScopeHash
sandboxEligible
These fields are structured prefilters, not similarity hints. The connector applies all five before vector ranking. Participant identifiers are salted and hashed instead of being stored as raw platform IDs, and a runtime that cannot derive a trusted scope does not broaden the query.
AgentMemoryEvent v1 also standardizes provenance, visibility, trust classification, timestamps, and deterministic SHA-256 identities. Retries therefore use the same eventId or factId, allowing idempotent upserts instead of duplicate memories. The event contract documentation includes the canonical graph, supersession rules, and trust boundaries.
For custom TypeScript harnesses, the contract package exposes the same primitives directly:
pnpm add @rushdb/agent-memory-contract
Its published JSON Schema and conformance fixture provide a language-neutral boundary for other runtimes.
Memory persistence is a separate committed action from the model response. Neither connector keeps a database transaction open across inference or waits indefinitely for a remote write.
The reliability model has four parts:
- Fail-open recall. A short timeout returns no remote memory instead of failing the host turn.
- Durable enqueue. Completed episodes reach a local outbox before background delivery is acknowledged.
- Idempotent replay. Deterministic IDs make retry and restart replay safe.
- Recent-write fallback. A bounded local cache makes fresh episodes recallable while managed embeddings become visible.
This keeps the conversation responsive while still giving acknowledged memory writes a durable path to RushDB.
Installing a native connector does not make RushDB MCP redundant. The two layers are complementary:
| Layer | Best owner for |
|---|
| Native connector | Pre-inference recall, completed-turn episodes, compression/session handling, retry, shutdown |
| RushDB MCP | Explicit DECISION, TASK, ENTITY, ARTIFACT, and other domain records; graph traversal; administration |
The important rule is to assign each operation one owner. Do not mirror every completed turn through MCP when the native connector already captures it. Use MCP when the write adds intentional structure beyond the episode—for example, turning a conversation outcome into a DECISION connected to a TASK and an ARTIFACT.
For application-controlled runtimes, use the shared contract and a RushDB SDK to build the same lifecycle explicitly. For hosts without native hooks, MCP-only memory remains useful, but recall and persistence are model-directed rather than guaranteed lifecycle operations.
After installing either connector:
- Tell the primary agent a stable project decision in an eligible private session.
- Complete the turn and end or switch the session.
- Start another authorized session with the same profile and participant scope.
- Ask about the decision without instructing the model to call RushDB.
- Confirm that one canonical
EPISODE exists for the deterministic event ID.
- Temporarily make RushDB unavailable and confirm that the conversation still completes.
- Restore connectivity and verify that the outbox replays the pending event.
For Hermes, also test an explicit native memory add and confirm that it creates an active MEMORY_FACT. For OpenClaw, confirm that local Markdown and SQLite memory remain available alongside the RushDB supplement.
The goal is not to upload everything an agent sees. It is to retain the smallest useful, authorized memory unit and make it available at the right lifecycle moment.
OpenClaw and Hermes now reach that goal through their own native interfaces while producing compatible RushDB records. The result is automatic recall where it belongs, durable capture without response-path network waits, explicit boundaries for privacy and trust, and a graph layer ready for more deliberate knowledge operations.
Create a project at app.rushdb.com, install the connector for your runtime, and let the next session start with the context the previous one earned.