Specification Overview

The Agent Legal Context (ALC) Protocol v1.0.0-draft -- an open protocol for recording, discovering, and enforcing legal context in agentic commerce.

Version: 1.0.0-draft | Status: Draft | License: Apache 2.0

Abstract

The Agent Legal Context (ALC) Protocol is an open protocol for recording, discovering, and enforcing legal context in agentic commerce. It provides the missing legal layer -- terms publication, acceptance, negotiation, agreement records, and dispute resolution -- for machine-to-machine transactions conducted over existing agentic commerce protocols.

The protocol defines:

A discovery mechanism (/.well-known/legal-context.json) for advertising legal context availability
An API specification for terms retrieval, verification, acceptance, and dispute resolution
On-chain primitives for tamper-evident agreement records
Integration patterns for embedding legal context into existing commerce protocols
A graduated adoption model requiring no changes to existing protocol specifications

Scope

This specification covers:

Discovery of legal context via well-known URI
API for terms retrieval, verification, acceptance, and disputes
On-chain record format for agreement anchoring
Integration patterns for existing commerce protocols
Three tiers of terms acceptance (implicit, explicit, negotiated)

This specification does NOT cover:

How vendors author, format, or publish their terms
Specific dispute resolution procedures (resolver-specific)
Identity verification methods (provider-specific)
Payment processing (handled by existing protocols)

Design Goals

The protocol is designed to:

Complement, not compete with existing agentic commerce protocols
Require no changes to existing protocol core specifications
Support graduated adoption from zero-effort integration to full legal infrastructure
Work across all EVM-compatible chains and settlement rails
Scale proportionally -- a $0.001 API call and a $5M contract do not need the same infrastructure
Preserve existing vendor workflows -- vendors publish terms however they choose; the protocol records proof

Architecture

The protocol operates at three layers:

APPLICATION LAYER
  AI agents, chatbots, autonomous services

COMMERCE PROTOCOL LAYER
  MPP (payments) - ACP (checkout) - UCP (consent)
  x402 (micropayments) - AP2 (authorization)

AGENT LEGAL CONTEXT (ALC) LAYER
  Discovery - Terms - Acceptance - Records
  Dispute Resolution - Compliance

SETTLEMENT LAYER
  Tempo - Base - Ethereum - Visa - Bank stablecoins

Core Flow

1. PUBLISH    Vendor creates an on-chain record with resolvers.
              Vendor publishes /.well-known/legal-context.json.

2. DISCOVER   Agent fetches legal-context.json from vendor domain.
              Agent reads contentHash and API endpoint.

3. TRANSACT   Agent includes contentHash in payment memo/metadata.
              Terms are bound to the transaction.

4. VERIFY     Any party retrieves the terms document via the API.
              Any party hashes the document and compares to contentHash.
              Match confirms authenticity.

5. RESOLVE    If dispute arises, the API provides the dispute process.
              The on-chain record is the evidence anchor.

Terminology

Term	Definition
Agent	An autonomous software system that acts on behalf of a human or organizational principal. Has no independent legal existence.
contentHash	A 32-byte SHA-256 content hash (`0x`-prefixed, 66 characters) that uniquely identifies a document. The field name follows the Integra reference implementation convention.
recordId	A unique identifier for an on-chain record. Distinct from contentHash -- the recordId identifies the relationship; the contentHash identifies a specific version of the terms.
IntegraExistence	An on-chain record proving a document existed at or before a specific timestamp. (Integra reference implementation name.)
IntegraRecord	An on-chain record wrapping an contentHash with operational metadata -- parties, resolvers, state, and timestamp. (Integra reference implementation name.)
Resolver	A smart contract or API endpoint providing a specific service for an IntegraRecord.
Tokenizer	A smart contract managing party identity and permissions, including agent authorization scope.
Principal	The human or organization on whose behalf an agent acts. Bears legal responsibility within the authorization scope.
Terms Policy	A document defining the legal boundaries of an agent's authority.

Specification Sections

Discovery -- The /.well-known/legal-context.json standard
API -- All HTTP endpoints for terms, verification, acceptance, and disputes
On-Chain Primitives -- On-chain primitives (IntegraExistence, IntegraRecord in the reference implementation) and resolver interfaces
Terms Binding -- Embedding contentHash in protocol transactions
Acceptance Tiers -- Implicit, explicit, and negotiated acceptance
Proof of Intent -- EIP-712 typed data schemas and chain of trust
Dispute Resolution -- Lifecycle state machine and agent participation
Security -- Document integrity, replay protection, and privacy