Precedent

Case law for your codebase. Decision records are immutable, so later decisions quietly overrule parts of earlier ones while the old header still says Accepted. Precedent reads that prose once, builds the citation graph in Relate, and tells you — and your coding agent — which clauses are still good law.

▶ Try it in your browser  ·  Demo video (1:33)  ·  Method  ·  Evaluation  ·  Agent integration

Everything in that screenshot is answered by Relate compiled to WebAssembly, running in the browser tab — no server.

Use case

Teams (and agents) increasingly steer software with decision records: ADRs, RFCs, specs. The records are write-once, so a change of mind is a new record that says, in a sentence somewhere inside it, "§4 is superseded". Nothing updates the old one. A reader — human or LLM — who opens the original acts on dead clauses.

We ran Precedent on the real, public decision log of Relate itself — 533 ADRs in relatedb/relate:

Which relationships matter? treatments — "A supersedes §4 of B", "C reverses A", "D withdraws part of E" — and the citations and code paths around them. That is a graph, and "is this still good law?" is a question about walking it.

Related MCP server: ratchet-mcp

What Precedent does

Try it

No install — open the explorer: search any decision to see which clauses still hold and who overruled the rest, browse all 533, or see the whole network. The Query tab runs your own Cypher on the same graph.

CLI (Python ≥ 3.10; uv recommended). The store is already in the repo — nothing to build, no keys, no network:

git clone https://github.com/ZNLong2203/precedent && cd precedent
uv sync
uv run precedent demo                       # 20-second tour
uv run precedent status ADR-0116            # clause-level standing + the quoted evidence
uv run precedent preflight "add support for creating and switching between multiple databases"
uv run precedent overlaps "Allow creating and dropping databases instead of three fixed namespaces"   # before you write a decision
uv run precedent fix-status --limit 5       # which headers still say Accepted, and what they should say (--diff for a patch)
uv run precedent cite-check                 # 300+ structural findings, grouped
uv run precedent propose examples/proposal-multi-tenant.json    # what-if: dry run of a draft ADR

Inspect the raw Relate store with the stock relate CLI (read-only, so git stays clean):

curl -sSfL https://relatedb.ai/install.sh | bash
relate -d data/relate-adr.rl --read-only "MATCH (d:Decision) WHERE d.status = 'accepted' AND d.standing = 'partial'
  RETURN d.id, d.title, d.out_clauses ORDER BY size(d.out_clauses) DESC LIMIT 10"
relate serve --database data/relate-adr.rl --read-only --bolt 7687 --http 7474 --mcp 7475 --auth none   # Bolt: the official Neo4j driver connects (examples/bolt_driver.py)

With your coding agent — the repo ships a project‑scoped .mcp.json and a Claude Code skill. Open the repo in Claude Code, approve the precedent server, and ask: "Add support for multiple databases to Relate — what do I have to respect?" → what the agent sees.

How it uses Relate

• Mode: single file (data/relate-adr.rl, 17 MB, committed).

• Why this mode:

  • Not :memory: — judges must be able to open the graph, and the standing it holds is the product.

  • Not a directory — one file is the unit of sharing, of git history, and of forking: a .rl bundle copy is a complete, writable fork of the graph, which is how the guard simulates a draft against a read‑only store without touching it.

  • The stock relate CLI and relate serve (Bolt/HTTP/MCP) open the committed file as‑is, and the official Neo4j Python driver queries it over Bolt (examples/bolt_driver.py, tested with driver 6.4.1).

• What the graph models — decisions as cases, clauses as holdings, treatments as how later cases treat them:

graph LR
  D((Decision)) -- HAS_CLAUSE --> C((Clause))
  D -- "CITES {section, clauses, evidence}" --> E((Decision))
  D -- "SUPERSEDES · REVERSES · WITHDRAWS<br/>AMENDS · REINSTATES · AFFIRMS<br/>{scope, clauses, evidence, rule, confidence, effective}" --> E
  D -- "REFERS_TO {section}" --> P((CodePath))
  D -- "SIMILAR {score, cited}" --> E

533 Decision, 1 591 Clause, 697 CodePath nodes; 3 741 CITES, 362 treatment edges, 2 548 SIMILAR. standing, out_clauses and controlled_by are derived by standing.py and written back, so plain Cypher answers "what is still good law?".

Setup and run

Prerequisites: Python 3.10+, uv (or pip install -e .). Optional: the relate CLI and Node (only to re‑vendor the WASM bundle).

uv sync --extra dev          # install
uv run pytest                # 72 tests, a few seconds (real Relate store, real MCP calls, 31 real ADRs)
uv run precedent --help

To build a store for your own decision records (NNNN-title.md, ADR style):

uv run precedent index /path/to/repo --adr-dir docs/adr --out my.rl --name my/repo
uv run precedent cite-check --store my.rl
uv run precedent mcp --store my.rl            # serve the tools to an agent (stdio)

Reproduce the committed store and every number in the docs from the pinned upstream commit: make data eval (clones relatedb/relate at 1ebb65e).

Where the data lives

How well does it work?

Full numbers and caveats in docs/evaluation.md. Headlines:

• Precision of the 178 negative treatments (every one read against its evidence): 176 correct, 1 plausible, 1 wrong — but the rules were tuned on this audit; held‑out precision is unmeasured.

• Agent behaviour (24 tasks, 3 runs each, a model with no tools): relied on an overruled clause in 46 of 72 runs with the documents alone, 48 of 72 with a generic warning, 3 of 72 with preflight. The tasks were chosen where such a clause exists, only what the model says it relies on was scored, and the one residual miss is a decision preflight did not surface — see §8.

• Recall of explicit overruling statements ≈ 91–97 % on a held‑out sample (statements phrased without any trigger word are invisible to that estimate).

• 0 of 184 dated treatments are temporally impossible (actor older than target).

• Latency on the real graph: status 0.35 ms, hybrid search / preflight ≈ 45 ms (p50).

Limitations (honest list)

• Rule‑based extraction tuned on one corpus (Relate's ADRs, written in a very regular style). Other styles will extract less; the evidence‑on‑every‑edge design makes errors cheap to spot. No LLM is used at runtime.

• Clause granularity needs numbered clauses in ## Decision; otherwise supersession is tracked as "a part of it".

• Relate is single‑process and keeps the graph in RAM: one writer at a time (readers are fine), working set must fit in memory — a non‑issue for decision records.

• The corpus never contains an overruling that is itself fully overruled, so the restoration path of the standing engine is covered by unit tests, not by the demo data.

• The browser explorer is a sandbox copy; edits there never leave the tab.

Where models are involved

The shipped product makes no model calls. Two places involve a model: the gold audit labels were produced by an AI assistant rather than a human (see data/gold/README.md), and the evaluation calls one: scripts/agent_eval.py run feeds prompts to Claude Sonnet 5.5 through the claude CLI as the model under test (prompts, raw answers and per-call metadata are committed in data/agent-eval/).

License and attribution

Apache‑2.0 (LICENSE). The decision records analysed are © Neo4j, Inc. and contributors, Apache‑2.0, from relatedb/relate; see NOTICE. Vendored: @relate/relate-wasm (Apache‑2.0), force-graph (MIT). Relate and Neo4j are trademarks of Neo4j, Inc.; this project is not endorsed by Neo4j.