Give Your Local AI Agents Memory That Understands Time and Relationships

Most AI memory is a growing pile of similar text — it retrieves stale facts confidently, loses relationships between events, and can't explain why it surfaced what it surfaced. HexVenn Temporal Graph Memory (HexVenn-TGM) is a local-first architecture that stores agent memory as a bi-temporal graph and scores retrieval explicitly. This field note explains the design and its open challenges.

Temporal graph memory network projected above a small local computer, gold older memory nodes flowing along a timeline into bright blue recent nodes
Memory with a timeline: older facts in gold, current state in blue, every connection inspectable.
Quick answer

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.

Storage (MVP)

SQLite + FTS5, normalized graph tables, embedding blobs — a single inspectable file.

Retrieval

Hybrid: dense vector similarity, sparse lexical relevance, and graph proximity, combined by an explicit formula.

Context model

Fuzzy context sets instead of rigid tags — memories belong partially to multiple contexts.

Procedural memory

Successful action patterns stored as reusable procedures, not just facts about the world.

Tenancy

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:

S = 0.25·D + 0.15·Sp + 0.15·G + 0.10·T + 0.10·C + 0.10·R + 0.05·Rc + 0.05·F − St − Cf
DDense vector similarityRcRecency
SpSparse lexical relevanceFConfidence
GGraph proximityStStaleness penalty
TTemporal cohesionCfConflict penalty
CContext overlapRReinforcement 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

1

SQLite vector search limits

Brute-force cosine similarity becomes expensive at scale; the adapter path to a dedicated vector store exists for that point.

2

Graph traversal complexity

Recursive graph queries grow computationally heavy as relationship density increases; depth limits and scoring cutoffs are operational necessities.

3

Embedding drift

If embedding models change over time, semantic-neighborhood consistency can degrade; embedding versioning remains an open item.

4

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.