Why build another legal language?
The rules-as-code field has fifty years of history and zero billion-dollar companies. Every previous attempt hit the same wall: the world keeps speaking in prose. Nomos's thesis is that LLMs change what's possible — but only if you put them at the edge, not the center.
Legal reasoning is already a computation.
Statutes define predicates. Facts are inputs. Precedent is a priority ordering. Reforms are temporal updates. Judges have been running this computation for two thousand years. Logic programming — Prolog, Datalog — formalized it in the 1970s, and Kowalski et al. proved its limits when they encoded the British Nationality Act in 1981.
The formalization worked. The bottleneck wasn't the logic. The bottleneck was getting unstructured prose — contracts, regulations, case law, emails — into structured rules at scale. Armies of paralegals couldn't do it economically. That's why rules-as-code never moved from academia to industry.
LLMs changed what's possible. But they're the wrong center.
LLMs can read a contract and produce structured data. That changes the economics of rules-as-code overnight — the paralegal army is replaced by an API call. But this doesn't mean LLMs should be the reasoning engine.
A legal verdict that came from "an LLM thought it should" is worthless in court, in procurement, in audit. Regulated industries need a deterministic chain back to statutes. Probabilistic at the edges, deterministic in the middle — that's the shape law has always had, and it's the shape Nomos enforces.
LLMs are not the programming language. They are one primitive inside the language — a typed bridge from prose to structure, sitting at the edge, under the compiler's supervision.
Four first-class primitives nothing else has together.
extract<Party>(pdf) using llm(...) verified_by human if confidence < 0.95
is a language-level construct, not library plumbing. The compiler derives a
JSON schema from the target type, routes low-confidence extractions to a
human queue, and carries the model + confidence + latency through the proof
tree. Catala, OpenFisca, Blawx — none have this.
A rule declares @ FR from 2016-08-10. A query runs
as of 2015-01-01 and the compiler refuses to apply the
post-reform rule to the pre-reform fact. No if (date >= …)
boilerplate. Temporal correctness is a type-system property.
Legal rules contradict each other. A non-compete is enforceable under labour law unless consumer law kicks in. Specific beats general. Later beats earlier. Higher court beats lower. Classical logic can't express this; defeasible logic can. Nomos's solver applies priority, specificity, and recency, and tells you which rule defeated which.
Every value carries its proof: the authorities (statute articles, case numbers), the facts that fed each requirement, the as-of date, the defeated alternatives. Ask the verdict why and you get a tree back to statutes. No hallucinations, no vibes.
Not from scratch. A layer.
Building a legal DSL in 2026 without studying Catala (Inria), OpenFisca, Blawx, Kowalski, Logical English, and LegalRuleML would be arrogant and slow. Building one from scratch when Eyecite, Concerto, Akoma Ntoso, CUAD, MAUD, and ACORD already exist would be worse.
Nomos is ~15% new code. The rest is borrowed, cited, and extended. The thesis is not "we invented this" — it's "we're the first to combine these four primitives, inside a modern developer experience, sitting on top of fifty years of OSS."
See /research/prior-art for the full table of what we borrow and what we leave.
What Nomos is not.
— Nomos is not a law firm, a legal advice engine, or a replacement for counsel.
— Nomos is not a universal encoder of law. It encodes the rules you write. Garbage in, garbage out.
— Nomos is not production-ready. This is v0. Breaking changes expected.
— Nomos is not a company. It is a side project, built in public, Apache-2.0.
If the claims above are wrong, the whole project is wrong. That's the point of writing them down.