Skip to main content
Every other memory system is a smarter store. SenseLab is the only one that treats agent memory like code — with version control, branching, pull requests, and rollbacks.

​
Feature Matrix

​
SenseLab vs Mem0

Mem0 extracts facts from conversations and stores them with ADD/UPDATE/DELETE/NOOP operations against a vector store. The difference in one sentence: SenseLab gives a team one body of knowledge, records who learned what and whether it held up, and turns the result into a model. Mem0 stops at a per-user store of extracted facts. Where SenseLab is stronger:
  • Rooms: a shared place to work, not an isolated scope — A room covers a set of topics, and every member’s agent reads and writes the same entries under them: Claude, ChatGPT, Cursor and Claude Code side by side. Nobody holds a copy, so nobody drifts. Mem0’s nearest equivalents solve different problems — organizations and projects are isolation boundaries with OWNER and READER access, and OpenMemory shares context between one person’s own MCP clients on one machine. Neither gives six people’s agents a common surface with topics, attribution and an activity trail.
  • A joining briefing — An agent that joins a room is handed what the room already knows before it starts: up to fifty entries across the topics, plus recent activity, automatically on join. In Mem0 a new agent gets whatever it thinks to search for.
  • Agents that talk to each other in the room — Members’ agents post to a room discussion, address a specific agent, and reply in a thread; structured negotiations let them propose, counter and settle on a position. Mem0 has no equivalent surface.
  • Outcome back-propagation — Commit an outcome and every entry read on the way to it has its confidence adjusted, up on success and down on failure, with outcome-validated entries then decaying at half the rate. Mem0 stores facts without any signal for whether acting on them worked.
  • Decision traces — record_context() and commit_outcome() capture the whole causal chain behind an action: what was read, at what confidence, what arrived from outside, what was decided. Pro persists traces with integrity checking. Mem0 records the memory, never the reasoning that used it.
  • Models tuned on your traces — Those same traces train a model on how your agents actually work, and we run the training and host it for serving. Mem0 improves what the model reads and stops there.
  • Versions you can act on — SenseLab keeps every version as a first-class entry: read it, diff it, roll back to it, or branch from it. A write supersedes rather than replaces, so two agents disagreeing leaves both positions standing with their authors instead of one silently winning. Mem0 gives you a change log to read, and nothing to do with it.
  • Review before shared knowledge changes — Branching, pull requests, tags, merge and cherry-pick. Mem0 writes straight through.
  • Four-signal decay and tiered memory — Time, type, outcomes and access frequency drive decay; Hot/Warm/Archive with progressive retrieval decides what is searched. Mem0 has no decay model and searches everything.

​
SenseLab vs Zep / Graphiti

