The Grammar of Administration: Toward a Universal Infrastructure for Procedures
For months I had a feeling that something fundamental about software was wrong.
Not wrong in the sense that software doesn’t work. Obviously it does. But wrong in the sense that the structure of the problem we are trying to solve—administration, governance, procedures—seems vastly simpler than the systems we build to implement it.
Why does it take thousands of engineers, hundreds of companies, and decades of tooling evolution just to manage things like taxes, memberships, compliance, contracts, or regulatory reporting?
Why does every organization on earth need its own custom administrative software stack?
And more importantly:
Why does it feel like we keep reinventing the same thing?
This article is the story of what happens when you follow that question all the way down.
The Real Nature of Software
The first realization is deceptively simple:
Most software is administration.
Operating systems administer resources.
Finance software administers money.
CRMs administer relationships.
Regulatory systems administer rules.
Software is not primarily computation.
Software is bureaucracy technology.
It organizes rules, states, permissions, workflows, and decisions.
In other words:
Software is the machinery that executes written procedures.
This insight changes the problem completely.
Because if administration is essentially written rules applied to structured facts, then the core problem is not programming.
The core problem is representation.
How do we represent:
facts
rules
decisions
evidence
provenance
constraints
procedures
in a way that machines can execute and humans can inspect?
The Dream: A Universal Administrative Language
Imagine the following.
You say:
“I want to run a cooperative.”
Instead of buying enterprise software or hiring developers, the system responds:
Here is the governance structure.
Here are the decision rules.
Here are the procedures.
Here is the audit trail.
Everything is transparent.
Everything is inspectable.
Everything is executable.
A library of procedures.
A Wikipedia of governance.
Not software products—but administrative blueprints.
This idea sounds utopian at first. But if we look closely at existing technologies, something remarkable appears.
Much of the necessary infrastructure already exists.
The Semantic Web Discovery
During my exploration, I encountered a collection of standards created by the W3C:
RDF
RDFS
OWL
SPARQL
SHACL
PROV
JSON-LD
SKOS
RIF
RDB2RDF
GRDDL
POWDER
SAWSDL
At first glance this list looks like an academic curiosity.
But when you understand the architecture behind them, a pattern emerges.
They form a coherent knowledge infrastructure stack.
And the stack looks suspiciously like exactly what an administrative system needs.
The Hidden Architecture
At the center lies a deceptively simple idea:
Everything can be represented as statements in a graph.
A statement looks like this:
subject predicate objectExample:
Alice worksFor CompanyXThis is the core of RDF (Resource Description Framework).
From this tiny abstraction, an entire ecosystem emerges.
Data model
RDF defines the graph structure.
Query
SPARQL lets you search the graph.
Validation
SHACL enforces constraints.
Ontologies
OWL defines complex relationships.
Provenance
PROV records where data came from.
Serialization
JSON-LD transports it across the web.
Taxonomies
SKOS organizes knowledge hierarchies.
Rules
RIF allows logical inference.
Suddenly the architecture becomes clear.
Applications
│
Rules & reasoning
│
Validation
│
Queries
│
Provenance
│
Serialization
│
Graph data modelThis stack is not random.
It is an attempt to create a universal language for machine-readable knowledge.
And administration is fundamentally knowledge.
The Missing Insight
However, there is a trap many people fall into when encountering these technologies.
They try to find the one true model.
But the deeper truth is different.
Many representations of knowledge are isomorphic.
Facts and rules can be represented as:
graphs
logs
state machines
relational tables
logical clauses
These models can often be translated into each other.
This means the real goal is not discovering the perfect model.
The real goal is creating a stable intermediate representation that many models can map to.
In compiler design this is called an Intermediate Representation (IR).
A pivot language.
A shared semantic backbone.
The Converging Architecture
When exploring many possible designs, a recurring structure appears again and again:
Append-only fact log
Logical rules
Provenance tracking
This architecture mirrors the Semantic Web stack remarkably closely.
Concept: Facts – Technology: RDF
Concept: Queries – Technology: SPARQL
Concept: Validation – Technology: SHACL
Concept: Rules – Technology: RIF / OWL
Concept: Provenance – Technology: PROV
Concept: Serialization – Technology: JSON-LD
The stack becomes a universal administrative substrate.
Why This Matters
Consider what most regulatory and administrative systems actually require.
Take international dividend taxation infrastructure.
Modern regulation like FASTER requires:
custody-chain transparency
auditable reporting
standardized schemas
event traceability
cross-institution data exchange
These systems are fundamentally about structured facts and verifiable processes, not about complex algorithms.
Indeed, modern regulatory infrastructure increasingly revolves around event logs, standardized data models, validation rules, and audit trails—exactly the kinds of structures this architecture represents.
A New Perspective on Software
If this approach becomes widespread, the consequences are enormous.
Today we buy software like products:
accounting systems
CRM platforms
compliance tools
regulatory engines
But if administrative logic becomes:
standardized
machine-readable
composable
then software stops being the product.
Instead:
governance models become reusable
procedures become libraries
compliance becomes configuration
Software becomes infrastructure.
Like electricity.
Or plumbing.
Invisible but essential.
The Real Political Question
This realization leads to a deeper question.
If software executes the rules of society, then the critical issue is not merely technical.
It is political.
Who controls the grammar according to which the world runs?
Today the answer is often:
large platforms
proprietary vendors
opaque systems
But a world where procedures are represented in open, inspectable standards could look very different.
Citizens could see:
how decisions are made
which rules apply
where exceptions exist
how processes can be challenged
Governance would become inspectable code.
The Long Road Ahead
The Semantic Web vision has existed for decades.
Adoption has been uneven.
Tooling can be complex.
Performance challenges exist.
Developer culture often prefers simpler tools.
But the core ideas remain powerful.
And perhaps the moment for them is arriving again.
Because the problem they address—the need for transparent, interoperable administrative systems—is only becoming more important.
The Future: A Library of Procedures
Imagine a world where anyone can say:
“I want to organize a cooperative.”
And instead of starting from scratch, they receive:
a governance model
decision rules
compliance procedures
audit mechanisms
All encoded in open, executable standards.
A library of procedures.
A public infrastructure for governance.
A system where the rules that govern us are not hidden in proprietary software, but written in a language that everyone can inspect.
And perhaps even understand.
The future of software may not be more code.
It may be better grammar.