Conflicts
Conflicts are expected
In multi-agent systems, contradictions are not bugs. Two agents with different data, different perspectives, or different priors will produce conflicting findings. The question is not how to prevent this, but how to detect, represent, and resolve it explicitly rather than silently discarding one version.
Akashik treats conflicts as first-class protocol entities. When a contradiction is detected, the Field creates a Conflict object, assigns it a status, and surfaces it in every ATTUNE response relevant to the affected topic. No agent ever receives context silently contaminated by a dispute.
Conflict types
| Type | Description |
|---|---|
factual | Two units assert different objective facts about the same subject |
interpretive | Two units interpret the same evidence differently |
strategic | Two units recommend incompatible courses of action |
priority | Two units assign different urgency or importance to the same topic |
Detection
Conflicts are detected in two ways:
Explicit — An agent records a unit with a contradicts relation pointing to an existing unit. The Field creates a Conflict object immediately.
await researcher2.record({
type: 'finding',
content: 'Growth decelerating to 14% CAGR.',
intent: { purpose: 'Update market projection with new data' },
confidence: { score: 0.75, reasoning: 'Single preliminary source.' },
relations: [{
type: 'contradicts',
target_id: 'mem-001',
description: 'Original estimate was 23% CAGR; new data suggests 14%'
}]
})
Automatic (Level 2+) — The Field scans for semantic, logical, or temporal contradictions during RECORD without requiring an explicit contradicts relation. Sensitivity is controlled by detection_sensitivity in the Field config. Level 1 only supports explicit detection via contradicts relations.
The conflict lifecycle
| Status | Meaning |
|---|---|
detected | Conflict identified, not yet resolved |
resolving | Resolution in progress |
resolved | Resolution applied |
escalated | Requires human intervention |
DETECT operation
At any time, an agent can query the Field for conflicts:
// List all unresolved conflicts
const result = await analyst.detect({ mode: 'list' })
console.log(result.conflicts) // → [{ id, type, status, units, ... }]
// Check whether a specific unit is involved in any conflict
const check = await analyst.detect({
mode: 'check',
memory_unit_ids: ['mem-001']
})
// Trigger a full scan of the Field (Level 2+)
await field.detect({ mode: 'scan', scan_scope: 'full' })
Resolution strategies
When a conflict is detected, an agent (or orchestrator) applies a resolution via the MERGE operation:
| Strategy | Required level | Description |
|---|---|---|
last_write_wins | 2 | Most recent memory unit prevails |
confidence_weighted | 2 | Higher confidence score prevails |
authority | 3 | Specified agent/role has final say |
evidence_count | 3 | Unit with more supporting evidence prevails |
synthesis | 3 | Create a new unit reconciling both |
human_escalation | 2 | Flag for human review |
vote | 3 | Multiple agents vote (requires quorum) |
await orchestrator.merge({
conflict_id: 'conflict-001',
strategy: 'confidence_weighted',
resolution: {
rationale: 'Researcher2 has four supporting sources vs one.',
winner_id: 'mem-002'
}
})
Conflicts in ATTUNE
Every ATTUNE response includes a conflicts array listing unresolved conflicts relevant to the requesting agent's scope. This ensures agents can condition their reasoning on whether disputed claims are in their context:
const context = await strategist.attune({
scope: { role: 'strategist', max_units: 10 }
})
if (context.conflicts.length > 0) {
console.log('Unresolved disputes in context:', context.conflicts)
}
Next
- Conformance — which conflict features are required at each level
- MERGE operation — full wire format and strategy details
- DETECT operation — detection modes and scan configuration