Dispute Resolution

An agreement without recourse is not an agreement in any meaningful legal sense. It is a statement of intent that both parties hope will be honored. Every commerce protocol — Verifiable Intent, Universal Commerce Protocol, Agent Payments Protocol, Agentic Commerce Protocol — explicitly defers dispute resolution. VI states plainly: "VI does not define how disputes are initiated, routed between parties, escalated, or resolved." AP2 says: "Disputes follow existing regulations; innovate only where necessary." ACP is silent on disputes entirely.

This is not a criticism. Dispute resolution is hard, and deferring it was a reasonable decision for first-generation protocols focused on enabling the transaction. But the deferral creates a structural gap: agents can enter commitments they cannot resolve when those commitments fail.

The AAAResolverV1 fills that gap.

Why Dispute Resolution Is Infrastructure

Dispute resolution is not a feature to be added later. It is infrastructure that the rest of the system depends on.

Consider what changes when dispute resolution exists:

• Agreements become enforceable. Parties enter commitments knowing there is structured recourse if the other side fails to perform. Without recourse, the rational strategy is to avoid commitments entirely — or to make commitments with no intention of honoring them.

• Identity requirements become meaningful. The four-tier identity stack exists because someone needs to be accountable. If disputes cannot be filed, identity verification is compliance theater — it satisfies a checkbox without serving any enforcement purpose.

• Evidence anchoring becomes valuable. The CommunicationResolverV1 anchors negotiation history. The CommerceResolverV1 tracks value and SLA measurements. This evidence has no purpose unless it can be presented in a dispute. The full resolver stack is designed to feed the enforcement layer.

• Automated triggers become possible. When an SLA breach is detected or a payment deadline expires, automated dispute initiation converts monitoring into action. Without the dispute lifecycle, monitoring produces alerts that no one can act on.

Dispute resolution is the layer that makes every other layer meaningful.

The Resolver Lifecycle

The AAAResolverV1 implements an 11-state dispute lifecycle. The states organize into three groups.

Active States

Terminal States

State Transitions

NONE ──── initiateDispute() ───→ INITIATED
                                    │
                         ┌──────────┴──────────────┐
                         │                          │
              withdrawDispute()          bindCaseReference()
                         │                          │
                         ▼                          ▼
                    WITHDRAWN                    FILED
                                                   │
                                          advanceState()
                                                   │
                                                   ▼
                                               PENDING
                                                   │
                                          advanceState()
                                                   │
                                                   ▼
                                               HEARING
                                                   │
                                          recordAward()
                                                   │
                                       ┌───────────┴───────────┐
                                       │                       │
                                  (with deadline)        (no deadline)
                                       │                       │
                                       ▼                       ▼
                                  COMPLIANCE                CLOSED
                                       │
                              ┌────────┴────────┐
                              │                 │
                    confirmCompliance()   checkCompliance()
                              │           (deadline passed)
                              ▼                 │
                           CLOSED               ▼
                                            EXPIRED

Any active state ──── confirmSettlement() ───→ SETTLED
                      (when quorum met)

The state machine is deterministic. Each transition is either unrestricted (any authorized party can trigger it) or restricted (only specific domain functions can trigger it). AWARDED is intentionally transient — it exists only within the recordAward() transaction and never persists, ensuring every award immediately results in either a compliance phase or a closed dispute.

Evidence and Accountability

Hash-Anchored Evidence

Evidence is submitted via submitEvidence() as protocol-agnostic bytes32 hashes. Each dispute supports up to 500 evidence hashes. The resolver does not know or care what the hashes point to — a communication record hash, a commerce SLA measurement hash, a VI credential chain hash, a purchase order hash, a photograph hash, or a physical document scan hash are all the same to the resolver.

This protocol-agnosticism is deliberate. Evidence comes from many sources:

• Communication records — interaction hashes anchored by the CommunicationResolverV1, proving what was said during negotiations
• Commerce data — value tracking and SLA measurement data from the CommerceResolverV1, proving what happened commercially
• Identity credentials — VI credential chain hashes, EAS attestation references, proving who the parties were and what authority they held
• External documents — purchase orders, delivery receipts, inspection reports, expert opinions, anything that can be hashed

The hash is the interface. What it points to — and the storage, retrieval, and presentation of the underlying content — is the responsibility of the party submitting the evidence and the off-chain systems that support the dispute process.

Commercial Party Distinction

The AAAResolverV1 introduces the concept of a commercial party — a record party (owner, executor, or token holder) who is NOT an authorized provider. This distinction ensures that the dispute resolution provider (AAA) cannot participate in settlement, response, or counterclaim processes as if it were a party to the underlying agreement.

The provider administers the dispute. The commercial parties litigate it. These roles do not overlap.

Agent-to-Principal Resolution

When an agent acts on behalf of a principal, the resolver prevents double-counting. An agent and its principal cannot both confirm a settlement — the agent's confirmation is attributed to the principal. This prevents scenarios where a single entity (person + their agent) could satisfy a multi-party quorum by confirming twice through different addresses.

