SuperLocalMemory

SuperLocalMemory is a governed memory brain for AI agents, positioned as one local-first memory shared by every agent a person or team runs. According to its listing, Claude Code, Codex, Cursor, ChatGPT and any MCP or CLI agent share the same governed memory, so context learned in one tool is available to the others. The product's stated purpose is to give agents durable memory that is trustworthy rather than approximate. Instead of guessing, recall tells you whether a memory actually answers the question, is only related to it, or is missing entirely. It is aimed at people running one or more coding agents on the same project, and at builders who need memory to be governed, with profiles, roles, an audit trail and verified erasure wrapped around a core that runs on the user's own machine. The project is open source under AGPL-3.0 and built by Qualixar, described as an AI Reliability Engineering lab behind 10 open-source products. The maker's relaunch post describes a rebuild around failures that showed up only after the first versions could already save and retrieve context. The harder failure was that a retrieval layer usually returns the closest thing it has, even when that thing does not actually answer the agent's question. In a chain of agents this compounds: one agent saves a half-related note, the next one treats it as fact, and the error travels onward. A second class of problem appeared once several agents shared durable state. The team needed to know when a fact was true, which agent wrote it, and who was allowed to read it, and whether deleting it really removed the derived copies. Those questions, accuracy of recall and governance of shared memory, are the two axes the relaunch was organised around. The headline capability is governed recall that refuses to bluff. Queries return one of three labels: supported, related, or no answer. Memories that are merely similar are handed back separately and labelled as related, while something is only marked as an answer when a stored memory actually supports it. When several agents share one memory, that label travels with the handoff, so a downstream agent inherits the uncertainty instead of a false certainty. An optional Answer Check verifies recall, checked by Laya on the user's Mac or by Jev online. One commenter singled out this distinction as the most valuable part of the design, noting that returning no answer is more useful than passing a vaguely relevant fact to the next agent. SuperLocalMemory is presented as one memory brain for every agent rather than a separate store per tool. Claude Code, Codex, Cursor, ChatGPT and any MCP or CLI agent connect to the same governed memory, whether through the Model Context Protocol or the command line. The system is described as mesh-connected, and the relaunch is accompanied by a separate mesh product listing from the same maker. The stated benefit is continuity across tools: what one agent learns does not have to be re-explained to the next one. The stated risk, which the makers explicitly invite feedback on, is where shared memory helps and where it becomes dangerous when more than one coding agent works on the same project. That open question is the reason access control and labelling sit in the shared layer instead of being left to individual agents to handle. Beyond text, the product includes optional local picture and PDF memory. Users can find pictures and PDFs by describing them, using Google's EmbeddingGemma 2. Memory is also time-aware: recall takes time into account, and every fact keeps a record of who wrote it and when, and the system tracks when each fact was true. The research behind the product describes related machinery, including a full cognitive memory taxonomy, adaptive forgetting, a memory lifecycle modelled as Langevin dynamics rather than hand-tuned decay, a retrieval metric drawn from information geometry, a distance metric that prefers full-fidelity embeddings over quantized ones, and a formal way to detect contradictions between memories. Governance is the V4 layer of the system. It enforces profiles, scopes, roles and role-based access, maintains a hash-chained audit trail, and offers verified erasure so that deleting a memory can be shown to have removed it. The first preprints describe local-first memory for multi-agent AI with a defence against memory poisoning through isolation and Bayesian trust scoring, and no cloud or LLM calls. Reliability claims are presented with unusual candour: the V4 paper opens with a negative result, reporting ten mechanisms that were implemented and reachable on a live call path yet ineffective at their final connection, plus two mechanical checks added to tell implemented, reachable and effective apart. Fault-injection testing of the write path covered eleven scenarios each run 200 times, holding 2,199 of 2,200 scoped properties. Measured properly, a governed write takes 11.0 ms, and most of that is described as the cost of durability rather than governance. The overall approach is local-first and evidence-led. The core memory path runs on the user's machine, so memory does not have to leave it. Memory is stored as facts rather than loose text; facts are ranked so that recency and relevance are respected, and old memories are forgotten. Everything is open source under AGPL-3.0, and the design is backed by four arXiv preprints published between February and August, covering local-first memory for multi-agent AI, the mathematical foundations of retrieval and forgetting, the cognitive taxonomy of the living brain, and the V4 governed memory system. According to the co-authors, each paper added something the product actually ships. Benefits stated or directly implied include a reduction in compounding errors across agent chains, because related-but-wrong context is labelled instead of silently promoted to fact. Users get continuity: one memory shared across Claude Code, Codex, Cursor, ChatGPT and other MCP or CLI agents, so context carries over between tools and sessions. They get provenance for every fact, the ability to know when a fact was true, and an audit trail of what happened. They get to enforce who can read what, and to demonstrate that data was erased. They also retain control over where the core runs, since it sits on their own machine, and they can inspect the implementation because it is open source. Concrete scenarios described in the content include running more than one coding agent on the same project and sharing memory between them; finding pictures and PDFs by describing them rather than by filename or folder; recalling a fact while knowing whether it is still true and which agent wrote it; and applying roles and scopes so that different people or agents see different parts of a shared memory. Another scenario is the handoff between agents, where the supported, related or no-answer label is passed along so the receiving agent does not treat an approximate memory as an answer. The makers also invite technical readers to examine the evaluation of the write path under fault injection, which speaks to teams that need reliability evidence before trusting governed memory in production workflows. The audience is developers and teams working with AI coding agents, particularly people running more than one agent on the same project, along with anyone building on MCP or CLI agents who needs shared, governed memory. Integrations named in the content are Claude Code, Codex, Cursor, ChatGPT, and any MCP or CLI agent. Google's EmbeddingGemma 2 powers picture and PDF retrieval, while Laya and Jev perform Answer Checks locally and online respectively. The launch is listed as Free and categorised under AI Coding Agents and LLM Memory, with topics including Open Source, Developer Tools, Artificial Intelligence and GitHub. The project is open source under AGPL-3.0, with code hosted on GitHub under Qualixar, and makers Arun Pratap Bhardwaj, Varun Pratap Bhardwaj and Garima Singh are listed on the launch. SuperLocalMemory's primary value proposition is memory an agent can be trusted with. By refusing to answer when the stored evidence does not support a claim, by keeping provenance and time attached to every fact, and by wrapping a locally running core in roles, an audit trail and verified erasure, it aims to make shared agent memory both useful and safe across the tools a team already uses.