The Grammar of Administration: Akoma Ntoso, LegalRuleML and more
Why the future of bureaucracy is not software, but law made computable
Most people think bureaucracy is made of forms, offices, and websites.
It is not.
At its core, bureaucracy is made of structured legal rules. A register entry, a permit, a tax declaration, an incorporation, a subsidy application, a nonprofit filing, a residency certificate — all of these are downstream expressions of something deeper: a legal system specifying what exists, what must be recorded, what must be proven, who is competent, and what happens next.
Once you see this clearly, a new possibility appears.
What if administration had a shared grammar?
Not a single global bureaucracy. Not one giant software platform. Not a universal state. But a common semantic infrastructure that makes it possible to describe, compare, align, and eventually interoperate between procedures across jurisdictions.
That is the idea.
And the surprising thing is: most of the pieces already exist.
The original intuition: an “Esperanto” of administration
The initial question was whether there is already something like a common conceptual language for administration — not literally a new spoken language, but a shared high-level structure beneath public procedures.
The answer is: yes, partially, but not under one single name.
What already exists is scattered across several fields:
semantic interoperability for public administration
public service vocabularies
legal document standards
evidence and criteria models
reference architectures
rules-as-code
provenance and linked data
ontology work around law and public administration
The closest institutional efforts are strongest in Europe, especially around the EU interoperability ecosystem. But they do not yet form one unified, law-first grammar of administration.
That is where the deeper question begins.
Starting from the smallest concrete case: the German e.V.
To avoid abstraction, it helps to start with something simple.
Take the most basic German eingetragener Verein — a registered association.
Legally, that status does not exist because a website says it exists. It exists because the law defines:
what an association is
when it acquires legal capacity
what must be in its statutes
how many members it needs
that it has a board
how it is registered
what the register entry must contain
That last point is especially revealing.
A provision like § 64 BGB specifies what must appear in the association register: the name, the seat, the date of the statutes, the board members, and their powers of representation.
This is already more than legal prose. It is very close to a data schema.
And once you notice that, everything changes.
Because now you can ask:
If German law decomposes an association register entry into these components, could equivalent laws in Austria, France, the Netherlands, Italy, or elsewhere be mapped to the same shared components?
And if yes, could one eventually compare national procedures not only at the level of institutions, but at the level of their legal-semantic building blocks?
That is the real ambition.
The first candidate: CPSV
A natural first place to look is the Core Public Service Vocabulary.
CPSV is one of the clearest attempts to create a common semantic model for public administration. It describes things like:
a public service
the competent authority
inputs
outputs
channels
legal resources
criteria and evidence
For many purposes, that is extremely powerful. If the goal is to describe what public administrations offer, how a service works, and what a citizen or company must provide, CPSV is excellent.
That is why it initially feels like the answer.
But it is not quite the answer.
Why CPSV is close, but not foundational
The problem is not that CPSV is wrong.
The problem is that it begins one layer too high.
A legal provision like § 64 BGB is not, fundamentally, a service. It is a normative specification of what a registry entry must contain.
In other words, it is part of the legal and semantic substrate from which services are later derived.
If you force everything into a service model, you can describe the registration procedure. You can describe the competent court, the needed evidence, the output, and so on.
But you lose the deeper structure:
which exact legal provision defines which field
whether a field is constitutive, evidentiary, declarative, or merely published
which foreign legal provisions are functionally equivalent
how one clause relates to another
how the register schema itself is grounded in law
This is the key realization:
Services are not the foundation of administration. Law is.
Services are one projection of law into practice.
That means CPSV should not be discarded. But it should not be the root ontology of a law-first system.
The decisive shift: from service-first to law-first
Once that becomes clear, the architecture changes.
Instead of asking, “Can all bureaucracy be represented as a set of services?”, the better question is:
How can legal texts be mapped into a semantic structure from which services, evidence flows, register schemas, and procedures can be derived?
That is a very different project.
It requires a stack.
Akoma Ntoso: the structure of law
The strongest candidate for the foundational legal-text layer is Akoma Ntoso.
Akoma Ntoso is not primarily an ontology of services or administrative operations. It is a standard for representing legal documents as structured machine-readable texts.
That means it captures:
acts
sections
articles
paragraphs
references
amendments
metadata
versions
lifecycle information
This matters enormously.
If the goal is to make law the foundation of administration, then the first requirement is that the law itself must be represented as a structured object rather than as inert prose.
That is what Akoma Ntoso does.
It lets you say, precisely:
this is the act
this is the section
this is the paragraph
this sentence refers to another provision
this version was amended at a certain time
That is the beginning of a computable legal substrate.
It also matters symbolically that the term Akoma Ntoso means linked hearts. The name expresses a philosophy of shared structure and mutual intelligibility — exactly the kind of ambition a universal grammar of administration requires.
LegalRuleML: the logic of law
But structured text is not enough.
A legal document is not just a document. It is also a system of norms.
That is where LegalRuleML enters.
The cleanest way to understand the distinction is this:
Akoma Ntoso models what the law says
LegalRuleML models what the law means operationally
Akoma Ntoso gives you the legal text as a structured source.
LegalRuleML gives you the ability to represent:
obligations
permissions
prohibitions
conditions
exceptions
precedence
temporal validity
jurisdictional scope
So if Akoma Ntoso tells you where § 64 BGB is and how it is structured, LegalRuleML tells you that the provision implies something like:
if an association is entered in the register, the register entry must contain certain fields
certain authorities are under an obligation to record them
those fields have a specific legal function
This is the difference between document structure and normative logic.
It is one of the most important distinctions in the whole space.
Which one is more authoritative?
In practice, Akoma Ntoso is currently the more authoritative standard at the institutional level for legal-document structure, especially in EU-related contexts.
LegalRuleML is authoritative in a narrower and more specialized sense: it is the standard for formal legal rule representation, but it is not the primary institutional format for publishing or exchanging official legislation.
So the correct conclusion is not to choose one against the other.
It is to understand their proper order:
Akoma Ntoso first, LegalRuleML second.
First the law as authoritative text.
Then the law as extracted rule logic.
The Semantic Web connection
At this point the whole project reveals its deeper technical lineage.
What we are really describing is a domain-specific extension of the Semantic Web.
The Semantic Web, in its most serious sense, is about shared machine-readable meaning across systems.
Administration has exactly that problem.
Different systems must refer to the same person, the same organization, the same authority, the same evidence, the same legal basis, the same registry entry, and the same procedural facts — and they must do so in a way that is portable, inspectable, and interoperable.
That is a Semantic Web problem.
Once seen in that light, the whole stack falls into place:
Akoma Ntoso for structured legal texts
ELI for legal identifiers and metadata
LegalRuleML for rule semantics
RDF / OWL for shared ontology
SKOS for controlled vocabularies and mappings
SHACL for constraints and validation
SPARQL for queries over the graph
PROV for provenance
JSON-LD for practical interchange
CPSV for service representation
CCCEV for criteria and evidence
Core Vocabularies for persons, organizations, locations, authorities, and related entities
This is not a random collection of standards.
It is the outline of a coherent architecture.
The role of ELI
A law-first system also needs stable identifiers for legal resources.
That is the role of ELI, the European Legislation Identifier.
ELI makes legal resources addressable and interoperable as web objects. It helps solve one of the most basic but essential problems: how to refer, reliably and consistently, to a legal text, a version, a fragment, or a related resource.
Without that, cross-jurisdiction comparison remains vague.
With it, legal provisions can become nodes in a larger semantic graph.
The role of the Core Vocabularies
Once the law is structured and identified, the next challenge is representing the things the law is about.
That is where the EU Core Vocabularies become crucial.
These vocabularies are already close to a common administrative lexicon. They provide reusable models for things like:
legal entities
public organizations
persons
locations
criteria
evidence
public services
This is where a German association register field and a French nonprofit register field begin to become comparable.
Even if the legal traditions differ, they may still refer to structurally similar components:
legal name
registered seat
governing body member
competent authority
evidence of authorization
representation power
This is where national legal diversity begins to reveal shared administrative structure.
The role of CCCEV and the once-only principle
The once-only principle is one of the deepest political motivations in this whole space.
It expresses something simple but transformative:
a citizen or organization should not have to provide the same information again and again if the state already knows it from an authoritative source.
But once-only is not just a user-experience principle. It is a semantic and institutional one.
For once-only to work, administrations must know:
what fact is being requested
under what legal basis
which source is authoritative
what counts as evidence
when a fact may be reused
how it was obtained
whether the reused fact is equivalent to the requested one
That is why CCCEV matters so much. It provides a model for criteria and evidence — not only for what a person must prove, but for what it means, semantically, for one piece of evidence to satisfy one legal or administrative criterion.
This is the heart of operational interoperability.
The role of PROV
A reusable administrative fact without provenance is dangerous.
If one procedure reuses a board member’s name from another registry, or one authority relies on a fact asserted elsewhere, then the system must know:
where that fact came from
when it was created
by whom it was asserted
under which process it was derived
when it ceased to be valid
That is why provenance is not optional.
PROV is one of the most important pieces in the stack because it gives administrative data an audit trail. It makes facts inspectable rather than merely portable.
For a visible, trustworthy grammar of administration, provenance is indispensable.
Why registries are the perfect starting point
One especially important insight is that registries may be the clearest place where the grammar of administration becomes visible.
Why?
Because registries sit at the intersection of:
legal status
public record
structured fields
evidence
authoritative sources
procedural updates
cross-agency reuse
A registry entry is almost never just “data.” It is a legal artifact.
A company register, association register, land register, civil status register, population register, or beneficial ownership register all embody the same core pattern:
the law defines what can exist
the law defines what must be recorded
the administration verifies evidence
an authority records the fact
the recorded fact becomes authoritative for other procedures
This is very close to the universal pattern you were looking for.
Registries are not just one administrative domain among others. They are one of the most revealing windows into the hidden structure of bureaucracy itself.
The real architecture
At this point, the answer becomes quite sharp.
A serious law-first ontology for administration should be layered like this:
1. Legal source layer
The law itself, as structured authoritative text.
This is where Akoma Ntoso belongs, together with ELI.
2. Normative logic layer
The obligations, permissions, conditions, exceptions, and rule relationships derived from the legal text.
This is where LegalRuleML belongs.
3. Shared concept layer
The common ontology of the entities, roles, fields, and administrative objects referred to by the law.
This is where OWL, SKOS, and the EU Core Vocabularies belong.
4. Constraint layer
The formal rules that say what a valid administrative object must contain.
This is where SHACL belongs.
For example, a register entry for an association can be constrained to require a legal name, a seat, a board member, and whatever else the relevant law requires.
5. Evidence layer
The model of what must be proven and what sources satisfy the relevant criteria.
This is where CCCEV belongs.
6. Service layer
The operational administrative services exposed to citizens, businesses, and authorities.
This is where CPSV belongs.
7. Provenance and audit layer
The record of how facts came to be known and reused.
This is where PROV belongs.
That is the proper place of each piece.
And it explains exactly why CPSV felt close, but not quite right: because it belongs in the stack, but not at the bottom of it.
The crucial conceptual reversal
The most important conclusion from this whole line of thought is a reversal.
Most digital-government work begins like this:
here is a service
what data does it need?
what software implements it?
But a law-first grammar of administration begins like this:
here is a legal provision
what concepts does it define?
what facts does it require?
what evidence satisfies it?
what record does it create?
what other procedures depend on that record?
what service is merely the outward execution of this structure?
That is an entirely different worldview.
It does not treat the service portal as the essence of administration.
It treats the service portal as a user interface layered on top of a much deeper legal-semantic system.
A new way to compare countries
This approach also changes comparative public administration.
Instead of comparing countries only at the level of ministries, agencies, traditions, or software stacks, one could compare them at the level of:
register-entry schemas
legal entity models
board and representation structures
evidence requirements
authority relations
lifecycle transitions
publication duties
once-only reuse patterns
That would make visible something that is currently mostly hidden:
not whether states are identical, but which parts of their procedures are structurally equivalent.
That could become the basis for a genuinely interoperable European administrative layer — not through flattening national law, but through mapping it to shared components.
What this makes possible
If this architecture were pursued seriously, it could make possible:
cross-country comparison of legal-administrative structures
reusable models for registers and procedural objects
transparent mapping from law to data fields
machine-checkable compliance with legal constraints
once-only evidence reuse grounded in law
inspectable provenance of administrative facts
public visibility into the actual grammar of bureaucracy
That would mean a profound shift.
Administration would no longer be a black box of ad hoc forms and siloed systems.
It would become a visible and legible system of structured legal semantics.
The final conclusion
The main discovery is simple.
There is no single existing standard that already is the full “grammar of administration.”
But the pieces are already here.
And their proper order is now visible.
Not:
service first, law second
but:
law first, rules second, concepts third, services later
That means:
Akoma Ntoso is for the structure of law
LegalRuleML is for the logic of norms
ELI identifies legal resources
Semantic Web standards provide the graph backbone
Core Vocabularies model shared administrative concepts
CCCEV handles criteria and evidence
CPSV describes public services
PROV preserves provenance and trust
This is not yet a finished universal administrative infrastructure.
But it is already the outline of one.
And once you see that, bureaucracy starts to look less like paperwork and more like what it really is:
a hidden grammar governing how societies recognize persons, organizations, statuses, facts, rights, and obligations.
The task now is not to invent that grammar from nothing.
It is to make it explicit.