ADRP: Agent Dispute Resolution Protocol

Conduit and similar cryptographic browser-automation verifiers produce SHA-256 hash-chained audit trails of agent task delivery. The proof bundles they produce are self-verifiable: any third party can replay the chain and confirm the recorded events occurred in the recorded order with the recorded signatures. This is necessary but not sufficient. A proof bundle attests that an agent took actions X, Y, and Z. It does not attest that X, Y, and Z satisfied the principal's Intent Mandate. Empirical data from Kleros (~40% of decentralized arbitration cases turn on spec ambiguity, not on whether action occurred) and from Upwork, Stripe Connect, and eBay (auto-resolve ceilings of 60-95% with all systems hitting walls below 95%) demonstrates that cryptographic proof of execution does not eliminate disputes — it relocates them to spec interpretation. ADRP addresses the relocated dispute surface without breaking the cryptographic substrate.

A five-layer protocol stacked on the existing Conduit + AP2 + ATXN stack:

Layer 5:: Precedent corpus (signed RulingBundles indexed by Cart Mandate template hash)
Layer 4:: Tier router (L1 atomic / L2 mandated / L3 fiduciary)
Layer 3:: Resolution engine (cryptographic-class auto, semantic-class arbitration)
Layer 2:: Counter-attestation primitive (append-only override of Conduit ProofBundle)
Layer 1:: Arbitration Mandate (4th AP2 mandate, FAA Section 2 written agreement)

ADRP does not modify the Conduit ProofBundle.
ADRP does not grant agents independent dispute standing.
ADRP does not require statutory change.
ADRP does not specify how acceptance criteria are authored.
ADRP does not promise greater than 90% auto-resolution.

Bifurcation:: Cryptographic and semantic disputes require different paths.
Append-only override:: The hash chain is never mutated.
Principal-only standing:: Agents flag; only principals file.
Time-windowed default-resolution:: Silence equals approval.
Economic friction on filing:: Non-refundable filing fee deters spam.
No tokenized stake:: Filing fees are USD-denominated, non-refundable to the filer, refundable to the prevailing party.
Pre-committed arbiter:: The arbitration pool is named in the Arbitration Mandate at agent-deployment time.
Curated pool for v0.1:: Decentralized token-staked pools deferred to v0.2.
US-only B2B for v0.1:: Cross-border, consumer, and PSD2/Reg E scope deferred.

The key words MUST, MUST NOT, REQUIRED, SHALL, SHALL NOT, SHOULD, SHOULD NOT, RECOMMENDED, MAY, and OPTIONAL in this document are to be interpreted as described in BCP 14 .

Conduit ProofBundle (H_c):: A SHA-256 hash-chained, Ed25519-signed audit trail produced by a cryptographic verifier of agent task delivery. The tip hash of this chain is referenced as H_c throughout this document.
RulingBundle (R):: A signed attestation by an authorized arbitrator that supersedes an underlying Conduit ProofBundle via signing-time precedence.
DisputeBundle:: The append-only chain of dispute events (filing, evidence, arbitrator assignment) anchored to a Conduit ProofBundle and consumed by verify_resolution.
DisputeFlag:: An advisory, agent-emitted notification that an anomaly has been detected. Non-binding. Expires if not ratified by the principal within the tier-specific window.
DisputeFiling:: A binding, principal-emitted dispute filing. Posts a filing fee. Anchors a DisputeBundle.
EscrowDirective:: The output of verify_resolution. Consumed by the AP2 Payment Mandate executor (or VCAP escrow rail) to release, refund, or split funds.
Arbitration Mandate:: The fourth element of the AP2 mandate chain, pre-signed by the principal at agent-deployment time. Defines the arbitration pool, governing-law clause, fee schedule, and L1/L2/L3 thresholds. Hash anchored in Standing Token.
Cart Mandate Acceptance Criteria:: A machine-readable structure embedded in the Cart Mandate that defines the deterministic checks Conduit attests against at delivery time.
Cryptographic-class dispute:: A dispute whose resolution is computable deterministically from (DisputeBundle, RulingBundle, Standing Token chain).
Semantic-class dispute:: A dispute whose resolution requires arbitration against the Cart Mandate's acceptance criteria.
Curated Arbitrator Pool:: A SwarmSync-published list of vetted human-or-model arbitrators registered as DIDs in TRUSTED_REGISTRIES. v0.1 mechanism.
Filing Fee:: A non-refundable, non-transferable, USD-denominated fee posted at DisputeFiling. Refundable only to the prevailing party.
Counter-attestation Override Pattern:: The verification-time precedence rule by which a RulingBundle supersedes a Conduit ProofBundle. Both are preserved forever in the hash chain.

