Get This Tool
Memharness
Pricing
- Model
- Free
Summary
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.
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.
Community Performance Report Card
No community ratings yet. Be the first to rate this tool!
Community Benchmarks Community
Sign in to submit a benchmarkNo community benchmarks yet. Be the first to share a real-world data point.
Pros
Sign in to edit- 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
Sign in to edit- 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.
Community Reviews
Sign in to write a reviewNo reviews yet. Be the first to share your experience.
About
- Platforms
- SQLite, MCP
- API Available
- Yes
- Self-Hosted
- Yes
- Last Updated
- 2026-06-19T20:47:23.786Z
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
Discussion Community
Sign in to commentNo discussion yet. Sign in to start the conversation.
Compare Memharness
Spotted incorrect or missing data? Join our community of contributors.
Sign Up to ContributeCommunity Notes & Tips Community
Sign in to contributeBe the first to contribute. General notes, observations, gotchas, and tips from people who use this tool day-to-day.
Frequently Asked Questions
- Is Memharness free?
- Yes — Memharness is fully free to use. There is no paid tier.
- 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.
Hours Saved & ROI Stories Community
Sign in to contributeBe the first to contribute. Concrete time/cost savings, with context. e.g. "Cut my code review backlog from 4h to 45m per week."
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.