Agent Memory as Institutional Knowledge: What Tech Leadership Should See in the Pipeline

BoundaryML's BAML is a DSL that turns prompt engineering into engineering: LLM functions with typed inputs/outputs, schema-validated responses, prompts that are diffable in code review and testable before any application code exists. The institutional-knowledge payload is subtle. When an agent's behaviour — its prompt, its output contract, its tool wiring — lives in a versioned, asserted artifact, the "why does the agent do this" knowledge stops being tribal. The contract is the memory: it is reviewed, diffed, and regression-tested like any other code.

SageOx (Seattle; $15M seed, 2026) builds "shared memory for AI agents and human teams" — a hivemind that captures decisions, architectural choices, and active constraints from conversations, chats, and coding sessions, then automatically primes every new agent session before it acts. Its stated differentiator is the load-bearing claim of this whole note: unlike single-agent memory tools (Mem0, Zep), it versions context team-wide, treating it like code. That is institutional knowledge made a first-class pipeline artifact rather than a per-agent scratchpad.

ThoughtWorks' Technology Radar names the failure mode precisely with its context graph technique: decisions, policies, exceptions, precedents, evidence, and outcomes modeled as first-class connected nodes — "institutional reasoning buried in Slack threads, approval chains and people's heads" turned into a queryable, machine-readable structure. Two things matter here. First, the diagnosis: most institutional knowledge is buried, not absent. Second, the Radar itself is the leadership instrument — an adopt/trial/assess/hold lens for deciding which of these patterns to bet on, which is exactly the posture this note argues leaders need.

"Treat it like code" is the lens, but code is general-purpose. The narrower question is: what shape do we give the encoded knowledge so an agent can ask it questions? The space splits cleanly. Vector stores answer "what is similar to this?" Graph databases — already surveyed in detail in [BROKEN LINK: No match for fuzzy expression: *Zep / Graphiti – bi-temporal knowledge graph] and [BROKEN LINK: No match for fuzzy expression: *A-MEM] — answer "what is connected to this?" Prolog and datalog answer a third question that neither of the others does cleanly: "given these facts and rules, what follows?"

The agent-memory consequence is that prolog/datalog is the only one of the three representations where the rules of inference live alongside the facts. For institutional knowledge that is an under-appreciated fit: most of what an organization knows is not "this fact" but "this fact implies that decision." A graph DB stores the implication as an edge; prolog stores it as a rule that fires automatically every time the edge would have been queried.

The concrete shape, sketched as a schema fragment (the kind a small-team platform-hat could write once and reuse forever):

%% Facts — three-place predicates, agent-readable, human-readable.
verdict(custom_id_slug, correct, '2026-06-07', skeptic_agent).
ledger(block_id, change_hash, verifier, parent_hash).
review(custom_id_slug, '2026-06-07', 3_agents, 1_correction).

%% Rules — institutional reasoning, written once.
trusted(Id) :- verdict(Id, correct, _, _).
trusted(Id) :- verdict(Id, verified, _, _).
needs_review(Id) :- review(Id, Date, _, _), days_since(Date, D), D > 180.
contradicts(A, B) :- verdict(A, V1, _, _), verdict(B, V2, _, _),
                     same_subject(A, B), V1 \= V2.

The query ?- trusted(X), needs_review(X). returns every claim the corpus has marked correct but has not re-checked in six months — a kind of institutional audit no graph-DB schema gets for free, because the rule for "trusted" is itself a fact about how this organization decides.

SWI-Prolog or Scryer (in production) plus an in-process Datascript or Asami graph (for the Clojure-native case) give two viable implementations. The existing wal.sh memory tiers (CLAUDE.md, bd memories, per-account MEMORY.md) are pre-prolog: they store facts as plain text, no rules. Adding a small prolog or datascript layer on top would not replace those files — it would let an agent query them: "what does this codebase trust about sandboxing?" rather than grep over the convention files.

Why this is not a duplicate: the 2026-agent-memory-systems catalogue surveys the systems (MemGPT, Zep, Mem0, A-MEM, LangMem, JITIR, CLI convention as schema). It does not name prolog or datalog as a representation, because at the system level those are below the API. They surface here as the shape an institution gives to facts it has already decided to encode.

A representation answers "how do I store the knowledge?" Propagation answers "how do two agents end up looking at the same knowledge?" The CRDT / local-first answer (see Local-First) is the well-developed one for durable state: append-only logs, vector clocks, eventual convergence.