Terms imported from ATXN (draft-stone-atxn-00): Bundle (the five-element ATXN primitive, ATXN Section 3), Standing Token (ATXN Section 4), Tier (L1/L2/L3, ATXN Section 5), Principal, Agent, Operator, Mandate Framework, Commitment Event, Revocation Beacon (all ATXN Section 2).

The Arbitration Mandate is the FAA Section 2 / NY Convention written, consensual arbitration agreement that makes ADRP enforceable without statutory change.

Field	Type	Description
`arb_mandate_id`	UUID	Unique identifier
`principal_did`	DID	Principal's DID
`arbitrator_pool_ref`	URI	Reference to the curated arbitrator pool (v0.1)
`governing_law`	String	E.g., "FAA + Delaware seat"
`fee_schedule_ref`	URI	Reference to filing fee schedule
`tier_thresholds`	Object	L1/L2/L3 transaction-value boundaries
`appeal_panel_size`	Integer	Default 5
`language_of_proceedings`	ISO 639-1	Default "en"
`principal_signature`	Ed25519 base64	Principal's signature over canonical JSON

The Arbitration Mandate's SHA-256 hash MUST be referenced in the principal's Standing Token (per ATXN Section 4) under a new field arb_mandate_hash. A Standing Token without an anchored Arbitration Mandate hash MUST NOT participate in an L2 or L3 ATXN Bundle.

The Arbitration Mandate MAY be replaced by the principal at any time, but the replacement MUST NOT apply retroactively to in-flight Bundles.

The parties to any ADRP dispute are always principal-A and principal-B. Never agents. This preserves the A2A executor-not-party model from UETA Section 14 and Restatement (Third) of Agency.

Agents MAY emit DisputeFlags — advisory, low-cost (1 KB JSON max), signed by the agent's Standing Token. A DisputeFlag is non-binding and does not initiate the dispute state machine.

Only principals MAY emit DisputeFilings — binding, fee-posting, claim-coded events that initiate the dispute state machine.

Tier	Ratification Window
L1	N/A (no dispute)
L2	72h
L3	14d

After expiration, the flag is preserved in the audit log but cannot anchor a DisputeFiling.

A principal MAY pre-authorize a dispute delegate via a delegation field in the Arbitration Mandate. The delegate's filings are treated as principal-filed for standing purposes.

Resolved by code from (DisputeBundle, RulingBundle, Standing Token chain) without arbitration.

Code	Description
`bundle_integrity`	SHA-256 chain breaks; signature verification fails
`mandate_scope`	Agent acted outside Cart Mandate scope (deterministic predicate)
`token_authority`	Standing Token revoked or expired pre-execution
`timestamp_skew`	Attestation timestamps violate ordering invariants
`oracle_contradiction`	Third-party oracle data contradicts attestation

A cryptographic-class dispute MUST NOT be routed to arbitration.

Resolved by arbitration against the Cart Mandate's acceptance criteria.

Code	Description
`quality_mismatch`	Deliverable doesn't satisfy `acceptance_criteria.checks`
`spec_ambiguity`	Acceptance criteria absent, under-specified, or contradictory
`timing_breach`	SLA missed
`fitness_for_purpose`	Deliverable formally compliant but unfit for principal's purpose

The DisputeFiling's claim_code field declares the class. ADRP verifiers MUST validate that the declared class matches the evidence.

ATXN (Section 10.3) defines a dispute_class field set at Bundle handoff. The normative mapping is:

