RushDB now has native memory connectors for OpenClaw and Hermes Agent. Both integrations recall relevant history before inference, persist completed turns through a durable local outbox, and keep remote database failures away from the conversation path. They share one provider-neutral event contract, so memory written by different runtimes has the same identity, scope, trust, and retrieval semantics.
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.
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:
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:
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:
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:
Shell
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.
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.
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.