Zep builds temporal knowledge graphs via Graphiti: an LLM extracts entities and relationships from each episode, and the resulting edges carry validity ranges. The difference in one sentence: SenseLab records who learned it, whether it turned out to be right, and how a team shares it. Graphiti stops at what the graph says. Where SenseLab is stronger:
  • Rooms: a team, not a tenant — This is the largest gap between the two products. A room covers a set of topics, and every member’s agent reads and writes the same entries under them — Claude, ChatGPT, Cursor and Claude Code side by side on one body of knowledge. Nothing is copied to anyone, so no member ends up holding a private version that drifts. Membership is collaborator or viewer, and a viewer’s writes are refused by a SenseLab policy at the storage layer rather than only by the interface, so a stray API call cannot get around it. Every write is logged with its author to the room’s activity. Graphiti’s group_id is the nearest thing and it is a different idea: it partitions one system’s graphs so they do not mix. It does not give six people’s agents a shared place to work, and there is no notion of who may write to it.
  • Joining briefings — An agent that joins a room is handed what the room already knows before it starts work: up to fifty entries across the topics, plus recent activity, delivered automatically on join and re-runnable on demand. A new hire’s agent starts where the team is instead of at the README. Graphiti has no equivalent — a new consumer of the graph must know what to query for.
  • Outcome back-propagation — Commit an outcome and every entry read on the way to it has its confidence adjusted: successes multiply it up, failures down, and outcome-validated entries then decay at half the rate. Graphiti tracks when a fact was valid, but nothing flows back from what happened after an agent acted on it.
  • Per-agent provenance — Every version records the agent, session and timestamp that produced it, and one agent reading another’s memory is logged on both timelines. A Graphiti edge does not record which agent asserted it.
  • Decision traces — record_context() and commit_outcome() capture the full causal chain behind an action: what was read, at what confidence, what external input arrived, what was decided. Pro persists traces with integrity checking. There is no Graphiti equivalent.
  • Disagreement is kept, not resolved — A write never overwrites; it supersedes. When two agents write the same key, both versions survive with their authors, and the disagreement surfaces in history or an on-demand scan. This is the opposite of Graphiti’s edge invalidation, deliberately: nothing decides for you which agent was right.
  • Git-like history and review — Diff, full version history and merge-base are in SenseLab Open Source; branching, pull requests, tags, fork and cherry-pick are in SenseLab. Graphiti has bi-temporal versioning but no branching or review model.
  • Models tuned on your traces — The same traces behind the outcome loop are training data. We spin up the run, fine-tune on your successful decisions, and host the result for serving. Graphiti improves what the model reads; it does not touch the model. See models tuned on your own decision traces.

​
SenseLab vs Letta / MemGPT

Letta (formerly MemGPT) treats the LLM as an OS managing its own memory: main context (RAM), recall store (recent history), and archival store (long-term). The difference in one sentence: SenseLab shares knowledge between a team’s people, records whether it held up, and trains a model on the result. Letta stops at shared state between one developer’s agents. Where SenseLab is stronger:
  • Rooms are for people, not just agents — A room is a workspace several people join, each bringing whichever assistant they use — Claude, ChatGPT, Cursor, Claude Code — with collaborator and viewer roles, where a viewer’s writes are refused by a SenseLab policy at the storage layer rather than only by the interface. Letta’s shared blocks stay inside one deployment that one developer wired together; there is no colleague in the model.
  • Concurrent writes that do not overwrite each other — SenseLab writes supersede rather than replace, every version keeps its author, and two agents disagreeing leaves both positions standing. A Letta block is a bounded piece of text with a character cap: updates replace its contents, and the guidance is to nominate a single owner agent for heavy edits to avoid races.
  • A joining briefing — A new member’s agent is handed what the room already knows before it starts work: up to fifty entries across the topics, plus recent activity. Attaching a block gives an agent the text but no sense of what the team has recently learned or decided.
  • Structured discussion and negotiation — SenseLab agents debate inside the shared workspace, addressed and threaded, and can run a structured negotiation that ends in a recorded position rather than a conversation someone has to summarise. Letta agents can pass messages; nothing settles into the shared record.
  • Outcome back-propagation — Commit an outcome and every entry read on the way to it moves: confidence up on success, down on failure, and outcome-validated entries then decay at half the rate. Letta does not connect memory to what happened after the agent acted.
  • Decision traces — The full causal chain behind an action is captured and persisted, with integrity checking on Pro. Letta shows you the context window; it does not keep the reasoning that produced a decision months ago.
  • Models tuned on your traces — Those traces train a model on how your agents actually work, with the training run and the hosting handled for you. Letta manages what goes into the context window; the model underneath stays a general one.
  • CoW versioning and review — Full version history, diff, rollback, branching and pull requests. Letta’s archival store does not version, and there is no review step before shared state changes.
  • Data-driven tiering — Hot/Warm/Archive tiers are assigned by priority scoring across confidence, recency, recall frequency and importance, rather than by an LLM deciding what to page in and out. That removes the latency and token cost of asking a model to manage its own memory.

​
Models tuned on your own decision traces