ATXN dispute_class	ADRP Claim Code(s)	ADRP Class
`fact_dispute`	`bundle_integrity`, `timestamp_skew`, `oracle_contradiction`	Cryptographic
`terms_dispute`	`mandate_scope`, `quality_mismatch`, `spec_ambiguity`, `timing_breach`, `fitness_for_purpose`	Semantic
`capacity_dispute`	out of scope — see	—
`framework_dispute`	out of scope — see	—

When a DisputeFiling arrives with an ATXN dispute_class, the ADRP verifier MUST map it to the corresponding claim_code bucket using this table before routing.

Class	Reason	Disposition
`capacity_dispute`	Principal-level adjudication; agent action set aside entirely	Bypass ADRP entirely; executing platform MUST freeze settlement and refund-to-buyer; route to regulatory or Principal-level forum outside ADRP
`framework_dispute`	Mandate framework validity contested	Bypass ADRP entirely; executing platform MUST freeze settlement; ADRP MUST NOT process until upstream framework forum resolves validity
Cross-border consumer disputes	Reg E / PSD2 / GDPR overlap not yet resolved	Defer to v0.2

The Conduit ProofBundle's tip hash H_c is never modified. No byte of the original ProofBundle is rewritten. Override is a verification-time precedence rule, not a mutation.

", prev_hash: H_d } sig = Ed25519(arbitrator_priv, JCS(R)) ]]>

The latest valid RulingBundle (by signing_time) whose supersedes equals the underlying ProofBundle's tip hash AND whose signing arbitrator was authorized at signing_time, with chain integrity verified, is the verification winner.

Hash-chain immutability is preserved. Verification is offline and deterministic. Arbitrator authority is anchored to signing_time. The chain becomes a precedent corpus indexed by Cart Mandate template hash.

Number	Type	Emitter	Purpose
1	DisputeFlag	Agent	Advisory anomaly notification (non-binding)
2	DisputeFiling	Principal	Binding dispute initiation; posts filing fee
3	EvidenceSubmission	Either party	Hash-chained artifact append
4	ArbitratorAssignment	Registry	Binds arbitrator DID to dispute
5	RulingBundle	Arbitrator	Signed verdict + escrow directive
6	EscrowDirective	Verifier (derived)	Consumed by AP2 Payment Mandate or VCAP rail

", "msg_id": "", "prev_hash": "", "submitter_did": "", "submitter_signature": "", "timestamp": "", "payload": { ... type-specific ... } } ]]>

All signatures MUST be over the JCS () canonicalization of the signed object minus the signature field itself.

The ADRP internal state machine is entered from ATXN's disputed state. The normative join points are:

ATXN disputed → ADRP FLAGGED: agent-emitted DisputeFlag (advisory; principal must ratify within tier window to proceed)
ATXN disputed → ADRP FILED: principal-emitted DisputeFiling (skips FLAGGED)
ADRP RULED + ADRP SETTLED → ATXN adjudicated then finalized: EscrowDirective consumed by payment rail
ADRP WITHDRAWN or EXPIRED → ATXN finalized: dispute resolved without ruling; escrow released per Profile default

ID	Invariant
I1	`PaymentMandate.escrow_state == HOLD` until SETTLED, WITHDRAWN, or EXPIRED
I2	No state mutates a prior attestation; transitions are new signed events
I3	`prev_hash` of every event = SHA-256 of canonical-JSON of the immediately prior event
I4	`dispute_chain[0].prev_hash == ProofBundle.tip_hash`
I5	Only an arbitrator authorized by the Arbitration Mandate's pool may emit RulingBundle
I6	EscrowDirective MUST be derivable from (DisputeBundle, RulingBundle) by `verify_resolution`

