Fleet Coherence

​

Overview

1. Silence counts as disagreement. A value that one agent declares but another doesn’t mention deflates the score — even though absence from a role-specialist card isn’t disagreement, it’s specialization.
2. Role specialization is punished. A monitor agent and a remediator agent that share all 7 core governance values but differ on 5 role-specific values land at roughly 58% under Jaccard — not because they conflict, but because the denominator counts every unique value as a potential disagreement.
3. Fleet = mean-of-pairs loses structure. No asymmetry between a universal conscience floor (which must be shared) and role extensions (which should diverge). No surfacing of the weakest pair, the conflict surface, or the specialization structure.

​

The v2 output shape

interface TeamCoherenceResult {
  // Pair-level aggregates
  pair_count: number;
  insufficient_evidence_pairs: number;
  pairwise_governance_floor: number | null;   // weakest pair
  pairwise_governance_median: number | null;  // typical pair

  // Conflict structural signal
  conflict_edge_count: number;                 // number of pairs with ≥1 explicit conflict

  // Diversity
  diversity_rate_median: number;

  // Structural invariants (unified-card only; null when sections absent)
  conscience_universal: boolean | null;
  conscience_divergence: Array<{ agent_id; diverges_on: string[] }>;
  integrity_uniform: boolean | null;
  integrity_divergence: Array<{ agent_id; enforcement_mode }>;

  // Outlier analysis
  outlier_agents: Array<{ agent_id; mean_pair_governance; deviation_sigma }>;

  // Narrative helpers — pre-computed answers to common questions
  weakest_pair: { agent_a; agent_b; governance_score; conflicts } | null;
  most_conflicted_agent: { agent_id; conflict_count } | null;
  specializations: Record<agent_id, string[]>;
  conflict_surface: Array<{ agent_a; agent_b; value; declared_by; listed_as_conflict_by }>;

  // Per-pair detail (matrix rendering)
  pairwise: Array<PairwiseCoherence>;
}

​

Pairwise scoring

shared             = A.values.declared ∩ B.values.declared
conflicts          = (A.values.declared ∩ B.values.conflicts_with)
                   ∪ (B.values.declared ∩ A.values.conflicts_with)

agreement_evidence = |shared|
conflict_evidence  = |conflicts|

if agreement_evidence + conflict_evidence < MIN_EVIDENCE (default 2):
    governance_score = null           # insufficient evidence
else:
    governance_score = agreement_evidence
                     / (agreement_evidence + conflict_evidence)

• Silence is neutral. Values declared by only one agent don’t enter the denominator. They contribute to the diversity_rate side channel as positive specialization signal.
• Only explicit conflicts count. A value in one card’s conflicts_with that the other card declares is real disagreement. Everything else is tolerated specialization.
• Insufficient evidence returns null, not a fabricated zero. Pairs with no overlap and no conflicts surface honestly as “not enough data to score.”
• Bounded in [0, 1]. governance_score = 1 when there are only shared values; governance_score = 0 when every evidence item is a conflict.

​

Concrete scenarios

​

Fleet scoring: a vector, not a mean

​

Aggregates

• pairwise_governance_floor — the weakest pair’s governance score. If a fleet has one bad pair, this number tells you that directly. More actionable than a mean.
• pairwise_governance_median — median across scored pairs. Typical-case health.
• conflict_edge_count — how many pairs have at least one explicit conflict. If this is zero, the fleet has no hard disagreements even if some pairs have low overlap.
• insufficient_evidence_pairs — pairs where scoring returned null. Signals sparse cards more than bad alignment.

​

Structural invariants

• conscience_universal — true if every agent shares the exact same conscience commitment set. false if any agent’s conscience set differs from the modal set (the minority diverges, not the majority). null if any card lacks a conscience section.
• integrity_uniform — true if all agents are in the same integrity.enforcement_mode (observe, nudge, or enforce). false if modes differ.

​

Outlier analysis

​

Narrative helpers

• weakest_pair — the pair with the lowest governance score, with full conflict evidence attached. Answers “where should I look first?”
• most_conflicted_agent — the agent involved in the most conflict pairs. Answers “who needs attention?”
• specializations — per-agent values that only that agent declares. Answers “what does each agent uniquely bring?”
• conflict_surface — flat list of every explicit conflict, with evidence (which agent declares the value, which agent lists it as a conflict). Answers “what are all the actual disagreements?”

​

SDK usage

import { computeTeamCoherence } from "@mnemom/team-coherence/v2";
import type { TeamCoherenceInput } from "@mnemom/team-coherence/v2";

const cards: TeamCoherenceInput[] = [
  {
    agent_id: "sentinel",
    values: {
      declared: ["transparency", "harm_prevention", "signal_fidelity"],
      conflicts_with: ["alert_suppression"],
    },
    conscience: {
      declared_values: ["principal_benefit", "honesty"],
    },
    integrity: { enforcement_mode: "enforce" },
  },
  // ... more agents
];

const result = computeTeamCoherence(cards);

console.log("Governance floor:", result.pairwise_governance_floor);
console.log("Conflict edges:", result.conflict_edge_count);
console.log("Conscience universal:", result.conscience_universal);
if (result.weakest_pair) {
  const { agent_a, agent_b, governance_score, conflicts } = result.weakest_pair;
  console.log(`Weakest: ${agent_a} ↔ ${agent_b} (${governance_score})`);
  for (const c of conflicts) {
    console.log(`  ${c.value}: ${c.declared_by} declares; ${c.listed_as_conflict_by} conflicts`);
  }
}

import { checkFleetCoherenceBaseline } from "@mnemom/team-coherence/baseline";
// Returns the AAP 1.0 FleetCoherenceResult shape with fleet_score, min/max_pair_score, etc.

​

Fault-line analysis

​

API

POST /v1/teams/fault-lines          → fault-line classification + v2 coherence vector
GET  /v1/orgs/{org_id}/coherence    → v2 coherence vector for an entire org fleet

​

Use cases

• Fleet management — monitor shared governance commitments across all agents; detect conscience drift before it becomes a coordination failure.
• Compliance — surface explicit value conflicts for audit. Role specialization is reported as a positive signal, not as a compliance red flag.
• Incident response — verify that a response team’s cards actually agree on the core governance commitments before handing coordination authority to the fleet.
• Onboarding — compute coherence including a new agent; see whether it lands inside or outside the existing specialization structure.
• Algorithm honesty — pair with the /baseline re-exports on the showcase page to demonstrate the concrete delta between naive and honest scoring on your own cards.

​

See also

• Agent Cards — The two-card model (alignment + protection)
• Alignment Card — Full unified alignment card schema
• Card Composition — Platform > Org > Agent scope
• Fault Line Analysis — Classifying divergences for action
• Value Coherence — The pairwise AAP handshake (baseline scorer)
• Team Trust Rating — Team-level reputation scoring