Code Tribunal — The court for AI-generated code

Did the code build what the ticket asked for?

Linters check style. Tests check behavior. The Tribunal checks intent — seven agents cross-examine every diff against the ticket and stamp a verdict.

See the court rule →Get early access

CLI · MCP · Web — free-tier LLMs, bring your own keys

The Gap

AI writes the code. Nothing checks the ticket.

eslint --fix

Linters check style

Semicolons, imports, naming. The surface of the code — never what it was supposed to do.

pytest -q · 42 passed

Tests check behavior

They prove the code does what the code says. Not what the ticket asked for.

the blind spot

Nobody checks intent

The ticket said rate-limit login. The diff added logging. Both pass CI.

The Tribunal reads the ticket, cross-examines the diff, and rules.

Meet the Court

Seven agents. One verdict.

CLERK

“The Conductor”

Orchestrator

Runs the room with zero drama. Calls exactly the witnesses the case needs.

“Chamber's open. Let's hear it.”

ADVOCATE

“The Literalist”

Intent Witness

Holds everyone to the receipts. If you asked for five things, all five get counted.

“You asked for five things. I'm counting all five.”

SURVEYOR

“The Cartographer”

Implementation Witness

No opinions, just terrain. Reports exactly what the code does.

“Here's what the code really does.”

GHOST

“The Negative Space”

Omission Auditor

Hunts the gaps everyone else scrolls past. Sees what isn't there.

“You forgot something. I can feel it.”

DRIFT

“The Tripwire”

Scope Auditor

Catches the sneaky extras nobody approved. Trusts nothing on sight.

“Who authorized this?”

WARDEN

“The Bouncer”

Constraint Witnessrecruited mid-trial

Only appears when something's on the line — and never blinks.

“Not on my watch.”

ARBITER

“The Gavel”

Judge

Hears it all, then decides. The trust score is not a negotiation.

“The chamber has decided.”

How a Trial Runs

Ticket in. Cross-examination. Verdict out.

CLERK
Files the case, summons the court.
Orchestrator
ADVOCATE
Turns the ticket into hard requirements.
Intent Witness
SURVEYOR
Maps what the diff actually shipped.
Implementation Witness
GHOST
Finds what was asked but never written.
Omission Auditor
DRIFT
Flags changes nobody authorized.
Scope Auditor
WARDEN ?
Recruited when auth or payments appear.
conditionalConstraint Witness
ARBITER
Weighs every witness. Issues the ruling.
Judge

Deterministic scoring — 100 minus earned deductions. Same inputs, same verdict.

Exhibit — mock trial

Watch a verdict land

A real docket, scripted — no API calls.

DocketLOGIN-482 · 4 requirements

Add rate limiting to the login endpoint

·
Throttle failed attempts per IP (5 / 15 min)
under examination…
·
Return HTTP 429 with Retry-After header
under examination…
·
Window configurable via settings flag
under examination…
·
Persist lockout counter across restarts
under examination…

Verdictcourt in session…

Run it on your own PRs →

Ship It Into Your Agent

Free · BYO keys

The court travels. Install it where your agent works.

The CLI and MCP server run today, free, with your own keys — install them from the repo below. The PyPI release and the hosted court land together — join the waitlist to hear the day they ship.

uvx --from "git+https://github.com/arun3676/code-tribunal.git#subdirectory=apps/api" tribunal-mcp

One command, works today — straight from the repo, no clone. Runs in Claude Code, Cursor, Codex, OpenClaw, Hermes; bring your own free Groq/Cerebras/Gemini keys. The short uvx --from code-tribunal form lands with the PyPI release.

The same intent-conformance court that runs in this browser ships as a CLI and an MCP server. Both OpenClaw and Hermes are MCP clients — so an agent can ask “does this diff match the ticket?” and loop on BLOCK before a human ever sees it.

tribunal init <agent>

CLI

Shell · CI

Gate any PR from your terminal or pipeline. Exit 0 = clear to merge, 1 = blocked — drop it straight into CI. Bring any of Groq / Cerebras / Gemini — free tiers.

gate a PR, exit-code only

tribunal verify --ticket ticket.md --git --quiet || exit 1

Check your keys first: tribunal doctor

MCP server

Any MCP client

One server, every MCP-native agent. Registers verify / ghost / drift as tools your agent calls mid-task. Groq is just the default key — tribunal init accepts --cerebras-key / --gemini-key too.

Claude Code · Cursor (mcpServers) — via tribunal init claude

{
  "mcpServers": {
    "tribunal": {
      "command": "uvx",
      "args": [
        "--from",
        "git+https://github.com/arun3676/code-tribunal.git#subdirectory=apps/api",
        "tribunal-mcp"
      ],
      "env": { "GROQ_API_KEY": "<your-key>" }
    }
  }
}

Shortens to --from code-tribunal once the PyPI release lands

OpenClaw

Self-hosted gateway

Add the gate to your OpenClaw agent and post verdicts straight back into the Discord / Slack thread the ticket came from.

openclaw mcp add

openclaw mcp add tribunal \
  --command uvx \
  --arg --from \
  --arg "git+https://github.com/arun3676/code-tribunal.git#subdirectory=apps/api" \
  --arg tribunal-mcp

Hermes

Autonomous agent

MCP plus an Open Skill that teaches the write → verify → fix loop, so the gate becomes a habit across sessions.

generate the ~/.hermes block

tribunal init hermes

Bundled Open Skill: integrations/hermes/skill

How it worksThree tools: verify_intent_conformance · ghost_check · drift_check

Coming Soon

The hosted court is next. Get on the docket.

The CLI and MCP server ship today, free, with your own keys. The hosted court — team dashboards, a PR bot, verdict history — opens invite-first. Register and your invitation lands the day it does.

We're not a model lab. We're the layer between the ticket and the diff — and because the court reasons with whatever key you bring, it gets sharper with every model upgrade. Your keys, your models, our courtroom.