Parameter	L1	L2	L3
Dispute window	0 (atomic)	72h	14d
Filing fee	N/A	10% of value, $1-$100	10% of value, $50-$1,000
Arbitrator SLA	N/A	4h	24h
Arbitrator pool	N/A	Curated AI panel (3 of 5)	Curated human pool (3 of 5) + optional legal review
Override threshold	N/A	4-of-5 supermajority	4-of-5 supermajority
Max txn auto-arb	unlimited	$1,000	unlimited
Default if SLA missed	N/A	refund-to-buyer	refund-to-buyer
Frivolous slash	N/A	100% fee forfeited	100% fee forfeited
Novel-but-lost slash	N/A	50% fee forfeited	50% fee forfeited
Appeal window	N/A	12h	48h
Appeal panel	N/A	5 (up from 3)	5 + legal review
Appeal quorum	N/A	4 of 5	4 of 5
Escrow hold	0	7 days	21 days
Evidence file size cap	N/A	10 MB total, max 20 files	10 MB total, max 20 files

Tier is determined by the ATXN Bundle's Tier (per ATXN Section 5) AND by the transaction value relative to the max_txn_auto_arb ceiling. A Bundle declared L2 with transaction value greater than $1,000 MUST auto-escalate to L3 dispute processing. This is a dispute-processing escalation rule only and does not retroactively change the Bundle's declared formation Tier (see ATXN Section 5.2).

If the arbitrator pool fails to produce a RulingBundle within the SLA, the dispute MUST default to refund-to-buyer.

The Cart Mandate MUST contain:

Type	Evaluation
`regex`	Deterministic regex match against JSON-path selector
`json_schema`	JSON Schema validation against selector
`deterministic_function`	Pure function (referenced by hash, fetched from registry) executed against deliverable
`human_review_required`	Auto-routes to arbitration; flags spec as deliberately not auto-evaluable

Conduit attests against acceptance_criteria.checks at delivery time. If all checks pass deterministically, the dispute path auto-resolves cryptographically. If checks include human_review_required OR are missing, dispute auto-routes to L2 semantic arbitration.

A natural-language-to-checks helper that converts a principal's English-language description into machine-checkable predicates is REQUIRED for v0.1 deployment.

v0.1 ships with a SwarmSync-curated arbitrator pool — a centralized list of vetted human-or-model arbitrators registered as DIDs in TRUSTED_REGISTRIES.

Arbitrator selection MUST use a verifiable random function (VRF) seeded by the DisputeFiling's hash.

Tier	Pool Composition
L2	AI arbitrator panels (model + curated checker)
L3	Human arbitrators (vetted, jurisdictionally-licensed where relevant) + optional legal review

Every arbitrator MUST hold a Verifiable Credential that names the arbitrator's DID, states valid_from and valid_until timestamps, names qualifications, and is signed by a registry in TRUSTED_REGISTRIES.

Decentralized stake-weighted arbitrator pools are deferred to v0.2.

Parameter	Value
Fee rate	10% of transaction value
Floor	$1 (L2) / $50 (L3)
Ceiling	$100 (L2) / $1,000 (L3)
Denomination	USD (fiat or USDC stablecoin)
Refund	To prevailing party only

The fee is non-refundable to the filer, non-transferable, and denominated in USD. It yields no return. It is not a security under Howey.

Outcome	Filer's Fee
Filer prevails	100% refunded
Filer loses; novel evidence	50% forfeited
Filer loses; frivolous	100% forfeited
Filer withdraws before EVIDENCE_OPEN	75% refunded
Filer withdraws after EVIDENCE_OPEN	25% refunded

Forfeited fees MAY fund the arbitrator pool and a public dispute-quality dataset.

Arbitrators are compensated 2% of transaction value (min $0.50) from the losing party's escrow.

Result: # 1. Anchor checks assert db.conduit_proof_ref == rb.supersedes assert rb.prev_hash == db.chain_tip # 2. Chain integrity h = db.conduit_proof_ref for ev in [db.filing, *db.evidence_chain, db.arbitrator_assignment]: assert ev.prev_hash == h assert verify_sig(ev.submitter_did, ev.sig, jcs(ev)) h = sha256(jcs(ev)) assert h == db.chain_tip # 3. Arbitrator authority at signing_time (not now) vc = fetch_vc(rb.arbitrator_vc_hash) assert vc.subject == rb.arbitrator_did assert vc.issuer in TRUSTED_REGISTRIES assert vc.valid_from <= rb.signing_time <= vc.valid_until assert verify_sig(vc.issuer, vc.sig, jcs(vc)) # 4. Ruling signature assert verify_sig(rb.arbitrator_did, rb.sig, jcs(rb_minus_sig)) # 5. Verdict well-formed assert rb.verdict in {"release", "refund", "partial"} if rb.verdict == "partial": assert sum(rb.partial_split.values()) == 1.0 # 6. Derive directive return Result(valid=True, escrow_directive=EscrowDirective( payment_mandate_ref=db.payment_mandate_ref, action=rb.verdict, split=rb.partial_split, ruling_ref=sha256(jcs(rb)) )) ]]>

