Most "agent memory" is a vector store with a similarity search bolted on. Vectadyne is a governed control plane: a typed, bi-temporal, provenance-complete knowledge graph with a deterministic trust boundary between having a memory and acting on it. This page is how it works.
A fleet of agents generates enormous experience and almost never reuses it safely. We treat memory as five logical planes — evidence, canonical graph, guides, retrieval + admission, governance — where evidence is immutable and everything downstream is derived and traceable back to it. The result is experience reuse that is shared, explainable, and governed: one agent's failure becomes the whole org's guardrail, without a rulebook anyone has to maintain by hand.
Every memory node is a point in a three-dimensional space. Because the axes are independent, the system can answer who a memory is for, when it is true, and what shape of knowledge it is — separately and precisely.
A governance-inheriting lattice; a policy at org is enforced everywhere below it.
Bi-temporal: when a fact was valid in the world vs. when the system asserted it.
Seven typed kinds with six edge types — a real graph, not a bag of chunks.
Naïve decay throws away knowledge that is still correct. Vectadyne forgets for a reason — each transition is a recorded, auditable event, and the bi-temporal record means you can always time-travel to what an agent knew at decision time.
Current and trusted — admitted at full weight.
Contradicted by newer evidence; surfaced, but down-weighted.
Past its review_after horizon; flagged for re-derivation.
Superseded or retracted; kept for audit, excluded from retrieval.
Retrieval is cost-adaptive: cheap lexical and scope filters first, dense and graph expansion only when the budget and the query warrant it. Then admission — the part that matters — gates candidates deterministically, on both the write path and the read path.
The evidence log is append-only and hash-chained — a tamper-evident system of truth. Canonical memory is derived, never hand-typed, so any node, guide, or verdict can be walked back to the raw traces, PRs, and CI runs that produced it.
A node's weight at admission combines several priors, so a fresh, corroborated, high-scope lesson outranks a stale, disputed one — automatically.
The vocabulary buyers and papers use — working / episodic / semantic / procedural — maps cleanly onto our seven kinds. We don't replace the taxonomy; we make it typed, scoped, and governable.
An internal eval + safety harness ships with the product as vec e2e, measuring failure-prevention against a held-out set of known regressions. Directional results from pilot repositories:
We publish our uncertainties, not just our claims. Each of these has a written trigger for when we'll adopt a heavier design.
v1 forgetting is event-driven. We'll add a continuous decay sub-score only if the eval harness shows stale-but-not-yet-flagged memory materially degrading verdict quality — the freshness_prior already carries the plumbing a decay term would slot into.
v1 is deliberately 1-hop. Multi-hop traversal, community detection, and GraphRAG-style community summaries are deferred until retrieval quality on real fleets demonstrably needs them — not before, because they cost latency on the preflight hot path.
Auto-derived lessons are both the only value source and the top attack surface. We require provenance-backed derivation and write-time admission thresholds, so a single crafted trace cannot mint an enforced memory.
The research is only interesting if it prevents a real failure. Watch it warn on a repeated fix in your codebase.