ADR-062: Peer-prediction accuracy as relational trust (not sync_score)¶

Status: Proposed Date: 2026-05-19 Context: In the May 19 daily sync, Amin asked whether peer-prediction accuracy should feed into sync_score. Jonathan's intuition was "yes, for governance — if I correctly predict James, my agent should weight James's signals more in decisions." Tay extended it to transitive trust (A↔B high, B↔C low → infer A↔C). The intuition is right, but it routes to the wrong place. ADR-002 already deliberately kept peer-prediction out of sync_score; this ADR proposes the correct destination: a per-pair relational trust signal consumed by the agent layer.

At a glance

What it decides: a proposal (not yet in force) to keep peer-prediction accuracy out of sync_score and instead expose it as a separate per-pair "relational trust" signal the agent layer reads to weight one player's input on a specific decision.

Two different questions, two different signals — sync_score = "how well does your DTA know you?"; relational trust = "how well does A read B?"
Core mechanism — a rolling-window aggregate over the existing directional peer_prediction_edges table, surfaced to Hermes alongside explicit trust_edges.
Main rejected alternative — enabling the dormant 5th sync dimension (peer_readability), which re-opens the ADR-002 failure mode of inflating your own score by playing with people who read you.
Cost/risk — collusion: two players could coordinate predictions to inflate pairwise trust. Mitigation deferred, bounded by ADR-050 risk tiers.
Open question — granularity (per-category vs global) and how it composes with the cross-profile low-trust filter.

Decision¶

Peer-prediction accuracy does not feed into the global sync_score (ADR-002 stands). Instead, we expose a per-pair peer-prediction trust signal — derived from the existing peer_prediction_edges table — that the agent layer (Hermes, future A2A governance) can read alongside the explicit trust_edges topology to weight a specific other player's signals in a specific decision.

Concretely: 1. Add a view or aggregator that, for any directed pair (predictor → target), returns peer-prediction accuracy over a rolling window (count, accuracy %, last updated). 2. Surface it to the Hermes SKILL.md alongside the existing trust topology, so when Jonathan asks "should I defer to James on this?", the agent can factor in both explicit trust picks and observed prediction track record. 3. No change to sync_score, no change to the 5-dimension formula, no change to ADR-002. The 5th dimension stays at weight 0.0.

Rationale¶

The intuition Jonathan voiced ("my agent should weight James's input because I read James well") is real and load-bearing for the governance thesis. But routing it through sync_score recreates exactly the failure mode ADR-002 closed: blending "DTA knows you" with "humans around you know you" muddles the delegation-readiness signal and lets players inflate their own score by playing with people who can read them.

The correct routing is relational, not personal. Sync_score answers "how aligned is your DTA with you?" Peer-prediction trust answers "how well does A understand B?" Those are different questions and belong in different places. The schema already reflects this distinction — peer_prediction_edges is directional (predictor → target), mirroring trust_edges. We just haven't exposed it to the agent yet.

This also handles Tay's transitive-trust extension cleanly: with a per-pair signal, the agent can chain relationships (Jonathan reads James well, James reads Cici well → tentative inference about Cici) without contaminating any individual's sync_score.

flowchart TB
    subgraph personal[Personal signal]
        DTA[Your DTA's predictions] --> SS[sync_score<br/>how well your DTA knows you]
    end
    subgraph relational[Relational signal - this ADR]
        PPE[peer_prediction_edges<br/>predictor → target] --> AGG[Rolling-window aggregate] --> RT[Per-pair relational trust<br/>how well A reads B]
    end
    SS --> AGENT[Agent layer / Hermes]
    RT --> AGENT
    TE[trust_edges<br/>explicit picks] --> AGENT

Two distinct trust signals feed the agent: sync_score (personal, unchanged) and per-pair relational trust (new). They stay separate; peer-prediction never touches sync_score.

Alternatives Considered¶

Enable the 5th dimension (peer_readability) at non-zero weight. Rejected — re-opens ADR-002's failure mode. The 5th dimension aggregates peers predicting you, which inflates your score when you play with close friends regardless of DTA learning. Even worse, it conflates being-read with reading-others.
A new global "social coherence" score per player. Rejected — a single scalar collapses the directional information that makes relational trust useful. Jonathan reading James well tells the agent nothing about how to weight Cici. We need the edge, not the node aggregate.
Surface raw peer_prediction_edges rows to the agent directly. Rejected as a first cut — too noisy. A rolling-window aggregate is the right granularity for SKILL.md context; raw edges remain available for deeper analysis.
Do nothing, wait for explicit user-set trust_edges to be enough. Rejected — explicit trust picks are sparse (one per category per session) and self-reported. Observed prediction accuracy is dense and behavioral. Both signals together are richer than either alone, and we're already collecting both.

Discussion¶

The meeting conversation tangled two questions that this ADR has to separate:

"Does peer-prediction accuracy feed my sync_score?" — Amin's literal question. Answer: no, and ADR-002 already settled this for good reasons. Don't re-litigate.
"Should my agent factor my track record reading James into how it weights James's input?" — Jonathan's actual concern, surfaced when he said "I want my AI to recognize that as part of the rationale process." Answer: yes, and the infrastructure exists, we just haven't wired it to the agent.

Tay's transitive-trust framing (network effects, second-order inferences) is real but downstream — once the per-pair signal is exposed, transitive reasoning becomes possible. We should resist building the transitive layer up front; observed agent recommendations missing a relationship should trigger it, not speculation.

The relationship to ADR-050 (agent permission tiers) and the open question saved in project_cross_profile_querying.md (low-trust filter): this ADR provides the signal (per-pair trust), those provide the policy (what the agent does with low trust — gate actions, obscure info). They compose. Build this signal first; the policies layer cleanly on top.

One risk worth naming: gaming via collusion. Two players could coordinate predictions to inflate their pairwise trust. Mitigation deferred — the signal is only meaningful inside teams that already have out-of-band accountability, and the consequence of inflation (agent over-weights a colluder's input) is bounded by ADR-050's per-action risk tiers. Revisit if observed.

Consequences¶

The sync_score semantics stay clean: it remains "how well your DTA knows you," not "how well your friends know you."
The agent layer gains a new input — per-pair peer-prediction accuracy — that pairs naturally with the explicit trust_edges topology already in place.
Unblocks the multiplayer / A2A governance prototype James is setting up: when profiles are mashed together as a governance algorithm, each profile's agent can weight other agents' input based on observed track record, not just self-reported trust.
New surface area to design: the SKILL.md format for exposing relational signals to Hermes (cf. the v3 response-shape work in project_agent_skill_response_shape_v3.md). Likely a small section like "relational context: you predict James correctly 75% of the time across 12 shared sessions."
Watch for: (a) agent recommendations that ignore obvious relational track record — signals we need richer aggregation (per-category, not just global); (b) collusion patterns in pairwise accuracy if external playtests start; (c) tension with the cross-profile querying / low-trust filter design when that question gets answered.

Key files: - migrations/020_peer_coherence.sql — peer_prediction_edges table; source data already directional with was_correct - migrations/021_trust_topology.sql — trust_edges + delegation_preferences; complements the new signal - src/app/api/sessions/complete/route.ts (lines 128–160) — where was_correct is filled and per-session readability is computed; the aggregator likely lives near here - src/lib/sync/multi-dimensional-score.ts — explicitly not modified; 5th dimension stays at weight 0.0 - docs/decisions/002-ai-only-sync-scoring.md — the precedent this ADR is careful not to overturn - docs/decisions/050-agent-permission-tiers.md — downstream consumer of the relational signal once policies attach