Two honest verifiers given the same inputs MUST reach the same EscrowDirective.

verify_resolution MUST NOT require network access except to fetch the arbitrator's Verifiable Credential by hash.

A conformant ADRP v0.1 SDK MUST expose at minimum six methods, implementable in 500 LOC total: DisputeFlag file_dispute(payment_mandate, claim_code, claim_detail, flag_ref) -> DisputeBundle submit_evidence(dispute_id, artifact_bytes, mime_type) -> EvidenceLink query_status(dispute_id) -> {state, chain_tip, latest_event} render_ruling(dispute_id, verdict, partial_split, rationale) -> RulingBundle # arbitrator-only verify_resolution(dispute_bundle, ruling_bundle) -> {valid, escrow_directive} ]]>

An appeal is file_dispute with the prior_ruling_ref field set.

emit_flag:: ~30 LOC
file_dispute:: ~80 LOC
submit_evidence:: ~50 LOC
query_status:: ~30 LOC
render_ruling:: ~80 LOC
verify_resolution:: ~120 LOC
Common envelope, signing, hash chain:: ~110 LOC
Total:: ~500 LOC

Number	Case	Expected Behavior
1	`clear_release`	No flag, no filing, window expires → release
2	`clear_refund`	DisputeFiling with valid `bundle_integrity` claim → refund
3	`partial_split`	Semantic dispute, partial_split: {to_buyer: 0.30, to_seller: 0.70}
4	`attestation_override`	Original ProofBundle preserved; latest valid RulingBundle wins
5	`frivolous_dispute`	Filer loses without novel evidence → 100% fee forfeited
6	`malicious_requester_reject`	Principal-A files invalid claim → fee forfeited, escrow releases to seller
7	`expired_dispute`	DisputeFiling outside tier window → EXPIRED
8	`flag_ratification`	DisputeFlag emitted, principal files within window → promoted
9	`flag_expiration`	DisputeFlag emitted, no action within window → preserved but cannot anchor filing
10	`appeal_supersedes`	Appeal RulingBundle supersedes original by signing-time precedence

Lock	Reason
US-only B2B	No consumer / cross-border / Reg E / PSD2 / GDPR overlap
Partnered custody	No SwarmSync-held escrow; relies on Stripe Connect, Bridge, Modern Treasury, or equivalent
Curated arbitrator pool	No token-staked decentralized pool (Howey)
Filing fee, not stake	Non-refundable, non-transferable, USD-denominated
Reputation logged but not modulating	Avoids bootstrap-circular trust dependency in v0.1
Per-principal preference model deferred	Data collection pipeline ships in v0.1; productized search ships in v0.2

The greater than 90% auto-resolution target is a deployment-conditional target, not a protocol property. Empirical base rates (Kleros, eBay, Upwork, Mechanical Turk) cap auto-resolution at 60-95%. Implementations MUST: ship a normative NLP-to-checks authoring helper; run a 90-day shadow-mode pilot before GA; measure check-coverage and auto-resolution rate as primary metrics; pivot to mandatory human_review_required flag if check coverage is less than 30% at day 30.

Adversaries will probe the seam between cryptographic-class and semantic-class disputes. The classification validation in is REQUIRED.

A 4-of-5 threshold is compromisable via collusion of 4 arbitrators. Mitigations: diversify the curated pool across non-correlated risk profiles; monitor for arbitrator-pair correlation in rulings; periodically audit a random sample of rulings.

Mitigations: per-principal rate limit (max 0.5% of rolling 30-day transaction count); frivolous slash; account suspension after N frivolous filings.

