Law as Code
Law that humans can examine and machines can execute.
Law as Code – internationally also known as Rules as Code – is the machine-executable representation of law: readable for humans, evaluable by machines. It ranges from the representation of a single norm to the complete examination logic and its application to the specific case. And it is a paradigm: making law digitally effective and automatable without it losing its properties.
Norm and implementation
Today, a translation lies between statute and decision.
Statutes are written as text – and then translated into systems: through interpretation, programming, configuration. Every change in the body of rules triggers a cascade of adjustments. This translation work is expensive, error-prone, and structurally always one step behind legal reality.
Code remains code.
Until now, once a rule is programmed, it exists only in the code and can no longer be read as a rule in its own right. Lawyers, legislators, and public administration can no longer examine it directly; every examination needs a technical intermediary, and with every release, what the norm was actually meant to decide can shift unnoticed. Artificial intelligence speeds up this translation. It does nothing about the break itself: with every move from norm to code, details can slip, terms can narrow, exceptions can be smoothed over. The norm and its encoding drift apart. And where systems deliver results whose path cannot be traced step by step, the result may be correct – but it cannot be justified, examined, or challenged.
The form has to deliver what the law promises.
Traceability, challengeability, and equal treatment are not features that can be retrofitted. They hold only if the form in which law is executed carries them by itself: if the examination structure of a norm is open and its wording binds every decision. The question, then, is not whether public administration gets automated, but whether this form secures the properties of law – or merely promises them.
The benchmark
Four properties decide.
A Law as Code architecture holds up if it fulfills four properties – as entry requirements, not as qualities of degree. They are the benchmark for every architecture. Including ours.
01
Externalization of the normative basis
The norm exists as an artifact in its own right – publishable, versionable, signable, regardless of where and whether it is executed.
The effect: Only an externalized norm can be examined, compared, and replaced as a whole. A new system reads the same norm – not a new one.
02
Sub-normative anchoring
Every logic component can be traced back to the individual passage of text – section, subsection, sentence, and where necessary clause.
The effect: This is binding to statute in structural form. Automated implementation stays bound to the wording, not to an interpretation that disappears into the code.
03
Deterministic evaluation
The same input always leads to the same result – the evaluation knows no chance and no hidden weighting.
The effect: Equal treatment, traceability, and challengeability presuppose reproducibility. The ten-thousandth decision follows the same criteria as the first. Where a norm requires human understanding of language, this is marked as an exception – never silently.
04
Court-proof documentation
For every automated decision, it can be documented which norm in which version was applied to which facts – and how each statutory requirement was assessed: cryptographically secured, time-stamped.
The effect: What must stand up in court needs evidence. The path of every decision remains provable even years later.
The answer
RUML holds itself to this benchmark.
The RUML format is the Institute’s answer: an open file format that makes the four properties achievable – the norm as an artifact in its own right, anchored down to the passage of text, evaluated deterministically in every conformant implementation, and documented in a court-proof manner. Both can be verified: the specification is open, and real Norm Rulemaps are available in the Rulemap Catalog.