Cadenya
Freemium
Developers building agentic workflows
Memharness
FreeOpen SourceAPISelf-Hosted
Most agent memory is a bag of strings that gets stuffed into a context window and thrown away — leaving no record of what the agent believed yesterday, no way to answer why it acted the way it did, and no mechanism to selectively forget a source without rebuilding the whole store. memharness is a bi-temporal, provenance-carrying memory primitive built to close that gap.
Similar tools
CadenyaFreemiumCadenya is an agent runtime built around a layered model: tools connect once through MCP…
WorldsFreemiumWorlds spins up a sealed twin of the external systems your agent touches — Stripe and Zendesk…
Brain MemoryFreeBrain Memory stores agent decisions as Markdown files with YAML frontmatter, organized in a…
JevProxyFreemiumThe proxy sits in front of your Cursor or Claude Code agent fleet and classifies incoming tool…
Get This Tool
License: Apache-2.0 Any use incl. commercial
Local-run terms: Run via npm in examples directory; single SQLite file; full source available under Apache-2.0.
Screenshots 1
Pricing
- Model
- Free
Summary
The core premise is storing facts, not strings, with two independent time axes: when something became true in the world and when the agent learned it — so querying past agent states is a real query, not archaeology through logs. Everything lives in a single SQLite file, which means the storage layer makes zero LLM or network calls and stays auditable. Recall combines hybrid vector search and full-text search with a source-staleness signal, so older or superseded sources rank down automatically. Where it breaks: the SQLite backend is a hard ceiling for teams expecting distributed writes or high-concurrency production deployments. Teams hitting that ceiling will need to treat memharness as a pattern to port, not a service to scale horizontally.
Bottom line: Reach for memharness when your agent needs months of traceable, correctable, GDPR-deletable memory stored in a single auditable file — skip it when your deployment needs concurrent writes from more than one process.
Find your fit
Before you choose Memharness
More options in Agent Frameworks. Compare pricing, platforms, and features side by side.
Brain Memory
Free · Open source
Long-term continuity in multi-session coding projects
Pros
- Bi-temporal storage tracks both world-time and agent-learn-time independently, so you can reconstruct exactly what the agent believed at any past moment — which means post-incident reviews and compliance audits have an actual record to query instead of inferring from logs.
- Provenance-scoped deletion lets you remove all facts derived from a specific source in one operation, so GDPR takedown requests or source revocations do not require a full memory wipe that destroys unrelated facts.
- The storage layer makes zero LLM or network calls, so memory reads and writes have no latency dependency on external APIs and no token cost — which means memory operations do not blow your inference budget.
- Hybrid vector-plus-full-text recall with a built-in staleness signal means older or superseded sources rank lower automatically, so the agent surfaces the most current relevant facts without you writing custom re-ranking logic.
- MCP exposure and a self-hosted SQLite backend mean the tool drops into any agent stack that speaks MCP without requiring a separate managed service, so you retain full data ownership and avoid a vendor dependency in the memory layer.
Cons
- SQLite is a single-writer database: the moment two agent processes attempt concurrent writes — a parallelized pipeline, a multi-worker deployment, any architecture where more than one process holds the file — writes will collide or block. Teams with concurrent-write requirements either serialize all memory operations through a single process (adding a bottleneck) or abandon memharness for a Postgres- or Redis-backed alternative.
- The project has 2 stars and 1 fork on GitHub at time of curation, with 19 commits and no open issues, which means community-sourced debugging, third-party integrations, and production war stories are essentially nonexistent. Teams that hit an edge case are reading the source, not a Stack Overflow thread.
- There is no built-in access control or multi-tenant isolation: if multiple agents or users share the same SQLite file, provenance-scoped deletion could become a liability rather than a feature — one delete call wipes facts for every tenant who learned from that source. Teams building multi-user applications will need to implement per-user database files or a sharding layer before going to production.
About
- Platforms
- SQLite, MCP
- API Available
- Yes
- Self-Hosted
- Yes
- Last Updated
- June 19, 2026
Best For
Who it's for
- Agents with months of evolving facts
- Applications requiring explainable memory
- GDPR-style source-specific forgetting
- Scenarios where corrections must remain traceable
What it does well
- Long-term agent memory exceeding context windows
- Audit trails for agent decisions and belief changes
- Provenance-scoped deletion or forgetting
- Bi-temporal queries on past agent states
Compare Memharness
Frequently Asked Questions
- Is Memharness free?
- Memharness offers a free option. Hosting, model usage, or optional services may have separate costs; check the pricing details and official terms.
- Is Memharness open source?
- Yes. Memharness is open source.
- Does Memharness have an API?
- Yes. Memharness exposes a developer API. See the official documentation at https://github.com/las7/memharness for details.
- Can I self-host Memharness?
- Yes. Memharness supports self-hosting on your own infrastructure.
- What platforms does Memharness support?
- Memharness is available on: SQLite, MCP.
People also compared
Curated lists that include this category
Agent memory that forgets its own history is a liability: the agent cannot explain its reasoning, cannot be corrected without a full wipe, and cannot comply with a request to forget everything from a specific source. memharness addresses this by treating every stored item as a fact with two timestamps — a valid-time axis tracking when the fact was true in the world, and a transaction-time axis tracking when the agent learned it. These are stored separately in SQLite, exposed to any agent via the Model Context Protocol (MCP), and queried without touching an LLM or the network.
The differentiating feature is bi-temporality combined with provenance. Every fact carries its source, so deletion is scoped: you can remove everything learned from a specific document or API endpoint without touching other facts. Corrections are traceable — when a fact changes, the old version is not overwritten, it is closed on the transaction axis. That architecture is what makes explainable memory and GDPR-style forgetting possible from the same data model, rather than bolted on as separate systems.
Recall is hybrid: vector similarity search and full-text search run together, with a source-staleness signal that adjusts ranking based on how old or superseded the originating source is. The vendor documents this signal in a dedicated STALENESS-SIGNAL.md, which suggests it is a first-class design concern rather than a tuning afterthought. The tool positions itself as a memory primitive, not an agent framework — it does not plan, route, or act autonomously.
The SQLite-only backend is both the simplicity story and the hard constraint. A single file is trivially portable, auditable, and zero-infrastructure — which makes this a fit for single-process agents, local deployments, and prototypes requiring auditability. It is not a fit for multi-process or distributed deployments where concurrent writes from separate agent instances would corrupt the store. Teams at that scale will either hit SQLite’s write-concurrency ceiling or need to architect a wrapper that serializes writes, at which point memharness is a reference implementation rather than the production layer.
Contribute
- Work on Memharness? Claim this listing.
- Embed a badge for your README or site.
Sign in to rate this tool or suggest an edit.