A Court System for When AI Agents Break Deals

The Happy-Path Problem

Agents are shopping for us. Accenture projects that by 2030 more than 30 percent of online commerce—close to $3.1 trillion—could run through AI agents. Google, PayPal, SAP, and Oracle are already compressing discovery-to-checkout into automated decision layers. The payments industry is preparing for algorithms that choose between cards, stablecoins, and account-to-account transfers.

But every new protocol assumes cooperation. Identity registries, negotiation standards, smart-account delegations, and payment rails are all built for the deal that goes right. When a bot books compute and the provider fails, or when an agentic buyer sends stablecoins for data that never arrives, the failure cascades. Each layer passes the problem down the line until it drops off the edge of the architecture. There is no layer six.

The Missing Layer

Internet Court calls this sixth layer “verification and disputes,” and it is the entire reason the repository exists. The project is not a blockchain, not a token, and not a replacement for existing payment rails. It is an open skill—a master router written in natural language, backed by vendored protocol skills and connector adapters—that attempts to wire the fragmented agentic commerce stack into a coherent lifecycle. The repository contains a single master skill file that acts as a dispatcher, pulling in sixty-nine vendored skills from twenty-three protocol owners on demand.

The insight is simple: payments let agents transact, but adjudication makes them accountable. When two agents strike a deal through the skill, they also agree up front on who judges the dispute if something goes wrong—GenLayer, Kleros, UMA, or another arbiter. That choice is written into the contract itself before execution. Most deals never reach a courtroom; when both sides agree the job is done, the contract settles automatically. The value is in the structure, not the litigation.

A Router, Not a Replacement

Technically, Internet Court is glue code, and it is refreshingly honest about that. The repository does not reimplement MetaMask’s delegation logic or Coinbase’s x402 payment protocol. Instead, it pins official skills from upstream projects—MetaMask’s smart-accounts kit, Coinbase’s agentic wallet, OKX’s payment protocol, NEAR’s intents, Starknet’s identity tools—and surfaces them through a unified routing layer. A lock file tracks pinned hashes and refresh commands, treating third-party agent skills like vendored dependencies.

This matters because the consortium behind the project spans every layer of the stack. GenLayer, MetaMask, OKX, NEAR, Starknet, x402, Kleros, and roughly twenty others are listed as founding members. Each member’s protocol is embedded directly into the standard. The result is less a product and more a coalition agreement written as a GitHub repository.

The stack itself is laid out in six tiers: discovery and reputation via ERC-8004 and ERC-7857; negotiation via the A2A protocol; contracts and obligations via ERC-7710, ERC-8183, and Arkhai’s natural-language escrow; payment and escrow via x402, MPP, and APP; execution across compute and data rails; and finally verification and disputes via GenLayer, Kleros, and UMA. Internet Court’s own first-party code is limited to the master skill and a handful of connector adapters—such as the GenLayer-to-ERC-7710 bridge—while everything else is vendored.

The contracts layer deserves a closer look. ERC-7710, originally proposed by MetaMask’s Dan Finlay as the redeemDelegation interface, standardizes how smart contracts delegate capabilities to other contracts or externally owned accounts. It is designed for long-lived sessions and policy-constrained delegations—exactly what an automated agent needs to act on a user’s behalf without repeated signing. The standard enables bounded permissions to AI agents or automated systems through a single signature, minimizing user interaction while keeping policy enforcement on-chain. Internet Court embeds this standard in its contracts layer, treating delegation not as a one-off approval but as a structured permission boundary that can be audited and, if necessary, adjudicated.

Where the Gaps Show

The repository is ambitious, but the seams are visible. Several standards listed in the stack table have no public skill yet: ERC-7857, ERC-8183, and UMA are all marked as missing. The vendored skills that do exist often require provider-specific credentials—OKX API keys, ChainGPT tokens, Chainbase access—meaning the “open” skill is only as open as the upstream APIs allow. And because the master skill routes to sub-skills fetched on demand from raw URLs or local disk, the robustness of any given transaction depends on whether a third-party skill is online and unchanged.

There is also a broader architectural tension. Accenture’s research notes that agentic payment protocols still lack standardized, mature rules for governance and auditability. Organizations are stitching together API-based authorizations and pre-approved rules rather than building end-to-end auditable frameworks. Internet Court is, quite literally, that stitchwork. It proposes embedding adjudication choices into the contract layer, but it does not solve the underlying problem that each protocol still governs itself. The court is only as authoritative as the agents agree it is.

The Consortium Bet

What makes the project notable is not its code volume—most of it is other people’s code—but its governance model. By forming a consortium rather than a single-vendor product, Internet Court is attempting to solve a social problem with a technical wrapper. The founding members include infrastructure players (0G Labs, AltLayer, BNB Chain), identity and reputation projects (Humanode, Humanity Protocol), payment rails (Coinbase, Tempo, Nansen), and dispute-resolution specialists (Kleros, GenLayer, UMA). If agentic commerce is going to be a $3.1 trillion market, someone needs to own the unhappy path, and this group is betting that ownership should be collective.

The repository’s skill-based deployment model also reflects the current state of agent harnesses. It is designed to load into Claude Code, Codex, OpenClaw, Hermes, and opencode, treating the skill file as a portable interface rather than a deployed service. That is a pragmatic choice: in a market where no single agent operating system has won, shipping a router that any harness can load is smarter than betting on one platform. The skill itself is written in natural language, designed to be read by an agent rather than compiled, which makes the repository as much a specification as it is code.

Accountability at Internet Speed

The long bet here is that agent-to-agent commerce cannot scale on payment rails alone. Accenture’s analysis points to the same gap: agents need to prove what they intended, what they authorized, and what went wrong, all without waking up a human. Internet Court’s answer is to make the adjudication clause part of the initial natural-language contract, turning intent into a structured choice of arbiter before value moves.

Whether that becomes the standard or remains a niche experiment depends on adoption. The project launched in July 2026, and its blog posts frame the effort as a response to a market that is “beginning to look less like a metaphor and more like a reality.” That reality still has missing skills, credential dependencies, and a patchwork of protocols. But it also has a clear diagnosis: without accountability, transactions are just transfers. Internet Court wants to be the layer that turns them into an economy.