A working, legible model. It runs live, end to end: phases, blind commitments, votes, quorum, judge reasons, and a causal ledger — the mechanics of accountable group decision, made observable instead of hidden behind a score.
A toy model. The "game theory" here is illustrative — quorum is plain majority, payoffs are simple. It demonstrates ROOT0's architecture for witnessed decisions; it is not a validated equilibrium result or a benchmarked solver.
His own coinages, rendered. "Witness," "veracity ledger," "blind packet," "quorum runtime," the court framing — these are David Lee Wise's system, made concrete here. Read them as a designed vocabulary, not standard game-theory terms.
The actual engine, embedded and running. Load a topic, then Run All Slowly to watch the phases fire — votes accumulate, the quorum forms, judges post reasons, and the causal ledger fills in the "why now?" for each event. Everything you see is computed locally; nothing is sent anywhere.
engine_core.py) lives in the repo for inspection.A run begins with a contested topic (a controversy, a decision). The engine steps through fixed phases — a transparent order of operations, so no move happens off-stage.
Agents seal their positions before reveal — a commitment you can't retro-edit. The same idea as a sealed bid: you're bound to what you committed, which is what makes the later vote trustworthy.
Positions are tallied; a quorum settles the outcome. The reference core is honest about its simplicity — quorum(votes) returns the plain majority — the point is the visible tally, not a clever rule.
Judges score the resolved decision and must post a reason. A verdict with no stated reason isn't allowed to count — accountability is built into the data type, not bolted on after.
Every event records its cause: the "why now?" panel shows the active arrows — what triggered what. The decision isn't a final number; it's a replayable chain of moves.
The run carries a veracity verdict — the engine's own discipline applied to its own claims (the same idea as ROOT0's veracity ledger). It judges whether the process actually held.
The thesis. A group decision should be a witnessed object — committed-before-reveal, tallied in the open, reasoned-about by named judges, and logged with its causes — not a scalar you're told to trust. This engine is that thesis you can press play on; it grew, version by version, from a bare core through an "agentic commons," witness scoring, and a quorum runtime to this visual causal view. ⚑ It sits beside ROOT0's other witness pieces — the veracity ledger, the far side (a machine that measures its own gap), and the court/shadow-court work.
Two layers, held apart. What this is: a genuine, runnable, self-contained model of accountable multi-agent decision — phases, blind commitments, open tallies, reasoned judging, and a causal ledger — built deliberately across twenty-seven versions, and a faithful render of ROOT0's witness-and-court framework. What it is not: validated game theory. The payoffs are illustrative, the quorum is a plain majority, and "veracity" is a designed verdict in David's own vocabulary, not a theorem about truth or a benchmarked solver. It is an architecture demo — a way to make the usually-invisible machinery of a group decision watchable — and it should be read as exactly that: a prototype that argues, by running, that decisions deserve to be witnessed. The naming ("witness," "blind packet," "quorum runtime," "veracity ledger") is ROOT0's coined system; the value is the legibility, not a claim of optimality. ⚑ Render-not-invent: this page describes the engine David built; it doesn't dress a toy as a result.