An instrument built to cite its sources.

CommonBench is built around a single, non-negotiable commitment: every authority it surfaces must be real, correctly attributed, and capable of being verified against a primary source. In legal research, a confident answer supported by an invented case is worse than no answer at all — particularly for self-represented litigants, who lack the institutional safeguards that catch such errors. Citation integrity is therefore a structural property of the platform, not an aspiration of the underlying model.

Everything else follows from that. The architecture separates the things a language model is good at — reading, summarising, explaining, drafting in a consistent register — from the things it must not be trusted to do unsupervised: deciding which authorities exist and what they say. Retrieval, verification, and synthesis are kept as distinct layers so each can be checked, constrained, and improved independently.

At the foundation is a curated corpus of decided cases and legislation drawn from official and authoritative reporters across five common law jurisdictions — the United Kingdom, Hong Kong, Singapore, Australia, and the United States. Source material is assembled from established public repositories, including BAILII, HKLII, AustLII, the Singapore eLitigation service, and CourtListener, and is cross-checked against these free public databases to confirm that a citation corresponds to a genuine, correctly reported authority.

Each entry is normalised, tagged by jurisdiction, and linked to its primary source, so any authority CommonBench relies on can be traced back to the report it came from. The corpus is treated as a controlled asset: additions are reviewed rather than scraped indiscriminately, and this verification step lets the platform distinguish authorities it can stand behind from those it cannot.

When a user poses a question, CommonBench does not ask a language model to recall relevant cases from memory. It runs the query against a dedicated retrieval layer built on full-text search with relevance ranking, supplemented by a doctrinal scoring step that weighs how closely each candidate authority matches the legal substance of the query rather than mere keyword overlap. The result is a shortlist of authorities that actually exist in the corpus and are genuinely responsive to the question.

This retrieval-first design is what makes citation integrity tractable. The model that ultimately answers the user works from a constrained set of real, retrieved authorities, and every citation it returns is checked against the corpus before it reaches the user.

CommonBench uses a layered prompt architecture that separates general legal-reasoning instructions from jurisdiction-specific and task-specific guidance. System prompts are jurisdiction-locked, so reasoning about Hong Kong civil procedure is not contaminated by United States doctrine, and the register and conventions appropriate to each jurisdiction are preserved.

The synthesis layer — the Engine of Authority — takes the retrieved authorities and the question and produces a structured, citation-anchored response: an explanation grounded in named cases and provisions, each proposition tied back to the authority that supports it. The aim is not to replace the user’s judgment but to give them a research footing they could otherwise obtain only through a law library and considerable training.

Before a response reaches the user, the authorities it relies on pass through a verification step that checks each citation against the corpus and its anchor. Authorities are surfaced with an indication of their verification status, so the user can see which propositions rest on confirmed authority and which are offered with less certainty. Where a citation cannot be confirmed, the system flags that uncertainty rather than presenting it as settled — erring, deliberately, toward hedging over false confidence.

This verification layer is the core of the product. It is the difference between a tool that sounds authoritative and one that is accountable for what it cites.

CommonBench offers tiered levels of access, scaled to the depth of research a user requires — from occasional, single-issue queries through to sustained, multi-jurisdiction work. Jurisdiction locking and the verification pipeline apply across all tiers; the tiers govern breadth and depth of use, not the standard of citation integrity, which is constant.

The platform runs on a conventional, well-understood stack — a Node.js and Express application backed by a SQLite datastore, hosted on dedicated infrastructure. Deployment is governed by automated safeguards and review gates intended to prevent unverified changes — in particular changes affecting the citation pipeline — from reaching production. The engineering posture is deliberately conservative: in a tool people may rely on for consequential decisions, predictability and safety are valued above novelty.