Rembr
Durable memory and context infrastructure for AI agents.
Website
·
Docs
·
Portable Memory
·
Agent Debugging
·
Intelligence vs Storage
Rembr is an open-source memory layer for agents that need more than chat history and vector search. It gives agents a place to store what they learn, retrieve the right context later, hand off focused context to other agents, track how facts change over time, reason over relationships, and keep long-running work resumable.
Most agent memory systems answer: "What past text is semantically similar to this prompt?"
Rembr is built for the harder production question: "What should this agent know right now, why does it believe it, what changed, and what context should another agent receive next?"
The hosted Rembr product is built around a simple idea: one memory layer should follow you across Claude, Cursor, Windsurf, local models, and any MCP-compatible tool. The public site frames this as portable memory for agents: tell one tool once, and the rest of your workflow can remember.
Why Agents Need Rembr
LLMs are powerful inside a context window and forgetful outside it. Once a session ends, the next agent usually has to rediscover:
- The architecture it already investigated.
- The user's preferences and decisions.
- Which facts are current and which are stale.
- Why a previous agent chose a particular plan.
- What work is blocked, complete, or ready for handoff.
- Which context should be passed to a sub-agent without flooding it.
That is fine for demos. It breaks down when agents work on real projects over days or weeks.
Rembr turns agent memory into durable infrastructure:
- Memory for facts, decisions, preferences, workflows, insights, and project context.
- Search across semantic, text, phrase, hybrid, and related-memory strategies.
- Contexts for building focused working sets instead of dumping raw search results.
- Snapshots for immutable, versioned handoff packages.
- Temporal tools for asking what was known at a point in time.
- Graph tools for exploring relationships between memories, tasks, decisions, and incidents.
- Contradiction detection for finding stale or conflicting context.
- Causal reasoning for tracing why state changed and what followed.
- RLM/task tooling for resumable agentic work with acceptance criteria, iterations, task state, dependencies, and handoffs.
- Audit and PII tooling for safer production use.
What Makes Rembr Different
Rembr is not just a vector database, and it is not just a chatbot memory store.
It is designed as an agentic context layer: a memory system that agents can actively use to construct, validate, version, and transfer context.
The product pages on rembr.ai describe this distinction as the gap between storage and intelligence. Storage can hold text. Rembr helps agents decide which memories matter, when they mattered, how they connect, and what should be handed to the next agent.
Agent Handoff Is A First-Class Primitive
Agents often need to delegate. Search results are not enough for that. Rembr lets an agent build a focused context, attach the relevant memories, and create an immutable snapshot so a sub-agent receives a stable baseline.
That makes handoff auditable and repeatable:
search -> collect memories -> create context -> snapshot -> hand off to agent
Time Matters
Project facts change. User preferences change. Production systems change. Rembr includes temporal search and memory history so an agent can ask:
- What did we know when this decision was made?
- Which memory superseded this older one?
- What changed between these two snapshots?
- Was this runbook true before the latest deployment?
Memory Is Connected
Useful memories are rarely isolated. A decision affects a task. A task creates an incident. An incident updates a runbook. Rembr includes graph and relationship tools so agents can explore dependencies and missing links.
Long-Running Work Needs State
For serious agent work, "remember this" is not enough. Rembr includes RLM and task tools for work that needs:
- Acceptance criteria.
- Iteration history.
- Stuck detection.
- Plan regeneration.
- Task dependencies.
- Handoff payloads.
- Durable state across compaction or session interruption.
Comparison
