The Social Tier: Remembering Who Said What

Kendall Clark · Pentad Labs · 6 July 2026 · PLRN-017

Abstract

PLRN-013 argued that an enterprise has no record of a matter that is true from no perspective, only many situated accounts that disagree, and that an agentic memory system worth the name keeps them rather than flattening them. That note made the case. This one shows the details. For each piece of WunderOS’s social memory tier, including the opinion, its fusion, the trust placed in a source, the “case file” the various perspectives live in, and the sense in which one agent knows what another has done, I give the mathematics it rests on and, in a few cases, some code.

1. Three tiers the standard picture leaves out

Almost every account of memory for agents begins from the same taxonomy taken over from mid-century cognitive psychology: working, episodic, procedural, semantic. It is a good taxonomy and I keep it. But it carries two silent assumptions. The first is that memory belongs to an individual: one mind, one store, one vantage. The second is that agentic memory should be modeled on human memory at all. I will not argue against either; both are plainly wrong in my view. But the remedy is to add a social memory tier. The four standard tiers are less wrong than incomplete. They are simply not enough for an enterprise, which, legal personhood aside, isn’t really an individual. So WunderOS adds three tiers:

1. a compliance tier (what was permitted, by whom, provable after the fact),
2. an institutional tier (what the organization knows as a whole without collapse-by-integration), and
3. a social tier (who said what, from which vantage, and how far to trust it).

2. The opinion

A confidence between zero and one cannot separate two cases a decision must separate: first, a source examined and found evenly balanced; and, second, a source about which nothing is yet known. Both read one-half; only the second should move under a little evidence. What the scalar omits is how much is unknown. So the unit of the social tier is not a probability but a Subjective Logic opinion (after Jøsang), which carries uncertainty as its own mass:

pub type SLOpinion {
  SLOpinion(belief: Float, disbelief: Float, uncertainty: Float)
}

with \(b + d + u = 1\) and a base rate \(a\) fixing the prior expectation. A decision still reads a number off it—the projected probability, \(P(x) = b + a\,u\)—but the number is no longer all there is. The move that makes the next section work is that an opinion is equivalently a quantity of evidence under a non-informative Beta prior of weight \(W\) (here \(W=2\)):

3. Fusion that does not depend on the order it arrives in

Agentic accounts of real-world facts like human gossip do not arrive in a canonical order, nor do they arrive bidden, that is, gossip and opinion confront you in the daily grind of life, whether or not one also happens to seek it out, for whatever motivation.

In WunderOS, inspired as it is in part by Linda tuplespaces, opinions come over Gerede, the substrate’s gossip protocol, which promises nothing about sequence and, after a partition, reconciles the two sides by exchanging what each is missing rather than replaying a log.

Two nodes will see the same accounts in different orders. If the combined result depended on order, the two nodes would hold two different memories of the same events.

In evidence form the fix is immediate. Jøsang’s cumulative fusion is addition of evidence,

Addition is commutative and associative. WunderOS carries the counts in a wide fixed-point integer accumulator—a quire, which does not round between operations—so the addition is exact, and “commutative and associative” becomes not an approximation that holds on the cases tested but bit-for-bit identity.

The fusion kernel (zig/sl_ops.zig) folds any number of opinions through one accumulation and one conversion, and the property is asserted directly:

test "accumulate: fold is byte-identical under any permutation (associativity)" {
    const a = OpinionTuple{ .b = 0.6, .d = 0.2, .u = 0.2, .a = 0.5 };
    const b = OpinionTuple{ .b = 0.1, .d = 0.7, .u = 0.2, .a = 0.5 };
    const c = OpinionTuple{ .b = 0.3, .d = 0.3, .u = 0.4, .a = 0.5 };
    // accumulate over every permutation of {a,b,c} — all bits_equal
}

That the substrate’s arithmetic is deterministic in this sense is the subject of PLRN-002; here it does one specific job, which is to make gossiped belief safe to hold.

4. Trust as a rating

Fusion assumes the accounts are worth pooling; discounting adjusts for the fact that some sources are worth more than others, and discounting needs a number.

WunderOS does not hand-set a weight. It carries a source’s standing as a Glicko-2 rating—an estimated skill \(\mu\), an uncertainty \(\phi\) about that estimate, and a volatility \(\sigma\) for how fast the estimate may move—and updates it after each period of outcomes \(s_j\) against sources of skill \(\mu_j\) and deviation \(\phi_j\).

With \(g(\phi)=\big(1+3\phi^2/\pi^2\big)^{-1/2}\) and \(E_j=\big(1+e^{-g(\phi_j)(\mu-\mu_j)}\big)^{-1}\), the update runs through an estimated variance and improvement,