The gap is the transient layer — the live "I am working on conjecture C-42, in proof phase, touching these files, this will be done in an hour" signal that has to reach the other agents right now so they do not pick up a conflicting conjecture. This is the layer Olivier Wulveryck's team-topologies collaboration mode would have to mechanise if it ran without humans in the loop, and it is exactly what aq (an open-source gossip layer at github.com/jwalsh/aq) addresses.

What aq carries on the wire is presence, not facts:

Filesystem-backed (~/.aq/channels/<channel>/, newline-delimited JSON per file). AQ_HOME is TRAMP-aware, so the channel can live on local disk, NFS, SSH-mounted remote, WebDAV, or SMB without changing aq. Optional transports (NATS, MQTT, IRC, Meshtastic) fan out from the filesystem; the filesystem remains the canonical store.

What this means for institutional knowledge: aq is the missing primitive between bd (durable beads, work state — see Beads) and the various memory tiers (durable facts). It is L1.5 — the layer that says "this institution currently believes the following are being worked on." The CPRR phase modulates conflict severity: two agents in proof on overlapping files is HIGH severity (independent verifiers should not be unaware of each other); one in proof and one in conjecture is MEDIUM.

This is the layer Wulveryck's stream-aligned-to-platform handoff would have trouble mechanising if it ran at multi-agent scale without a presence broadcast: agents drafting the same note from different angles, agents verifying the same claim from different machines, agents quietly racing on the same :CUSTOM_ID: drawer. aq is also the only one of the three sub-systems (representation, propagation, consistency) that has an open-source formal spec in the same repository as the implementation — spec/aq.tla, plus docs/research/GEACL-FORMALIZATION.org mapping aq to the Gossip-Enhanced Agentic Coordination Layer theory in Habiba & Khan (arXiv:2508.01531, arXiv:2512.03285). This connects directly to the consistency sub-section below.

Once an institution stores facts (representation) and propagates them (propagation), the last load-bearing question is: when can two agents that consulted "the same fact" trust that they saw the same thing? At organisational scale this is a memory-consistency problem the distributed systems community has spent twenty years on. The wal.sh treatment lives in TLA+ and TLA+ for htaccess redirects (small-domain modelling) — the agent-memory case is one more instance of the same shape.

The four reference points worth naming here:

• Cosmos DB consistency in TLA+. Microsoft has open-sourced TLA+ specifications for all five Cosmos DB consistency levels at https://github.com/Azure/azure-cosmos-tla and described the construction in Hackett et al. (https://arxiv.org/abs/2210.13661). This is the load-bearing example because it shows that a closed catalogue of consistency contracts can be specified once and queried for individual workloads. The institutional analog is "which claims need sequential consistency (the legal interpretation), which need eventual (the brand-tone audit)?"
• Gossip / SWIM. No primary-source TLA+ specification of SWIM by its original authors (Das et al., 2002) was found in this round of searches; community specs exist under https://github.com/tlaplus/Examples. The agent-coordination version is aq's spec/aq.tla — the first formal specification of an agent-presence gossip protocol the wal.sh corpus has pointed at.
• Z3 for memory-consistency models. The strongest current line is Gao et al., "Satisfiability Modulo Ordering Consistency Theory for SC, TSO, and PSO Memory Models," TOPLAS 2023 (https://dl.acm.org/doi/full/10.1145/3579835) — a custom Z3 theory solver for happens-before. This is where the "two agents saw the same fact" question becomes decidable at scale: encode the institutional contract, ask Z3 whether the propagation protocol can violate it.
• Z3 / SMT for agent state itself. Empty cell. No paper formally verifies LLM-agent state machines with Z3 was found in this round of searches. Adjacent work — Logic-LM, VERGE (https://arxiv.org/html/2601.20055v2), MCP-Solver (https://arxiv.org/html/2501.00539v2) — plugs Z3 into the agent as a tool, the inverse direction. The empty cell mirrors the one named in Agent Memory Systems under "What composes, what complects."

The throughline: representation gives the agent a shape to query, propagation gives it a way to share, consistency gives the institution a way to know what the contract actually says. The three sub-questions are independent — you can change the prolog schema without touching aq; you can swap aq for a CRDT log without changing the TLA+ model — but a pipeline that does not answer at least one of them is doing institutional knowledge on tribal infrastructure.