HexVenn Temporal Graph Memory (HexVenn-TGM) is a local-first AI memory architecture for long-running agents. It stores events and entities as a bi-temporal graph in SQLite, retrieves with an explicit weighted score combining vector similarity, graph proximity, temporal cohesion, context overlap, and reinforcement — with penalties for staleness and conflict — and treats tenant isolation and procedural memory as first-class design concerns.
Why AI memory systems keep falling apart
Give a typical agent a vector store and three failure modes arrive on schedule. Staleness: a price changed in March, but the January memory retrieves with equal confidence. Lost relationships: facts are stored as isolated text, so “the client who owns that project” is a fresh search problem every time instead of a stored connection. Unexplainability: when the agent answers wrong, nobody can see which memories fired or why. Long-running agents don't need a bigger pile of text; they need memory that knows when things were true and how they connect.
What is HexVenn Temporal Graph Memory?
HexVenn-TGM is a local-first memory architecture for long-running, explainable, multi-tenant AI agents, developed as part of the Custom AI Works agent operating-system work by Edward Schechter. Its deliberate Phase 1 storage choices are SQLite with FTS5, normalized graph tables, and embedding blobs — chosen because local-first systems need portability, simplicity, deterministic behavior, low operational overhead, and offline capability. The architecture leaves room for future adapters (Qdrant, pgvector, Memgraph, Neo4j) without premature distribution.
SQLite + FTS5, normalized graph tables, embedding blobs — a single inspectable file.
Hybrid: dense vector similarity, sparse lexical relevance, and graph proximity, combined by an explicit formula.
Fuzzy context sets instead of rigid tags — memories belong partially to multiple contexts.
Successful action patterns stored as reusable procedures, not just facts about the world.
Tenant isolation designed as an architectural boundary from the start.
Memory as temporal graphs
The core idea: memory items are events and entities connected by relationships that hold over time, recorded bi-temporally — when something was true in the world, and when the system learned it. That second timeline makes corrections non-destructive (the old fact is superseded, not erased), enables historical replay (“what did we believe on Tuesday?”), and makes contradictions visible instead of silent.
SQLite as the MVP storage layer
Starting with SQLite is the deliberate engineering choice, not a compromise: one portable file that can be copied, backed up, inspected, and run offline with zero servers. Distributed vector or graph databases solve scale problems Phase 1 doesn't have yet; the adapter path is reserved for when a deployment genuinely outgrows local storage.
Explainable retrieval and the scoring formula
Retrieval exposes component-level scoring rather than a single opaque similarity number. The architecture defines an explicit weighted composite:
| D | Dense vector similarity | Rc | Recency |
| Sp | Sparse lexical relevance | F | Confidence |
| G | Graph proximity | St | Staleness penalty |
| T | Temporal cohesion | Cf | Conflict penalty |
| C | Context overlap | R | Reinforcement strength |
When retrieval surprises you, the components show exactly which signal drove it. That makes agent memory debuggable engineering — and explainable retrieval may be the most important feature in the design, because an agent whose memory can't be audited can't be trusted with consequential work.
Fuzzy context sets and procedural memory
Fuzzy context sets replace rigid tagging: a memory can belong 0.8 to “client work” and 0.4 to “billing,” matching how real context overlaps. Procedural memory is the sleeper feature: the system stores successful ways of doing things as reusable procedures, so the agent improves at tasks, not just at recalling facts about them.
Tenant isolation
Multi-tenant memory is where leakage would be catastrophic, so isolation is treated as an architectural boundary — enforced by storage structure and retrieval scoping from the first version — rather than a filter added when the second client arrives.
Potential challenges
SQLite vector search limits
Brute-force cosine similarity becomes expensive at scale; the adapter path to a dedicated vector store exists for that point.
Graph traversal complexity
Recursive graph queries grow computationally heavy as relationship density increases; depth limits and scoring cutoffs are operational necessities.
Embedding drift
If embedding models change over time, semantic-neighborhood consistency can degrade; embedding versioning remains an open item.
Reinforcement propagation risks
Graph reinforcement systems can accidentally amplify bad information; conflict penalties and confidence scoring mitigate the risk without eliminating it.
For local AI specifically, the architecture's priorities — portability, inspectability, offline operation, explainable retrieval — match what private, long-running agents actually need: memory that behaves like knowledge, not like a search index.
Frequently asked questions
What is HexVenn-TGM?
HexVenn-TGM stands for HexVenn Temporal Graph Memory. It is a local-first AI memory architecture designed for long-running, explainable, multi-tenant AI agents, storing events and relationships as a temporal graph rather than isolated text chunks.
What makes HexVenn-TGM different from vector search?
Vector search retrieves similar content. HexVenn-TGM combines vector similarity with temporal graphs, relationships, context overlap, reinforcement, procedural patterns, and explainable component-level scoring, so retrieval can be inspected rather than merely accepted.
Why does bi-temporal memory matter?
Bi-temporal memory tracks when something was true in the world and when the system learned it. That supports corrections without destructive overwrites, historical replay, contradiction tracking, and auditability.
Why use SQLite for AI memory?
SQLite is portable, local-first, reliable, easy to back up, and operationally simple — a strong MVP storage layer for private AI agents before adding distributed vector or graph adapters.
Who built HexVenn-TGM?
HexVenn-TGM is part of the Custom AI Works local-first AI agent operating-system work by Edward Schechter.
Sources and fact-check notes
HexVenn-TGM is documented from the architecture's own design materials as of September 2026. The retrieval formula, storage choices, and challenge list are reproduced as specified in those materials; performance characteristics at scale are identified within the design as open evaluation items rather than benchmarked claims. HexVenn-TGM is part of the Custom AI Works local-first AI agent operating-system work by Edward Schechter.
Keep reading
Sources and methodology
This article is a practical explainer or technical field note, not a statistical study. It distinguishes design guidance from measured outcomes; future external benchmarks must be linked beside the claim with enough context to interpret them.
Frequently asked questions
What does ai research mean for a business team?
AI Research becomes useful when it is tied to a defined workflow, an accountable owner, and a result the team can observe. The right starting point is not the most impressive technology. It is the smallest useful change that removes a real constraint without hiding risk or creating another system nobody owns.
Where should a team start with ai research?
Start by documenting one repeated process: its trigger, inputs, systems, decisions, exceptions, approval points, and desired output. Measure the current time, delay, error, or missed opportunity before choosing a tool. That baseline makes it possible to compare a pilot with the way the work operates today.
What should remain under human review?
Keep people responsible for unusual, sensitive, expensive, regulated, or relationship-heavy decisions. Automation can prepare context, route work, draft a response, or flag an exception, but the approval boundary should be explicit. The team also needs a way to stop the workflow, correct records, and review what happened.
How should the result be measured?
Choose a small set of operational measures before launch, such as handling time, response delay, exception rate, completed handoffs, rework, or qualified opportunities. Compare the same process over a defined period and include implementation, maintenance, review, and change-management costs instead of reporting gross savings alone.
When does custom implementation make sense?
Custom work makes sense when the process crosses several systems, carries private context, needs reliable approval rules, or cannot be represented by an off-the-shelf workflow. A custom build should still begin with a narrow scope and a clear handoff plan so the business is not trapped in another opaque dependency.
Custom AI Works