a volatility step that solves for the new \(\sigma'\) by Illinois iteration, and then the deviation and rating themselves,

Both batch sums accumulate in the same \(i128\) quire as the fusion of section 3, so a rating period is a set of results rather than a sequence and the posterior does not depend on the order the outcomes are folded in.

Only the position and its uncertainty cross into an opinion; the volatility does not. The projection works on the display scale: it sends the rating \(r\) through a sigmoid to a success probability and the deviation \(\mathit{rd}\) through a clamp to an uncertainty mass, then splits the remaining mass in Jøsang’s evidence form,

so \(b+d+u=1\) for every valid rating, and the opinion’s projected probability \(b + a\,u\) recovers exactly the success probability the rating stood for.

The base rate is a fixed policy half, not read off the rating. The evidence split is used rather than the tidier \(d = 1-b-u\) for a concrete reason: the latter goes negative on the default prior \((1500, 350)\)—that is, on every new agent—which is not a valid opinion. Volatility is deliberately not a fifth component. Jøsang’s tuple is a closed four, so a spike in \(\sigma\) routes to a death-spiral alarm rather than into belief, and the whole step is kept as a RatingDerivation record, prior and posterior \((\mu,\phi,\sigma)\) beside the opinion it projected to, auditable and replayable like any other fact.

5. The case file

The accounts of one matter live together in a case file (codename Fallakte): a Context-scoped handle over a registered case-type schema, a bounded local world in the sense of PLRN-012 rather than a query run across everything each time the matter comes up.

pub type Handle {
  Handle(
    ctx: CognitiveContext,
    schema: CaseTypeSchema,
    /// S = C for every slot write; the case's identity.
    case_atom: ast.SemanticTerm,
    closed: Bool,
  )
}

Each write to a slot is an ordinary Pentad fact whose subject and context are the case itself, kept under the append-only classified lineage of PLRN-007; nothing is overwritten, a write is appended and tagged with the ULID it was etched under.

Reading the case is a pure projection over the accumulated rows, and the current value of a slot is its most recent write, the row of greatest ULID:

/// Resolve rows against the schema. Single cardinality: each slot takes the
/// object of its max-ULID row. Rows whose predicate is not a schema slot drop.
pub fn project(schema: CaseTypeSchema, rows: List(CaseRow)) -> CaseSnapshot {
  let slots =
    list.map(schema.slots, fn(s) {
      let winner =
        rows |> list.filter(fn(r) { r.predicate == s.predicate }) |> latest
      #(s.predicate, winner)
    })
  CaseSnapshot(name: schema.name, slots: slots)
}

Because a ULID totally orders the writes, the projection does not depend on the order the rows are scanned in, which is what lets two agents that have seen the same writes hold the same case file. The property is asserted directly:

pub fn project_order_independent_test() {
  let a = CaseRow("status", ast.Concept("open"), ulid(1, 5))
  let b = CaseRow("status", ast.Concept("closed"), ulid(2, 0))
  projector.project(schema3(), [a, b]).slots
  |> should.equal(projector.project(schema3(), [b, a]).slots)
}

Latest-write-wins is the right rule when a slot has one true current value that is merely revised over time. It is the wrong rule when two vantages genuinely disagree and neither is simply newer; there the slot wants the evidence fusion of section 3 rather than the ULID, and reconciling competing vantages that way, rather than by recency, is the convergence step just ahead of this one.

6. What an agent may be said to know

Coordination asks a question that is not about the content of memory but about its distribution. It doesn’t ask what’s true, but who is in a position to act on it. When one agent finishes a step another waits on, the waiter should proceed exactly when it can be said to know the step is done. To make that precise WunderOS reads knowledge through the modal system S5, and grounds the knowledge operator in something the substrate already records: an agent’s Lineage:

A public announcement is then just a Gerede broadcast of \(F\) to the so-called das_man group; every listening agent absorbs \(F\), and VSA superposition commutativity (\(A + B = B + A\)) gives order-independence at this depth for free.

On this reading the S5 axioms are not assumptions but consequences of using Lineage as the substrate for \(K\):

Axiom 5 is why the logic is S5 rather than the weaker S4: an agent that can read its own Lineage in constant time cannot fail to know what it does not know.

Knowledge accessibility is exactly OTP’s pg-membership in das_man, an equivalence relation because membership is reflexive, symmetric, and transitive. The system stops at depth one—it reasons about whether an agent knows a fact, not about whether an agent knows that another agent knows it—because…realism: at depth one model-checking is P-complete, linear in the fluents, and the coordination questions that actually arise are answered there.

The nested case waits for a use that needs it.

7. Related notes

The opinion calculus is Subjective Logic (Jøsang, Subjective Logic: A Formalism for Reasoning Under Uncertainty, 2016). The rating is Glicko-2 (Glickman, 2012), read as a posterior and projected into an opinion. The epistemic treatment follows Fagin, Halpern, Moses, and Vardi (Reasoning About Knowledge, 1995) and the announcement semantics of van Ditmarsch, van der Hoek, and Kooi (2007); the order-free reconciliation of gossiped state is in the line of Demers and colleagues on epidemic replication (1987). Within the PLRN series this note takes the perspectival argument of PLRN-013 as given and supplies its mechanism, and it stands on the deterministic arithmetic of PLRN-002, the append-only retraction of PLRN-007, and the bounded local world of PLRN-012.

A note on method

Written in conversation with Claude Opus 4.8 (Anthropic) as structured interlocutor. The research backstop was assembled in part with Paper Lantern. The motives, ideas, claims, framing, architectural commitments and taste, or lack thereof, are mine.

Kendall Clark · k@pentad.ai
Great Falls, Virginia
July 2026