Trust isn't something you assert. It's something the graph computes.

There's a common proposal for making agent memory more reliable: attach a confidence score to every fact. File a memory, label it 0.8, let the retrieval layer use the score to filter low-confidence entries before they influence decisions.

The problem is that this requires someone to hand-label every memory. Agents don't naturally do this. Humans do it inconsistently. Within a few weeks the scores are either missing or stale, and the layer doing the filtering is working off numbers that were guesswork at the time of filing and have since drifted further.

Recordari doesn't use explicit confidence scores. Instead, trust is computed from structure that gets captured as a side effect of normal use.

Node kinds carry epistemic weight by design

Every memory in Recordari has a node_kind: finding, decision, standing, assumption, goal, option, issue, reference, transient. These aren't labels for human readability — they carry semantic meaning that the system acts on.

A finding is an empirically observed fact. A decision is a choice that has been settled by authority. A standing node is a durable rule or constraint — the kind of thing a team files deliberately and expects to govern future behaviour. An assumption is an unverified premise: something treated as true because no one has checked it yet.

The epistemic differences between these kinds are real. An assumption should be trusted less than a finding. A standing rule should be treated as a high-authority anchor. These properties don't need to be hand-asserted — they're already encoded in the choice of kind.

The topology signal

Node kinds give each memory an intrinsic weight. But what a memory is connected to matters at least as much as what kind it is.

Consider two decision nodes with the same intrinsic weight. One is connected to three finding nodes — empirical observations that support it. The other is connected to three assumption nodes — unverified premises it was built on. The second decision is inherently shakier, and the graph already knows this: the trust scores of its neighbouring nodes are lower.

Recordari's trust computation captures exactly this. Trust is derived from a node's own kind plus the kinds of the nodes connected to it — the same structural pattern used to compute significance (connection count), but operating on kind weights rather than edge counts. A decision resting on assumptions scores lower than a decision resting on findings, without anyone having to say so explicitly.

The contradicts edge adds a negative signal: a neighbour that contradicts the node pulls its trust score down by that neighbour's intrinsic weight. Unresolved contradictions in the graph are visible in trust scores, not just in edge labels.

All of this is surfaced through significance(mode=trust). The question it answers isn't "how connected is this node?" but "how much should I believe it?"

What this means in practice

An agent orienting on a domain at session start is shown standing nodes first — the highest-authority anchors, regardless of recency. When it encounters a decision with a low trust score, it has a concrete signal that the decision rests on unverified premises: not because a human labelled it that way, but because the graph topology says so.

An agent filing a new memory that conflicts with a high-trust standing node produces a visible tension in the graph — a candidate contradiction the filing path surfaces for review. The trust layer is what makes standing nodes load-bearing: it's not just that they're labelled standing, it's that contradicting them produces a structurally significant event.

The system builds a trust picture from honest filing choices, with no additional write burden on the agent. The agent files a finding because it observed something. It files an assumption because it hasn't verified something. Trust falls out of those choices rather than requiring a separate annotation pass.

Where the limits are

This model handles structural trust — what kind of claim it is, and what other claims it rests on. It doesn't handle provenance: who filed the memory, in what context, with what level of human oversight. A finding filed by an autonomous agent running an unattended pipeline carries a different trust baseline than one filed by a human workspace owner reviewing the evidence directly.

That's a second trust dimension, orthogonal to topology, and it requires provenance metadata rather than graph structure alone. It's what we'll cover next.

---

The trust computation is implemented as significance(mode=trust) — part of the same tool as structural significance, not a separate call. The formal grounding for the product combinator used in contradiction severity comes from weighted argumentation systems theory.

References: OWASP Agentic AI Threats and Mitigations — Wooldridge et al., Weighted Argument Systems (AIJ 2011)