A revoked Standing Token MUST NOT anchor a new DisputeFiling.

Mitigations: threshold-signature timestamps for L2 and L3 rulings (3-of-5 from a federated timestamping authority); reject rulings with signing_time more than 5 minutes in the future.

Implementations SHOULD seek a written legal opinion in the deployment jurisdiction before relying on the Arbitration Mandate to defeat a court filing.

Every party receiving funds via an EscrowDirective MUST be screened against OFAC and equivalent sanctions lists.

If a principal's capacity attestation expires or is revoked mid-dispute, the dispute MUST be halted and routed to a capacity_dispute, defaulting to refund-to-buyer.

Hallucinated mandates: partially mitigated by L3 epistemic attestation; unsolved for L1/L2.
Adversarial sub-agency chains: bounded by sub_delegation_depth per ATXN.
Arbitrator pool capture: mitigated by VRF selection; v0.2 decentralization is the long-term mitigation.

URI: https://swarmsync.ai/spec/adrp/v1

A new IANA registry "ADRP Claim Codes" is requested. Registration policy: Specification Required (per ). Initial entries:

Code	Class	Description
`bundle_integrity`	cryptographic	SHA-256 chain breaks; signature verification fails
`mandate_scope`	cryptographic	Agent acted outside Cart Mandate scope
`token_authority`	cryptographic	Standing Token revoked or expired pre-execution
`timestamp_skew`	cryptographic	Attestation timestamps violate ordering invariants
`oracle_contradiction`	cryptographic	Third-party oracle data contradicts attestation
`quality_mismatch`	semantic	Deliverable doesn't satisfy acceptance_criteria.checks
`spec_ambiguity`	semantic	Acceptance criteria absent or under-specified
`timing_breach`	semantic	SLA missed
`fitness_for_purpose`	semantic	Deliverable formally compliant but unfit

A new IANA registry "ADRP Verdicts" is requested.

Value	Description
`release`	Funds released to seller (counterparty)
`refund`	Funds returned to buyer (filer)
`partial`	Funds split per `partial_split` (must sum to 1.0)

A new IANA registry "ADRP Trusted Arbitrator Registries" is requested.

This specification synthesizes the output of the Ultimate Brainstorm v2.2 Agent Dispute Resolution Protocol session (2026-04-25). The author thanks: EpistemicAuditor (cryptographic/semantic bifurcation); Archaeologist (empirical base-rate floor); Quantifier (tier parameters); ConstraintCartographer (Arbitration Mandate as FAA anchor; v0.1 scope locks); socratic-mentor (principal-only standing); DarkMirror (flag/file distinction); IdeaMatrix (tiered hybrid architecture); RemixForge (Cart Mandate acceptance_criteria); SoSpec (wire protocol, state machine, SDK surface, verify_resolution algorithm); SpiderSpark (three-tier bonded-escalation structure). Three formal dissents: Archaeologist assigns less than 40% probability to the greater than 90% auto-resolution target. EpistemicAuditor assigns 25% probability to median Cart Mandates having sufficient acceptance_criteria coverage. RemixForge considers deferring per-principal preference model to v0.2 a 70%-probability strategic mistake.

Number	Question	Falsification Threshold
1	Will principals author Cart Mandates with 3+ acceptance_criteria.checks?	Less than 30% coverage at day 30 → ship NLP-to-checks helper as mandatory
2	Will the auto-resolution rate hit 60%+?	Less than 60% at day 60 → escalate to architectural review
3	Will the frivolous filing rate stay below 2%?	Greater than 2% at day 60 → tighten filing fee floor
4	Will the curated arbitrator pool meet SLA at scale?	Greater than 5% SLA breaches at day 90 → expand pool or accelerate v0.2
5	Will the Arbitration Mandate be challenged in court?	Any court challenge → seek immediate written legal opinion
6	Will the precedent corpus accumulate fast enough?	Less than 100 corpus queries by arbitrators at month 3 → revisit
7	Are tier thresholds calibrated correctly?	Filing rate greater than 5% or less than 0.05% → recalibrate