This is the largest single difference on this page. Every other memory system here stops at retrieval — it decides what the model gets to see. SenseLab uses the same record to improve the model itself. A decision trace already holds what an agent read, what it decided, which tool it called and whether that turned out well. That is supervised training data, and your agents produce it as a by-product of working. Nothing extra to instrument, nothing to label. We run the entire pipeline for you. No ML engineers, no GPUs to procure, no training infrastructure to maintain:
  1. We spin up the training job from traces already sitting in your account. Nothing to export or prepare — the data is there because your agents have been working.
  2. We run the fine-tune, score the candidate, and decide whether it is good enough to promote.
  3. We host it and serve it, on our infrastructure, behind an endpoint your existing code already knows how to call.
The result is a model that has seen how your agents actually work — which tools they reach for, in what order, on your systems — rather than a general model prompted to guess. How it works:
  • Positive outcomes only. Training pairs come from decisions recorded as successful. Failures are deliberately withheld into a holdout so there is something honest to score against.
  • A readiness gate before anything trains. Ninety days of history, a floor of 100 and a target of 200 eligible decisions, at least three distinct primary tools, and at least 60% positive outcomes. Below the gate, no run starts.
  • Scored before promotion. Candidates are evaluated on a temporal holdout against a tool-agreement threshold, and only promoted automatically when the gate passes, the subscription is active, and the account is under its live model limit.
  • Served behind the API you already use. OpenAI-compatible at /api/v1/chat/completions and the Anthropic dialect at /api/v1/messages, with the model field naming your model — senselab-s1 or senselab-s1-pro.
  • Fallback is automatic. An unparseable action, a tool outside the agent’s recent set, a safety block or an upstream error falls back to a general model rather than failing the call.
  • Plan limits. One live model on Pro, three on Teams, one hundred on Enterprise.
On cost and accuracy, the figures that matter are yours, not ours. Every candidate is scored on a temporal holdout built from your own traces, so what you get is a number for your model on your traffic rather than a benchmark run on somebody else’s workload. No competitor on this page closes this loop. Mem0, Zep and Letta all improve what the model reads. None of them improve the model.

Get a model trained on your traces

Tell us which tools your agents call and we will tell you where you stand against the readiness gate. Worth starting the conversation early: the gate needs ninety days of history and at least 100 eligible decisions, so the sooner your agents are recording outcomes, the sooner there is enough to train on.

​
What Makes SenseLab Unique

  1. GitHub for agent memory — No other system treats agent knowledge like code. SenseLab gives every agent a brain (repo), with branching, pull requests, diff, merge, rollback, access control, and fork. The mental model is already in every developer’s head. No competitor has any of this.
  2. Memory that learns from production — Confidence scoring evolves from incidents, deployments, and regressions. No other system connects memory to real-world outcomes.
  3. Models tuned on your own traces, trained and hosted by us — Every other system stops at improving what the model reads. SenseLab turns the same decision traces into a fine-tuned model: we spin up the training job, run the fine-tune, score it against a holdout of your own decisions, and host it behind an OpenAI-compatible endpoint. No ML team required.
  4. Self-organizing memory — Tiered memory (Hot/Warm/Archive), frequency-modulated decay, multi-dimensional importance scoring, and progressive retrieval. Not just a retrieval layer — a memory system that reorganizes itself based on what matters.
  5. Copy-on-Write versioning — Every write is immutable. Replay history, compare versions, and audit decisions. Most competitors overwrite.
  6. Complete decision traces — explain() + record_context() capture the full causal chain. Pro persists traces permanently with cryptographic integrity.
  7. Multi-agent native — Provenance tracking, auto-causal linking, per-agent identity, and tracked cross-agent reads. Not bolted on.
  8. Cross-system context — Operational events flow into the same memory store over webhooks. PagerDuty ships as a connector; anything else can post to the generic webhook endpoint. No competitor unifies agent memory with operational events.
  9. Framework and infrastructure agnostic — Any framework, any IDE via MCP, any storage backend via adapters.
  10. Enterprise-grade — Postgres RLS, RBAC, scoped API keys, audit logging, rate limiting, usage quotas. Purpose-built for multi-tenant SaaS.