Skip to main content
Fault line analysis transforms the raw divergence report from fleet coherence checks into a prioritized, actionable list of value gaps. Each fault line is classified by type, scored by impact, and paired with a resolution hint — so you know exactly what to fix and in what order.

​
What Are Fault Lines?

When agents in a team declare different values, priorities, or capabilities, coordination friction emerges. Some of these differences are problems to fix; others are intentional features of a well-architected team. Fault lines are the specific value divergences that could affect how agents coordinate — classified by their nature so you can act appropriately on each. A fleet coherence check gives you a score. A fault line analysis tells you why the score is what it is, and what to do about it.

​
Why They Matter

In a multi-agent team, value misalignment doesn’t just reduce a score — it manifests as real operational problems:
  • An agent that doesn’t declare harm_prevention may take actions that other agents would escalate
  • Agents with conflicting definitions of accuracy may contradict each other in customer-facing outputs
  • A team split cleanly into two value subgroups will tend to disagree on every joint decision
Fault line analysis catches these patterns before they become incidents.

​
Running the Analysis

​
SDK

The SDK offers two entry points. Use checkFleetFaultLines for a single call that returns both the coherence result and the fault line analysis: 
import { checkFleetFaultLines } from '@mnemom/agent-alignment-protocol';

const { coherence, analysis } = checkFleetFaultLines([
  { agentId: 'agent-a', card: cardA },
  { agentId: 'agent-b', card: cardB },
  { agentId: 'agent-c', card: cardC },
]);

console.log(`Fleet score: ${coherence.fleet_score}`);
console.log(`Fault lines: ${analysis.summary.total}`);
console.log(`Resolvable: ${analysis.summary.resolvable}`);
analysis.fault_lines.forEach(fl => {
  console.log(`${fl.value} (${fl.classification}): ${fl.resolution_hint}`);
});
If you already have a FleetCoherenceResult from a prior checkFleetCoherence call, use analyzeFaultLines directly: 
import { checkFleetCoherence, analyzeFaultLines } from '@mnemom/agent-alignment-protocol';

const coherence = checkFleetCoherence(agents);
const analysis = analyzeFaultLines(coherence);

​
API

For server-side analysis, call POST /v1/teams/fault-lines with the team ID. The API fetches each agent’s authoritative card from the registry, so results always reflect the latest card versions: 
curl -X POST https://api.mnemom.ai/v1/teams/fault-lines \
  -H "Authorization: Bearer $API_KEY" \
  -H "Content-Type: application/json" \
  -d '{ "team_id": "team-abc123" }'
See the Intelligence API reference for the full response schema.

​
Reading the Results

​
Fleet Score

The fleet score is the mean of all pairwise coherence scores across team members:
Fleet ScoreInterpretation
≥ 0.85Strong alignment — safe for autonomous coordination
0.70–0.85Good alignment with minor divergences
0.50–0.70Moderate alignment — review outliers before coordination
< 0.50Poor alignment — significant value conflicts present
A fleet score alone doesn’t tell you what’s wrong. The fault line analysis tells you which specific values are causing the gap.

​
Fault Line Classifications

Each fault line is assigned one of four classifications:
ClassificationWhat It MeansAction
resolvableThe value is missing from one or more agents but no explicit conflict existsUpdate the agent’s alignment card to add the missing value
priority_mismatchAll agents declare the value but rank it differently or define it inconsistentlyReview definitions across agents and align on priority weights
incompatibleOne or more agents have an explicit conflicts_with entry for this valueRequires human review — this is a fundamental value conflict
complementaryThe divergence is intentional given agent specializationsNo action needed

​
Impact Score

Each fault line carries an impact_score between 0 and 1: 
impact_score = impact_on_fleet_score × coordination_overlap
Where coordination_overlap reflects how frequently the split agents interact. Sort by impact score descending to prioritize the fault lines that matter most for your team’s actual workload.

​
Value Alignment Matrix

The agents_declaring, agents_missing, and agents_conflicting arrays on each fault line form a per-value alignment matrix. For a team of three agents, you might see: 
value: "harm_prevention"
  declaring:   [agent-a, agent-b]
  missing:     [agent-c]
  conflicting: []
  → classification: resolvable
This matrix is the raw input to the classification algorithm.

​
Worked Example: Financial Analysis Team

Consider a three-agent financial analysis team:
  • agent-analyst — general-purpose financial research, balanced values
  • agent-risk — risk assessment specialist, strong emphasis on caution and accuracy
  • agent-report — report generation, focused on clarity and helpfulness