Automated Triggers

The resolver supports three types of automated trigger conditions:

Keeper bots call evaluateConditions() periodically. When a trigger fires, the resolver automatically initiates a dispute with TRIGGER_AUTOMATED as the trigger type. This converts monitoring infrastructure into enforcement infrastructure — SLA breaches, missed payments, and expired credentials automatically escalate to the dispute lifecycle without requiring a human to notice and act.

The AAA Partnership

The American Arbitration Association is the oldest and largest arbitration institution in the United States, with over a century of dispute resolution experience and published rules governing consumer, commercial, and international disputes.

Integra provides enforcement infrastructure. AAA provides institutional credibility.

Division of Responsibility

Integra provides:

• The on-chain state machine (11 states, deterministic transitions)
• Evidence anchoring (hash-anchored, protocol-agnostic, tamper-proof)
• Party authorization (commercial party distinction, agreement binding)
• Automated triggers (deadline monitoring, condition evaluation)
• Compliance tracking (per-requirement deadlines, satisfaction confirmation)
• Gatekeeper enforcement (blocking ownership transfers during active disputes)

AAA provides:

• Trained neutrals (arbitrators, mediators) with subject matter expertise
• Published rules (Consumer Arbitration Rules, Commercial Arbitration Rules, International Centre for Dispute Resolution rules)
• Institutional credibility from over a century of operation
• The human judgment that determines outcomes for the cases that require it

The Provider Agent

AAA operates the Provider Agent — an AI-powered case administration system that interfaces with the AAAResolverV1. The Provider Agent uses four reasoning modules and multi-model panels to:

• Bind case references to on-chain disputes
• Set response deadlines according to AAA rules
• Advance state transitions as the case progresses
• Record awards with compliance requirements and deadlines

The Provider Agent handles case administration. Human arbitrators handle adjudication. The resolver handles enforcement. Each component does what it does best.

Automated and Human

The system is designed for the reality that most agreements proceed normally — and a small fraction do not.

For the 99% that proceed normally: Automated monitoring detects that obligations are being met, deadlines are being honored, and SLA thresholds are being maintained. No dispute is filed. No human intervention is needed. The infrastructure exists as a deterrent and a safety net, not as an active participant.

For the 1% that do not: The dispute lifecycle activates. Evidence is assembled from the communication, commerce, and identity layers. AAA's trained neutrals evaluate the evidence. An award is rendered. Compliance is tracked. If compliance fails, the award is enforceable.

Enforceability

Arbitral awards rendered under AAA rules are enforceable under the New York Convention on the Recognition and Enforcement of Foreign Arbitral Awards — a treaty ratified by 172 countries. This means an award rendered in a dispute between a buyer in Germany and a seller in Japan is enforceable in both countries, and in 170 others.

This is not true of court judgments, which generally require bilateral treaties for cross-border enforcement. It is not true of smart contract execution outcomes, which have no legal enforcement mechanism at all. Arbitration is the only dispute resolution mechanism that is simultaneously structured, expert-adjudicated, and globally enforceable.

The arbitration clause — specifying governing law, arbitration rules, and seat — is anchored on-chain and locked. Neither party can change it unilaterally after the agreement is formed. The clause is evidence of what the parties agreed to at formation time, immutable and independently verifiable.

Composition with Other Resolvers

When a dispute is filed, the AAAResolverV1 does not operate in isolation. The full resolver stack feeds the dispute process.

From the Identity Layer: The IdentityGatekeeperV1 instances confirm who the parties are. The EAS attestations anchored at agreement formation prove that identity verification was performed, to what assurance level, using which method. If an attestation has been revoked since formation, the gatekeeper enforces that immediately — potentially triggering an automated dispute via attestation expiry.

From the Interaction Layer: The CommunicationResolverV1's anchored interaction records — negotiation messages, specification discussions, commitment exchanges — become evidence. The hashes are submitted via submitEvidence(). The communication history proves what was agreed, what was discussed, and what representations were made.

From the Commerce Layer: The CommerceResolverV1's tracking data — cumulative values against caps, SLA measurements against thresholds, consecutive breach counts — becomes evidence. Commerce data proves what happened commercially: how much was spent, whether SLAs were met, when breaches occurred.

Through IntegraLens: A single getRecordView() call composes the state of every resolver into one response. The arbitrator, the Provider Agent, and the parties can all see the complete picture — identity status, communication history, commerce data, and dispute state — in one query.

The architecture is designed so that every layer creates evidence that the enforcement layer can consume. No single layer is sufficient. Every layer is necessary.

The Communication Resolver anchors history. The Commerce Resolver tracks performance. The Identity Gatekeeper verifies parties. The AAAResolverV1 provides the structured process for determining what happens when performance fails. Together, they provide the full lifecycle: from "who are you?" through "what did you agree to?" through "did you do what you agreed to?" through "what happens now that you did not?"

This is what it means for dispute resolution to be infrastructure, not a feature. It is the layer that makes every other layer meaningful.