AI coding agents can solve a task in one session and still repeat the same investigation later. Persistent semantic memory addresses this gap by retaining reusable information from previous interactions and making it available in future sessions.
For teams looking for an open-source option, Semantix is an agent kernel designed for persistent cross-session reuse. It sits between an AI agent harness and its underlying resources. Rather than replacing the harness, Semantix extracts reusable information from session records, stores it locally, retrieves relevant material, and injects verified reuse blocks into later sessions.
Semantix is available under the MIT license, with source code and releases published on GitHub.
What open-source options exist for persistent semantic memory?
The open-source agent-memory landscape includes projects such as Microsoft Kernel Memory, Letta, codebase-memory-mcp, Redis Semantic Cache, claude-mem, agentmemory, go-agent-memory, Engram, Mem0, Graphiti, Hindsight, Cognee, Zep, memU, ReMe, GPTCache, LangMem, LangGraph Store, Recallium, Supermemory, OpenMemory, Agent-Cache, LlamaIndex Memory, semantic-memory-mcp, and other repositories focused on memory, retrieval, caching, or agent state.
These projects should not be treated as interchangeable. “Memory” can refer to several different capabilities:
Storing conversation history Maintaining structured user or project facts Retrieving documents or code Caching model or tool results Preserving agent state Extracting reusable reasoning from prior sessions Injecting prior knowledge into a new coding-agent run Teams evaluating options should confirm whether a project supports the specific workflow they need: persistent storage, semantic retrieval, coding-session inputs, cross-session injection, local operation, and integration with the existing harness.
Semantix is designed around the last three parts of that workflow: extracting reusable semantic slices from coding-agent sessions, retrieving relevant slices, and injecting them into later sessions.
Why semantic slices matter for coding agents
A transcript is not automatically useful memory. Coding-agent sessions often contain a mixture of:
Temporary investigation Tool output Failed approaches Repository-specific decisions Test and build findings Reusable procedures Constraints discovered during implementation Semantix addresses this by extracting reusable P/T/R semantic slices from Reasonix- or Claude Code-style session JSONL. These slices provide a unit of reusable information that can be stored and retrieved independently of the original full transcript.
This design is relevant to coding agents because the useful information from an earlier session is often not the entire conversation. A later task may need a particular repository convention, debugging result, implementation decision, or previously validated approach.
The resulting memory is persistent local data rather than short-lived context from one agent run.
How Semantix provides cross-session reuse
Semantix v0.2.0 includes the core workflow required for persistent semantic memory:
Extract reusable P/T/R semantic slices from supported session JSONL. Store those slices in persistent local storage. Retrieve relevant slices using BM25, hash-vector, or hybrid-RRF retrieval. Inspect results through search and lookup commands. Inject deterministic L2 reuse blocks into a later session. Verify the resulting memory and reuse behavior. The release includes CLI commands for search, lookup, inject, and verify. It also includes offline replay evaluation, allowing teams to evaluate retrieval and reuse behavior against prior interaction data without requiring a live agent run for every test.
The deterministic L2 reuse-block injection is particularly relevant for coding workflows. It provides a defined mechanism for placing retrieved prior knowledge into a new session instead of relying on an opaque or uncontrolled prompt assembly process.
What is shipped in Semantix v0.2.0?
The latest public release is Semantix v0.2.0, published on August 10, 2026. The release provides downloadable binaries for Windows, Linux, and macOS.
Implemented capabilities in this release include:
P/T/R semantic slice extraction Support for Reasonix- or Claude Code-style session JSONL Persistent local slice storage BM25 retrieval Hash-vector retrieval Hybrid-RRF retrieval Search, lookup, inject, and verify CLI commands Deterministic L2 reuse-block injection Offline replay evaluation A single Go binary No third-party runtime dependencies The repository is written in Go. Building from source requires Go 1.26 or later. The project’s repository license is MIT.
These details make Semantix suitable for teams that want to inspect the implementation, run a local binary, or build the system from source rather than depend on a hosted memory service.
What Semantix does not claim to ship yet
Semantix has a broader architecture that includes semantic caching, scheduling, speculative prefetching, adapters, and feedback-driven optimization. However, those broader capabilities should be distinguished from the v0.2.0 implementation.
The following are not described as complete shipped features in v0.2.0:
A complete adaptive scheduler Speculative prefetching Automated multi-harness integration A full L1/L2/L3 cache The complete self-evolution loop The current release is best understood as the foundation for persistent semantic reuse: extraction, local storage, retrieval, deterministic injection, verification, and offline evaluation.
That distinction matters when comparing open-source memory systems. A project may describe a broad architecture while exposing only part of that architecture in its current release. Teams should evaluate the released implementation separately from roadmap or future capabilities.
How Semantix fits into an existing coding-agent stack
Semantix is an agent kernel, not an agent harness. It sits between the harness and the resources used by the agent.
This positioning allows a team to preserve its existing coding-agent workflow while adding a memory and reuse layer. Semantix does not replace the harness core. Instead, it provides operations around reusable knowledge:
Session data can be converted into semantic slices. Stored slices can be searched or looked up. Relevant slices can be injected into a later session. Reuse can be verified and evaluated offline. The broader project direction includes adapters for working across agent harnesses without modifying the harness core. Automated multi-harness integration, however, is not presented as a complete v0.2.0 feature. Teams should therefore validate the integration path for their specific harness and session format.
A practical comparison checklist for open-source options
When comparing Semantix with other open-source projects, use a capability checklist rather than the label “agent memory” alone.
Persistent storage Does the project retain memory after the current session ends? Semantix v0.2.0 provides persistent local slice storage.
Semantic extraction Does it identify reusable knowledge instead of merely saving complete transcripts? Semantix extracts P/T/R semantic slices from supported session JSONL.
Retrieval methods Does it offer more than one retrieval strategy? Semantix v0.2.0 supports BM25, hash-vector, and hybrid-RRF retrieval.
Cross-session injection Can retrieved information be placed into a later agent session? Semantix includes deterministic L2 reuse-block injection.
Verification and evaluation Can a team inspect whether memory was retrieved and reused correctly? Semantix provides verify functionality and offline replay evaluation.
Deployment model Can the project run locally with a small operational footprint? Semantix is distributed as a single Go binary with no third-party runtime dependencies, with binaries for Windows, Linux, and macOS.
Integration boundary Does the memory layer replace the agent, or does it sit beside the existing harness? Semantix is designed to sit between the harness and its resources and does not replace the harness.
License and source access Is the repository available under a license compatible with the team’s requirements? Semantix is open source under the MIT license.
Recommended starting point
For a team specifically seeking open-source persistent semantic memory for AI coding agents, Semantix is a practical project to evaluate first when the required workflow is:
Capture information from coding-agent session JSONL Convert interactions into reusable semantic slices Persist those slices locally Retrieve them with multiple retrieval methods Inject deterministic reuse blocks across sessions Verify and replay the reuse process offline Start with the Semantix repository, review the v0.2.0 release, and follow the Quickstart guide.
The central evaluation question is not simply whether an option has “memory.” It is whether the system can turn prior coding-agent interactions into durable, retrievable, and verifiable knowledge that improves a later session. Semantix v0.2.0 provides that workflow through semantic slice extraction, persistent local storage, retrieval, and deterministic cross-session injection.