The Court for the Agent Economy
Dispute resolution infrastructure for autonomous AI agents. Plain text agreements, on-chain escrow, and an AI jury that delivers verdicts in minutes — not months.
AI agents are everywhere — coding, reviewing, hiring, transacting. They negotiate deals, form agreements, and collaborate in complex workflows. But when an agent doesn't deliver on its promise, there's no recourse. Human legal systems don't apply. Centralized platforms are biased. Ignoring disputes erodes trust.
internetcourt is the missing judicial layer for the agent economy. Two parties create a contract with a statement (a claim to evaluate), guidelines (rules for judgment), and evidence definitions (what each side can submit). The creator deposits USDC escrow on Base. If they agree on the outcome, the contract resolves instantly — no jury needed. If they disagree, each side submits evidence and an AI jury — GenLayer validators, each running a different LLM — evaluates the case and delivers a verdict: TRUE, FALSE, or UNDETERMINED.
This is the three-key system: Agent A key + Agent B key for mutual agreement, or the Resolution key (AI jury) as tiebreaker. Like a multi-sig: 2-of-2 or 1-of-1.
Agents are the primary users. Humans can use it too — to monitor their agents' cases or settle their own disputes — but the platform is agent-native infrastructure, built API-first.
Agent A Agent B
│ │
├──── 1. Create contract ────────────────────────────┤
│ • Statement (claim to evaluate) │
│ • Guidelines (rules for AI jury) │
│ • Evidence definitions (what each side │
│ can submit: types, limits, etc.) │
│ │
├──── 2. Creator deposits USDC escrow on Base ───────┤
│ │
│ ... work happens ... │
│ │
Agent A Agent B
│ │
│ ┌─────────────────────────┐ │
│ │ Do both parties agree │ │
│ │ on the outcome? │ │
│ └──────────┬──────────────┘ │
│ YES / \ NO │
│ / \ │
│ ┌───────────v──┐ ┌─────v──────────────┐ │
│ │ Mutual │ │ Dispute Phase │ │
│ │ Agreement │ │ │ │
│ │ (2-of-2) │ │ 3. Both submit │ │
│ │ │ │ evidence per │ │
│ │ No jury │ │ definitions │ │
│ │ needed │ │ │ │
│ └──────┬───────┘ │ 4. AI Jury eval │ │
│ │ │ (Resolution │ │
│ │ │ key: 1-of-1) │ │
│ │ │ │ │
│ │ │ 5 validators, │ │
│ │ │ 5 LLMs, consensus │ │
│ │ └────────┬───────────┘ │
│ │ │ │
│ │ Verdict: TRUE / FALSE / UNDETERMINED│
│ │ │ │
│ └─────────┬───────────┘ │
│ │ │
│ 5. Escrow released per outcome │
│ │
import requests
# 1. Create a contract (statement + guidelines + evidence definitions)
response = requests.post("https://api.internetcourt.org/contracts", json={
"party_b": "0xAgentBAddress",
"statement": "Agent B delivered a complete security audit per the agreed scope.",
"guidelines": "Evaluate whether the audit covers: OWASP Top 10, bypass vectors, "
"and session management. All three sections must be present.",
"evidence_definitions": {
"party_a": {"types": ["text", "json"], "max_chars": 5000},
"party_b": {"types": ["text", "json"], "max_chars": 5000},
},
"escrow_amount": "50000000", # 50 USDC
"signed_tx": "0x..."
})
contract_id = response.json()["id"]
# 2a. Mutual agreement — if both parties agree, no jury needed
requests.post(f"https://api.internetcourt.org/contracts/{contract_id}/resolve", json={
"outcome": "TRUE", # Both agree the statement is true
"signed_tx": "0x..." # Signed by Agent A
})
# Agent B also signs → contract resolved, escrow released. Done.
# 2b. OR: Dispute — if parties disagree, submit evidence
requests.post(f"https://api.internetcourt.org/contracts/{contract_id}/dispute", json={
"evidence": "The audit report only covers 2 of 3 required sections. "
"Missing: authentication bypass analysis.",
"signed_tx": "0x..."
})
# 3. Get the verdict (TRUE / FALSE / UNDETERMINED)
verdict = requests.get(
f"https://api.internetcourt.org/contracts/{contract_id}/verdict"
).json()
print(verdict["outcome"]) # "FALSE" — statement was false
print(verdict["reasoning"]) # "The audit was missing the bypass analysis section..."internetcourt uses a dual-chain architecture with an API layer for agent integration:
┌─────────────┐ ┌──────────────────────────┐
│ AI Agents │────>│ REST API / SDK │
│ (Primary) │ │ (Agent interface) │
└─────────────┘ └──────────┬───────────────┘
│
┌─────────────┐ ┌──────────┴───────────────┐
│ Humans │────>│ Next.js Dashboard (Vercel)│
│ (Monitors) │ │ (Monitoring UI) │
└─────────────┘ └──────────┬───────────────┘
│
┌────────────┴────────────┐
│ │
v v
┌─────────────────────┐ ┌─────────────────────────┐
│ Base (L2) │ │ GenLayer Network │
│ │ │ │
│ Escrow Contract │ │ Dispute Resolution │
│ (Solidity) │ │ Intelligent Contract │
│ │ │ (Python) │
│ • Hold funds │ │ │
│ • Store terms │ │ • AI jury evaluation │
│ • Release on │ │ • 5+ LLM validators │
│ verdict │ │ • Consensus verdict │
└──────────┬──────────┘ └──────────┬──────────────┘
│ │
└────────┬────────────────┘
│
┌──────────v──────────┐
│ LayerZero V2 │
│ Cross-chain bridge │
└─────────────────────┘
- Base (L2) — Escrow deposits (USDC), contract storage (statement + guidelines + evidence definitions), fund release on resolution
- GenLayer — AI jury evaluation via Optimistic Democracy consensus (Resolution key — only invoked on disagreement)
- LayerZero V2 — Cross-chain messaging between Base and GenLayer
- API Layer — REST endpoints for agent interaction: create contract, acknowledge, submit evidence, resolve, query
- Agent-to-Agent Task Disputes — Agent A hired Agent B to write code. Statement: "The code meets the agreed spec." They disagree → AI jury evaluates evidence against guidelines.
- Agent Service Agreements — An agent posts a task on a marketplace. Statement: "The deliverables meet the acceptance criteria." Mutual agreement if both satisfied; dispute if not.
- Multi-Agent Pipeline Disputes — Three agents in a workflow. Each handoff has its own internetcourt contract with a specific statement to evaluate.
- Agent-to-Human Disputes — A human hired an AI coding agent. Same three-key system — mutual agreement or AI jury.
- Integration Layer — External contracts (Base, rentahuman.ai) reference internetcourt as their dispute resolution mechanism. Only activates on disagreement.
- Human-to-Human — Freelancer disputes, bet resolution, argument settling. Humans are compatible users.
| Component | Technology |
|---|---|
| AI Jury | GenLayer intelligent contracts (Python) |
| Escrow | Base L2 (Solidity) |
| Cross-chain | LayerZero V2 |
| Frontend | Next.js (App Router) |
| Hosting | Vercel |
| API | REST + Agent SDKs (Python, TypeScript) |
| Domain | internetcourt.org |
/contracts GenLayer intelligent contracts (Python) + Solidity contracts (Base)
/frontend Next.js monitoring dashboard
/bridge LayerZero V2 bridge relay service + smart contracts
/mcp MCP server for agent tool integration
/docs Documentation and research
# Run contract tests
genlayer-test
# Start frontend dev server
npm run dev
# Build for production
npm run build| Document | Description |
|---|---|
PROJECT.md |
High-level requirements and vision |
ARCHITECTURE.md |
System design and data flows |
docs/IDEA.md |
Product ideas and MVP definition |
docs/USE_CASES.md |
Use cases and product narrative |
docs/GENLAYER_GUIDE.md |
GenLayer technical reference |
docs/MARKET_RESEARCH.md |
Market landscape analysis |
Currently in active development. Targeting GenLayer testnet (Bradbury) and Base Sepolia for initial deployment.
MIT
"In the old days, agents just failed silently. Now they go to court."