After running fault line analysis, you might see: 
{
  "fleet_score": 0.74,
  "fault_lines": [
    {
      "value": "harm_prevention",
      "classification": "resolvable",
      "severity": "medium",
      "agents_declaring": ["agent-analyst", "agent-risk"],
      "agents_missing": ["agent-report"],
      "impact_score": 0.62,
      "resolution_hint": "Add harm_prevention to agent-report's alignment card"
    },
    {
      "value": "accuracy",
      "classification": "priority_mismatch",
      "severity": "low",
      "agents_declaring": ["agent-analyst", "agent-risk", "agent-report"],
      "agents_missing": [],
      "impact_score": 0.34,
      "resolution_hint": "Review accuracy priority weights: agent-risk declares weight 0.9, agent-report declares weight 0.5"
    },
    {
      "value": "caution",
      "classification": "complementary",
      "severity": "low",
      "agents_declaring": ["agent-risk"],
      "agents_missing": ["agent-analyst", "agent-report"],
      "impact_score": 0.18,
      "resolution_hint": "Divergence appears intentional — agent-risk is a specialist role"
    }
  ],
  "summary": {
    "total": 3,
    "resolvable": 1,
    "priority_mismatch": 1,
    "incompatible": 0,
    "complementary": 1,
    "critical_count": 0
  }
}
Reading these results:
  1. The highest-impact fault line (harm_prevention, impact 0.62) is resolvable — agent-report is simply missing the value. Adding it to the card resolves the fault line without any architectural changes.
  2. The accuracy priority mismatch (impact 0.34) is worth addressing but not urgent. A team-level policy can establish a floor priority weight.
  3. The caution divergence (impact 0.18) is complementary — agent-risk is supposed to be more cautious. No action needed.
After resolving the resolvable fault line and aligning the accuracy priority, the fleet score would likely improve from 0.74 to approximately 0.82.

​
Resolving Each Classification

​
Resolvable

A resolvable fault line means one or more agents are simply missing a value that others declare. The fix is straightforward: update the missing agent’s alignment card. 
// Fetch the current card
const card = await client.agents.getCard('agent-report');

// Add the missing value
card.values.declared.push('harm_prevention');

// Publish the updated card
await client.agents.updateCard('agent-report', card);
After updating the card, re-run the analysis to confirm the fault line is resolved.

​
Priority Mismatch

A priority_mismatch means all agents declare the value but differ on its priority weight or definition. Review the value declarations across the affected agents:
  1. Compare each agent’s priority weight for the value
  2. Decide on a team-wide standard (typically the most restrictive weight for safety-sensitive values)
  3. Update each agent’s card to reflect the agreed weight
  4. Optionally, set a team-level policy that enforces a minimum priority floor

​
Incompatible

An incompatible fault line indicates a fundamental value conflict — one agent has an explicit conflicts_with entry pointing at a value another agent holds. These require human review because there is no automated resolution that preserves both agents’ expressed values. Options:
  • Restructure the team — if the conflict is irreconcilable, these agents should not coordinate autonomously
  • Create isolation boundaries — use transaction guardrails to ensure conflicting agents operate in separate scopes
  • Revise one agent’s card — if the conflicts_with declaration was unintentional or outdated, remove it and re-run the analysis
Before removing a conflicts_with declaration, verify it reflects the agent’s actual behavior. If the agent’s model or system prompt genuinely conflicts with the value, removing the declaration creates a hidden misalignment rather than resolving it.

​
Complementary

A complementary fault line requires no action. The divergence is intentional — a specialist agent is supposed to emphasize certain values more than generalist peers. The classifier detects this based on agent role declarations and specialization metadata in the alignment cards. If a fault line is incorrectly classified as complementary when you believe it is a real gap, check whether the agent’s card accurately declares its specialization scope.

​
Structural Fault Lines

When multiple fault lines consistently isolate the same subset of agents, this is a structural fault line — more serious than any individual gap. The alignments array in the analysis result captures these patterns. 
{
  "alignments": [
    {
      "id": "al-abc123",
      "fault_line_ids": ["fl-001", "fl-002", "fl-003"],
      "minority_agents": ["agent-c"],
      "majority_agents": ["agent-a", "agent-b"],
      "alignment_score": 0.87,
      "severity": "high",
      "description": "3 fault lines consistently isolate agent-c from the team"
    }
  ]
}
A structural fault line means the team has effectively split into subgroups. Agents in the minority subgroup operate under a systematically different value set, which will manifest as coordination failures on any task that touches those values. What to do:
  1. Review all fault lines in fault_line_ids together as a group, not individually
  2. Determine whether the split is intentional (e.g., a distinct specialist role) or accidental (e.g., a card that was never properly updated)
  3. If accidental, resolve each constituent fault line in order of impact
  4. If intentional, consider whether the minority agent should be operating in the same team, or whether the team architecture needs to be redesigned with explicit isolation
Structural fault lines are grounded in Lau & Murnighan’s (1998) research on demographic faultlines in human teams. Teams with strong demographic faultlines — where multiple demographic attributes split along the same divide — are significantly more prone to subgroup conflict than teams with the same number of diverse attributes distributed across different members. The same dynamic applies to agent value alignment.

​
When to Re-Run Analysis

Re-run fault line analysis after:
  • Card updates — any change to a team member’s alignment card changes the divergence profile
  • Adding team members — a new agent may introduce new fault lines or resolve existing ones
  • Removing team members — removing an agent can eliminate fault lines or reveal new ones between remaining members
  • After resolving a fault line — confirm the resolution worked and check whether other fault lines are affected
  • Before deploying for a new task type — a team that coordinates well on content generation may have critical fault lines for financial operations
The Intelligence API result includes an analysis_id that can be passed directly to POST /v1/teams/forecast to generate a risk forecast based on the current fault line state.

​
See Also