The short version: the compliance plumbing every enterprise application needs (authentication, audit trails, traceability, data retention, GDPR, API and legacy-format interoperability) gets written once, as open-source formal specifications with generated, verified code. The domain logic on top of it stays proprietary and is sold as SaaS. The first customer is Divizend, a fintech I co-founded in 2020 whose withholding-tax software runs at more than 20,000 private clients and several large institutions, all the way up to the German stock exchange (Clearstream), Euroclear, BNY and Interactive Brokers.

The first milestone is concrete and six months out: Divizend’s audit, auth and data-retention layer, formally specified, with generated code in production. If that works, everything below becomes believable. If it doesn’t, we will have learned the key thing cheaply.

The problem

Every enterprise application in finance, tax and administration rebuilds the same non-functional requirements from scratch, and gets them subtly wrong. Role-based access, audit logs, data lineage, retention and deletion rules, consent handling, export to regulators’ formats: none of it is the product, all of it is where certifications, incidents and sales cycles are lost.

These requirements are also the part that is identical across products. An HR tool, an ERP, a tax-reclaim engine and a wealth-management portal all need the same guarantees, and today each vendor hand-writes them in TypeScript or Java and proves nothing about them beyond a test suite.

The buyers of this software (tax advisors, wealth managers, banks, family offices) don’t care about any of this. They want software that is fast, easy, reliable and, above all, demonstrably compliant. Those four properties are much cheaper to deliver when the compliance layer is specified once, verified once and reused everywhere.

The approach

Algebraic specification is a 40-year-old idea from Joseph Goguen’s OBJ family and the CASL and OMG DOL standards: describe a system as sorts, operations and equations, compose specifications like modules, and derive implementations that provably satisfy them. It never left academia because the tooling was hard to use and the business case was unclear. Both have changed. Proof assistants like Lean are usable by working engineers, and LLMs make writing and checking specifications dramatically cheaper.

The product splits into two layers with different licences:

• Open specification layer (open source). Formal specifications of the non-functional requirements above, plus the toolchain that turns them into running code. Anyone can read them, audit them and build on them. This is where trust and adoption come from.

• Proprietary domain layer (commercial). The actual business logic: tax rules, reporting frameworks, legal processes, the workflows of specific tools. This is where the revenue comes from, delivered as SaaS or through revenue sharing with partners who own the domain knowledge.

Technically the toolchain has three parts: a publisher that stores specifications in a language-agnostic format (CASL, DOL, Maude or similar), a translator that generates code for a functional host language (for example Haskell or Lean), and a runtime that executes the generated code and defines the effects it may have. Only the first two are needed for the Divizend milestone; the runtime follows once real workloads tell us what effects matter.

Commercially the long-run shape is a composable catalogue: compliant building blocks that a firm assembles into exactly the software it needs instead of stacking a dozen subscriptions. We get there by replicating existing tools closely enough that nobody has to learn new workflows, and pricing well under incumbents. We’re not inventing a market, we’re re-implementing one on a better foundation.

Customer zero: Divizend

Divizend does withholding-tax reclaims for institutional clients and runs today on an ordinary Next.js, MongoDB and Postgres stack. I’ve wanted to rebuild its foundation for a while; this is the reason to do it properly.

It is an unusually good first customer for three reasons:

1. Real compliance burden. Divizend is ISO 27001 and SOC 2 Type 2 certified. Those controls are a ready-made, externally audited list of the non-functional requirements the open layer has to satisfy.

2. Clean separation already exists. Divizend’s withholding-tax knowledge stays Divizend’s. The new company supplies the specified, generated infrastructure underneath it, as SaaS or with revenue sharing. That is exactly the open-layer / domain-layer split the whole thesis rests on.

3. Paying from day one. No pilot, no proof-of-concept purgatory, and production data from real institutions to validate against.

The six-month milestone: Divizend’s authentication, audit-trail and data-retention layer specified in an algebraic specification language, with generated code running in production behind at least one live customer flow, and the specification passing an external review against the SOC 2 control set.

What I bring, and who I’m looking for

I co-founded Divizend in 2020 and have taken it from zero through several international subsidiaries, so I’ve seen every stage of a regulated fintech: funding, hiring, certification, enterprise sales, and the long tail of keeping institutions happy. The software I built there processes withholding-tax reclaims for a large share of global cross-border dividend flows. I bring the customer, the domain, the distribution into banks and advisors, and the operating experience. I’m currently learning Lean and working through the algebraic-specification literature from scratch.

What I don’t bring is a decade in formal methods, and that is the first co-founder I’m looking for:

• A formal-methods engineer. Someone who has shipped with Lean, Coq, Isabelle, Maude or similar outside a paper, has opinions about where algebraic specification breaks down in practice, and wants to build the translator layer. Previous exposure to CASL or Hets is a plus, not a requirement.

• A functional-systems engineer. Someone who has run Haskell, OCaml or Scala in production, cares about effect systems and runtimes, and can own the generated-code path from specification to deployed service.

One person covering both is ideal; two who overlap is fine. Location is flexible, with a slight preference for the German-speaking region where Divizend and the first customers are. This is a founding role with equity, not a job, and the first six months are about the Divizend milestone and nothing else.

Longer term I believe this should become a federated company: one team per domain (for example German and Swiss tax, real estate, environmental compliance, HR tooling, Industry 4.0), all on the same open specification core. Whether that happens depends entirely on the core being stable first. It isn’t something I’m asking a co-founder to sign up for today.

Get in touch

If this is you, or you know who it is, write to me. Tell me what you’ve built with formal methods or functional systems, and what you think is wrong with the plan above. I’d rather start with the hardest objection than with a pitch.

julian@nalenz.org · https://linkedin.com/in/nalenz

ich schreibe dir in meiner Rolle als technischer Mitgründer von Divizend (https://divizend.com), einem Münchner FinTech, das sich bislang auf das Thema der Rückerstattung ausländischer Quellensteuer spezialisiert hat. Wir haben bereits etwa 20000 Privatkunden sowie viele Steuerberater, Vermögensverwalter und Großbanken als Kunden, bis hin zur Deutschen Börse, Euroclear, BNY und Interactive Brokers. Ich selbst habe von 2017 bis 2023 an der TU München und KTH Stockholm Informatik studiert.

Derzeit erforsche ich, wie wir die Architektur von Software grundsätzlich verbessern können, mit einem Fokus auf Interoperabilität, informationeller Selbstbestimmung und Datensouveränität, zu Beginn insbesondere aus der Perspektive von Software, mit der Dinge aus der realen Welt verwaltet und koordiniert werden. Meine Forschungsfrage ist im Kern “Wie können wir die Strukturen, durch die Menschen ihr Leben koordinieren, explizit, verständlich, interoperabel und veränderbar machen, ohne dass sich alle auf eine einzige universelle Darstellung der Wirklichkeit einigen müssen?“. Siehe auch meine persönliche Research-Map unter https://research.nalenz.org/.

Nun sehe ich den Erfolg dieses Projekts eng daran geknüpft, Exzellenz in drei Bereichen zusammenzubringen: Datenhaltung, Verarbeitungslogik und Benutzeroberfläche.

Die erste Schlüsseltechnologie, die ich dabei in Richtung Datenhaltung sehe, sind Wissensgraphen. Hier sind wir seit einigen Monaten mit Dr. Tobias Käfer vom KIT und seiner Forschungsgruppe in Kontakt und haben bereits gemeinsam eine Projektskizze mit dem Titel “Formulare, die sich selbst ausfüllen: Verlässliche agentische Finanzberatung über persönliche Wissensgraphen” bei KMU-innovativ eingereicht (siehe Anhang). Zudem arbeiten wir mit Tentris (https://tentris.io/) zusammen, einem Startup aus Bielefeld, das aus der Forschung rund um Prof. Dr. Axel-Cyrille Ngonga Ngomo von der Uni Paderborn hervorgegangen ist und die derzeit schnellste am Markt verfügbare RDF-Graphdatenbank entwickelt.

Hinsichtlich der Verarbeitungslogik sehe ich algebraische Spezifikationen (im Sinne von DOL, CASL usw.) als absolute Schlüsseltechnologie, deshalb schreibe ich dir. Wenn wir es hinbekämen, die deterministischen Vorschriften und die Interaktionen mit der realen Welt (algebraische Effekte) aus Buchhaltung, Steuergesetzen, ERP und sonstiger Bürokratie von der eigentlichen Implementierung zu entkoppeln und ausgehend davon die Idee von Ontohub (https://ontohub.org/) wiederzubeleben, kombiniert mit der Idee von Wikifunctions (https://www.wikifunctions.org/), könnte das die Grundlage für die radikale Demokratisierung des Zugangs zu allem von institutionellen Leistungen bis hin zu selbstorganisierten Verwaltungsstrukturen und jeglicher wirtschaftlicher Tätigkeit sein, insbesondere Selbstständigkeit und Unternehmertum. Ich habe auf deinem GitHub unter https://github.com/tillmo/erpnext-client schon gesehen, dass dir diese bürokratischen Themen definitiv nicht fremd sind. Selbst bin ich noch totaler Anfänger in diesem Bereich; erst vor einigen Monaten habe ich Hets und CASL entdeckt, in den letzten Wochen Projekte wie Hydra (https://github.com/categoricalData/hydra), die Arbeit von Joseph Goguen, John Backus, Paul-Blain Levy und Conal Elliott, und bringe mir derzeit autodidaktisch Kategorientheorie und Lean bei.

Deshalb würde mich sehr interessieren, wie du den heutigen Stand von Hets, DOL und Ontohub einschätzt: Was hat sich bewährt, woran ist es gescheitert und was würdest du mit dem Wissen von heute anders angehen? Am liebsten würde ich das in einem kurzen Videocall von etwa 30 Minuten mit dir besprechen, gern zu einem Termin deiner Wahl. Darüber hinaus fände ich es spannend auszuloten, ob sich daraus eine Zusammenarbeit ergeben könnte, etwa über Abschlussarbeiten, ein gemeinsames Forschungsprojekt oder einen Förderantrag. Divizend könnte dabei reale Anwendungsfälle aus Steuer und Finanzen sowie die Praxisperspektive unserer Kunden einbringen.

Beste Grüße
Julian

Algebraic Specification for Taxation and Bureaucracy: A Conversation About Hets, DOL, and Ontohub?

Dear Till,

I’m writing to you in my capacity as technical co-founder of Divizend (https://divizend.com), a Munich-based FinTech company that has so far specialized in reclaiming foreign withholding taxes. We already serve around 20,000 individual customers, as well as numerous tax advisors, asset managers, and major financial institutions, including Deutsche Börse, Euroclear, BNY, and Interactive Brokers. I myself studied computer science at the Technical University of Munich and KTH Stockholm from 2017 to 2023.

I’m currently researching how we can fundamentally improve software architecture, with a focus on interoperability, informational self-determination, and data sovereignty, initially particularly from the perspective of software used to manage and coordinate things in the real world. At its core, my research question is: “How can we make the structures through which people coordinate their lives explicit, understandable, interoperable, and modifiable, without requiring everyone to agree on a single universal representation of reality?” You can also find my personal research map at https://research.nalenz.org/.

I see the success of this endeavor as closely tied to bringing together excellence in three areas: data storage, processing logic, and user interfaces.

The first key technology I see on the data storage side is knowledge graphs. For several months now, we have been in contact with Dr. Tobias Käfer at KIT and his research group, and we have already jointly submitted a project proposal entitled “Forms That Fill Themselves Out: Reliable Agentic Financial Advice Through Personal Knowledge Graphs” to the KMU-innovativ funding program (see attachment). We are also collaborating with Tentris (https://tentris.io/), a startup from Bielefeld that emerged from research around Prof. Dr. Axel-Cyrille Ngonga Ngomo at Paderborn University and is developing what is currently the fastest commercially available RDF graph database.

When it comes to processing logic, I see algebraic specifications (in the sense of DOL, CASL, etc.) as an absolutely essential technology, which is why I’m reaching out to you. If we could decouple the deterministic rules and interactions with the real world (algebraic effects) involved in accounting, tax law, ERP, and other bureaucratic processes from their actual implementations, and use that as a starting point to revive the idea behind Ontohub (https://ontohub.org/), combined with the concept of Wikifunctions (https://www.wikifunctions.org/), this could lay the foundation for radically democratizing access to everything from institutional services to self-organized administrative structures and all forms of economic activity, particularly self-employment and entrepreneurship.

I already noticed your repository at https://github.com/tillmo/erpnext-client, so these bureaucratic topics are clearly not unfamiliar territory for you. I myself am still very much a beginner in this field. I only discovered Hets and CASL a few months ago, and in recent weeks I’ve come across projects such as Hydra (https://github.com/categoricalData/hydra), as well as the work of Joseph Goguen, John Backus, Paul-Blain Levy, and Conal Elliott. I’m also currently teaching myself category theory and Lean.

I would therefore be very interested in hearing your assessment of the current state of Hets, DOL, and Ontohub: What has worked well, where have these approaches fallen short, and what would you do differently with the benefit of hindsight?

Ideally, I’d love to discuss this with you in a short video call of around 30 minutes, at a time that suits you. Beyond that, I’d also be excited to explore whether there might be opportunities for collaboration, for example through student theses, a joint research project, or a funding proposal. Divizend could contribute real-world use cases from taxation and finance, along with practical insights from our customers.

Best regards,
Julian

Architecturally, firstly let’s assume each of us would have our own server and we can send any data between each other. Now let’s say you define a cool function f and I want to use that function on my server too. In the most basic case, it might be a pure function, say f(x)=x+3, with x being an integer. But what if it interacts with the real world?

I think the most important part of my research question (see https://www.nalenz.org/ and https://research.nalenz.org/) is the part “without requiring everyone to agree on one universal representation of reality”. So I do _not_ want to say “everyone must use this language” (https://xkcd.com/927/) or “everyone must use this logical framework”. Instead, when your server would send your cool function f to my server, firstly it would unwrap it from some serialization format (maybe JSON, XML, Protobuf etc.) and then in the metadata it would say which “doctrine”/theory/logical framework it adheres to, so that when my server receives it, it can ingest it, apply the morphism from f’s theory to the theory it uses internally and then start the execution. For example for f(x)=x+3, it should not depend on the encoding of that function, but instead the structure “natural numbers with zero and successor”. Besides Dedukti, I had also found https://uniformal.github.io/, which also claims to “integrate the 4 major paradigms for representing scientific knowledge”. Then there is also http://hets.eu/ focused on logic translation and this idea of “institutions”, but seemingly also more for proofs instead of for actually executable logic.

Then I kept going and now it seems like the architecture would be “ship terms of a theory, not code, and let the receiver supply the model”. So for example “Natural numbers with zero and successor” is a theory T. Then when my server implements a model of T, there’s a unique homomorphism from the initial model into mine, so f means exactly one thing on my machine. And for real-world interactions, my server runs them by providing a handler, which is a model of that algebraic effect theory in my own world. Seems like https://koka-lang.github.io is based on that idea. And then there is https://openmath.org/ which claims to be “an extensible standard for representing the semantics of mathematical objects” and its “SCSCP (Symbolic Computation Software Composability Protocol)” (https://openmath.org/standard/scscp/) which again sounds nice, but no idea how much substance is behind it. Then I also found “choreographical programming” which seems to be more for distributed systems, which is also so important I think to get right, because the collaborative aspect of this system so important to me.

Then I found “call-by-push-value (Levy’s calculus)” (https://en.wikipedia.org/wiki/Call-by-push-value and https://pblevy.github.io/papers/thesisqmwphd.pdf) which seems to also be a whole new paradigm for such an intermediate language. I didn’t even know the difference between CBN and CBV before, but apparently: “Category theory introductions, logical frameworks (Dedukti, MMT/UniFormal, Hets) and OpenMath all mostly deal with pure, terminating terms. There, evaluation order doesn’t matter: CBV and CBN give the same answer, so those communities rarely mention it. The distinction only becomes important once you have effects or non-termination. For example, print(”a”) + print(”b”) behaves differently depending on when and whether arguments run. That’s exactly where your question went with “what if it interacts with the real world?” So this isn’t a gap in your existing research, but you’ve reached the point where the logic side and the programming language side meet, and CBV/CBN is the first thing you find there.” The part “CBPV remains a unifying starting point in the study of computational and logical phenomena” from https://siglog.org/winner-of-the-2025-alonzo-church-award/ also sounds quite interesting. Unfortunately here the software side seems still quite thin, only PoCs like https://github.com/zydeco-lang/zydeco

So I guess my main curiosity is: Would Dedukti have any place as an “intermediate representation” in this stack, for example splitting it so that logic stays in Dedukti and effects become CBPV? Also, does any interoperability between Dedukti and CBPV (potentially a “λΠ-modulo signature” for CBPV?) already exist? And then my more general curiosity is not specific to Dedukti or LambdaPi, but instead I feel quite stuck in analysis paralysis and just really want to get started with some way to translate all the stuff I’ve already written in traditional programming languages (mostly TypeScript) into some representation (”theory”?) that is independent from the language itself, so that I can then create something like a compiler/interpreter for it as the first reference implementation and eventually something like Wikifunctions to make it distributed and collaborative. I just want to feel secure in the choice of language I make for this “intermediate representation” as well as my first reference implementation, so that I won’t have issues in the future around composability, provability, error handling, making it distributed, real-world effects, reactivity and making it processor-independent (WebAssembly?).

This vision that’s constantly making be bounce between excitement, insanity and hopelessness is that there might be a formulation that brings order into the chaos, not by imposing a certain structure or language but by providing a way for all our existing structures and ways how we put the world into symbols to become translatable into each other, to lay the groundwork for equal global cooperation across borders. The only thing I properly studied was computer science, so I’m really a complete noob when it comes to category theory, but I have a feeling that somewhere inside it, there’s a solution to my problems. I found https://topos.institute/work/catcolab/ yesterday too, and even just “technologies that enable cooperation across difference” from their homepage is basically exactly what I’m also all about. I want to find a way to make software engineering in general “become category theory” (sorry I cannot express it better yet).

I believe that the next big paradigm shift in computers will be leaving Unix’s “everything is a file” behind and transitioning to “everything is a graph”. I think everyone should have at least one personal graph stored with a private key that’s exclusively under their control, and then enabling event-driven/streaming/real-time selective disclosure between different graphs for secure data sharing. Since the beginning of this year I’ve gotten deeply into RDF, but of course that’s also just one of the puzzle pieces.

On the data storage side I’m therefore looking for formulations of everything that makes up a computer program in terms of graphs. The data side is rather trivial. For the business logic side, what Josh is doing with LambdaGraph and Hydra might be suitable. On the UI side, I discovered Goguen’s “algebraic semiotics” yesterday, but didn’t have time yet to get deeper into it. However how to formulate the runtime also in terms of graphs and possibly category theory is still a mystery to me.

Idealistically, what I care about is legibility, particular to make governments, companies and other organizations truly legible and understandable, to get away from our contemporary messy black-box institutions to making the processes that affect our lives auditable by everyone. Laws should not require “today’s priests” (i.e. tax advisors, lawyers etc.) to be understandable and actionable, but instead be clearly divided into what’s mechanical/deterministic and what requires human judgement, so that the execution of governance becomes a creative, compassionate, social dance again instead of so many people serving the system like mindless computers. I want to put an end to “bureaucracy anxiety”, which I call the pathological state of settling with exploitative working conditions simply because the fear of doing something wrong during the bureaucratic processes necessary for self-employment or founding a company are too overwhelming.

On the collaborative side, my vision is something similar to the existing “Wikifunctions”, so as the next generation of open source I see that we’ll be transitioning away from entire git-based projects (because they always reinvent the wheel regarding data storage, formulation of business logic and UI) and rather have a collaboratively edited catalogue of functions. Or maybe it would be a catalogue of effects, or of morphisms (I’m not well-versed enough in functional programming yet), but somehow it would be a sort of “Wikipedia of what computers can do”. I had already thought about “what if we treat data as carefully as real goods?”. For that I recently got more deeply into GS1 EPCIS, that’s the data storage and exchange standard that coordinates what eventually ends up in your local supermarket and practically all other global shopping and logistics, as well as Industry 4.0 digital twin environments like Asset Administration Shell and Eclipse Basyx, in an attempt to see data ingestion, transformation and output as equivalent to industrial production.

Notably liberating data from legacy institutions will also require a great deal of reverse engineering of web APIs, not just binaries like “Reverse Engineer Anything”. With Divizend we already reverse-engineered the web interfaces of dozens of banks and tax administrations to allow users to seamlessly import their stock portfolios and documents into our platform to pre-fill their reclaim forms and later submit them with a single click, so while we’re still in our contemporary world with all the legacy systems which often don’t have proper APIs, reverse engineering is the only option.

Practically, where I want to start with is tax filings. Through various coincidences in my life, I became co-founder and CTO of a company which sells a very specific kind of enterprise tax filing and regulatory tax compliance software (focused on withholding tax reclaims for foreign dividends and interest) not only to tens of thousands of private individuals but also many large international banks and tax advisors. I therefore have complete creative freedom what I want to bring into the market, also because we’re completely self-funded and have no external investors who would impose any other strategy onto us. Right now our platform is based on traditional 2020s-era web development technologies like Next.js, MongoDB, Sentry, etc., with all the different features bolted on over time, but right now I’m working on the architecture for this radical graph-based, category theory-based re-engineering. Regulatory reporting is where all the features I want to make accessible to private people are already mandatory: strong encryption, auditability, traceability, secure data sharing between organizations, on-premise if desired etc. Here I want to get to a point where I can formulate general bureaucracy and thus also regulatory reporting frameworks in terms of graphs and to somehow use category theory to not lose the overview when handling this massive complexity.

If you have any pointers for me that might be relevant to this research question of "How can we make the structures through which humans coordinate their lives explicit, understandable, interoperable, and changeable, without requiring everyone to agree on one universal representation of reality?", please let me know too :)

Was ist ein Staat?

Ein Staat, auch Nation genannt, ist primär ein kultisches Objekt. Jenes Objekt umfasst diverse Merkmale wie Name, Flagge, Nationalhymne sowie eine Menge abhängig beschäftigter Menschen, die zur Aufnahme in den Staatsdienst einen Eid schwören und sich so verpflichten, im Idealfall den Gesetzen dieses Staates Folge zu leisten.

Jeder Staat benötigt den Zwang, um zu überleben. Das Mindestmaß an Zwang dreht sich dabei um die Steuern, also notwendige Geldzahlungen, die auf dem Staatsgebiet wirtschaftlich tätige Personen entrichten müssen. Der Staat besitzt dabei das Gewaltmonopol, das heißt, jene Menschen im Staatsdienst beanspruchen für sich das exklusive Recht, Gewalt im Rahmen der geltenden Gesetze straflos auszuüben.

Auf praktischer Ebene ist ein Staat ein Verwaltungsobjekt. Laut Hans J. Wolff ist Verwaltung “mannigfaltige, zweckbestimmte, idR organisierte, fremdnützige und verantwortliche, nur teilplanende, selbstbeteiligt ausführende und gestaltende Wahrnehmung von Angelegenheiten, insbesondere durch Herstellung diesbezüglicher Entscheidungen”. Verwaltung ist dabei nicht exklusiv dem Staat vorbehalten. Auch Unternehmen müssen verwaltet werden, und Gruppen können sich selbst verwalten. Die Verwaltung kann dabei alles sein, was gemäß definierter Regeln abläuft, vom Aufaddieren von Ressourcenbeständen im Kleinen bis hin zur Verwaltung von internationalen Großunternehmen oder Nationalstaaten im Großen.

Derzeitige Funktionsweise

Zunächst soll das Gegenteil des Pluralismus bestimmt werden, dies ist die derzeitige Welt: An der Spitze steht ein Staatsoberhaupt, das für sich beansprucht, den gesamten Staat zu repräsentieren. Gleichzeitig gibt es ein Parlament aus wenigen hundert Personen, die für sich beanspruchen, den Willen des Volkes in die Gesetzgebungsprozesse einfließen zu lassen, während diese Personen in Wahrheit primär wohlhabenden Gesellschaftsschichten entstammen. Ernsthafte Bestrebungen, alle Menschen der Gesellschaft anzuhören, gibt es nicht. Die Stimmen von nicht volljährigen Personen werden vollständig vernachlässigt und unter verschiedenen Vorwänden wird ihnen bis zur Vollendung des 18. Lebensjahres glaubhaft gemacht, dass sie nicht reif oder intelligent genug wären, um am politischen Diskurs teilzuhaben. Bildung ist ebenfalls ein Verwaltungsobjekt, das zentralistisch ausgeübt wird (bspw. von Bundesländern) und in dem der Fokus auf Arbeit liegt, bei dem es “richtig und falsch” gibt. Sowohl der Staat als auch staatsnahe, regulierte Institutionen wie Banken oder Versicherungen beanspruchen für sich die Treuhandschaft der Daten, die über die Menschen gespeichert werden.

Missachtung der Gesetze wird nicht mit Unterstützung zur Besserung beantwortet, sondern mit physischer und psychischer Gewalt, Abschreckung und Erzeugung von Verfolgungswahn, in Form der Strafverfolgung. Das Menschenbild ist grundsätzlich negativ. Ausbeutung und Erniedrigung werden mit Argumenten wie dass Menschen außerhalb von Machtpositionen nicht intelligent genug wären, um Verantwortung zu übernehmen, als notwendig zum Funktionieren jener hierarchischer Machtstrukturen dargestellt. Das System dient letztlich dem Transfer von Geld und Macht in den Besitz jener, die das meiste Selbstbewusstsein haben.

Der Einfluss des Großteils der Menschen auf die Legislative beschränkt sich auf ein oder zwei Kreuzchen alle paar Jahre. Wer mehr Einfluss ausüben möchte, muss dafür sehr viel Zeit aufwenden, bis hin zur Berufspolitik. Das Parlament funktioniert lediglich repräsentativ, wo Abgeordnete nach ihrer Wahl frei entscheiden können, welche Meinungen sie vertreten; eine Verbindung zu den Meinungen der Menschen aus ihren Wahlkreisen braucht nicht zu existieren. Zudem besteht die Politik aus Parteien, also effektiv nur den Meinungen einer Handvoll Vorstände, denen die anderen Parteimitglieder im Großen und Ganzen Folge zu leisten haben. Auf die Exekutive und die Judikative hat das Volk keinen direkten Einfluss.

Die Verteilung von Steuergeldern ist Aufgabe des Parlaments, wobei das Endergebnis ein Haushaltsplan ist. Das bedeutet, dass zwar praktisch alle Menschen, die innerhalb des Staates in irgendeiner Weise wirtschaftlich tätig sind, zu den Steuereinnahmen beitragen, allerdings effektiv nur wenige hundert Menschen am Ende über die Verteilung entscheiden. Die Flexibilität dieses Modells ist überaus gering und dient primär dem Machterhalt jener, die bereits viel Macht haben.

Der Zugang zu vielen bedeutsamen Verwaltungsleistungen steht primär lediglich solchen Menschen offen, die bereits viel Geld haben und Verwaltungskräfte wie Buchhalter, Anwälte, Steuerberater und Ähnliche bezahlen können. Je mehr diesen bezahlt wird, desto einfacher wird es, den eigenen Willen durchzusetzen und insbesondere keine Steuern zu zahlen. Jene Verhaltensweisen werden als besonders intelligent angesehen, sodass jene Listigkeit und Gerissenheit in der Gesellschaft als sehr hoch und erstrebenswert angesehen wird. Arbeitnehmertum ist die Norm, das heißt jene Praktik, bei der Menschen für ihre geleistete Arbeitszeit bezahlt werden, anstatt an dem Wert teilzuhaben, den diese Arbeit dem Unternehmen bringt, sodass die Anteilseigner des Unternehmens diese Differenz für sich beanspruchen. Selbstständigkeit ist die Ausnahme und den meisten Menschen wird bereits von Kindesalter an vermittelt, dass sie lediglich dazu fähig sind, als Arbeitnehmer die Visionen ihrer Chefs in die Welt zu tragen, anstatt selbst ihre Träume zu verwirklichen.

Pluralistische Verwaltung

Eine pluralistische Verwaltung legt hingegen den Fokus auf den Menschen. Nicht mehr ein abstraktes Gebilde wie der Staat wird als “Souverän” behandelt, sondern jeder Mensch ist gleichberechtigt souverän. Die Unterwerfung unter Hierarchien wird nicht mit der Geburt begründet, sondern folgt dem FRIES-Prinzip, bei dem das Einverständnis nach folgenden Maßstäben erfolgt:

• freely given (freiwillig gegeben)

• reversible (widerruflich)

• informed (informiert)

• enthusiastic (enthusiastisch)

• specific (spezifisch)

Die Speicherung von Daten in elektronischen Medien erfolgt auf eine solche Art und Weise, wo die physische Lagerung der Daten zwar auf einem von Fremden kontrollierten Server erfolgen kann, jedoch dies auf jeden Fall verschlüsselt erfolgen muss. Der Schlüssel für die Entschlüsselung und den Zugriff auf die Daten wird dabei ausschließlich von der Person selbst kontrolliert. Externe können folglich nicht mehr “durch die Hintertür” Zugriff auf die Daten bekommen, sondern müssen das Medium mit dem privaten Schlüssel physisch entwenden. Durch die Rückkehr zu souverän selbstverwalteten Einheiten zur Datenverarbeitung wird die Relevanz von Rechenzentren und Technologieunternehmen minimiert.

Die Aggregation von Meinungen wird nicht mehr der subjektiven Filterung von Berufspolitikern überlassen, sondern eine pluralistische Verwaltung setzt alles daran, die Stimmen von so vielen Menschen wie möglich mittels modernster technologischer Möglichkeiten gleichberechtigt zu hören. Allen Menschen wird eine Möglichkeit bereitgestellt, damit sie ihre Wünsche kundtun können. In der Folge werden fortgeschrittene Methoden zur Verarbeitung natürlicher Sprache eingesetzt, um diese Wünsche zu aggregieren und öffentlich sichtbar zu machen. Basierend darauf werden die Steuergelder verteilt: nicht mehr gemäß “haben wir ja schon immer so gemacht”, sondern als Optimierungsproblem, bei dem hochmoderne, auf Quantencomputern basierende Optimierungsalgorithmen eingesetzt werden, um den Bedürfnissen der Menschen nachweisbar maximal gerecht zu werden.

Während derzeitige Staaten primär militärisch geprägt sind, also sich bis hin zur Bundesregierung stets auf “den Vorgesetzten” berufen wird, wird im Rahmen der pluralistischen Verwaltung schon im Kindesalter die Eigenverantwortlichkeit geübt sowie die Fähigkeit, die Bedürfnisse des eigenen Körpers zu erkennen und entsprechende Wünsche in Worten zu formulieren. Die Verteilung von Budgets erfolgt umgekehrt zu den derzeitigen Staaten. Während derzeitige Staaten die Entscheidungen über den Haushalt so weit oben wie möglich treffen wollen, wird in der pluralistischen Verwaltung so weit unten wie möglich angesetzt: beispielsweise Schülerinnen und Schüler und Lehrpersonal entscheiden gleichberechtigt über das Budget für ihre Schule.

Die Interaktion mit der Verwaltung, also die Bürokratie, wird, basierend auf der personenzentrierten Datenspeicherung, überaus intuitiv und zielführend gestaltet. Regeln zur Interaktion mit Formularen werden in einem international vereinheitlichten Format definiert und dezentral mittels einer Wikipedia-ähnlichen Struktur gepflegt, sodass alle Menschen denselben hochqualitativen Zugang zu Verwaltungsleistungen haben. Eine bedeutsame Folge dessen ist, dass die Selbstständigkeit die Norm ist, also die Wirtschaftstätigkeit primär aus vielen Kleinstunternehmen besteht, die alle in Kooperation auf Augenhöhe ihre Innovationen in die Welt tragen können. Kommerzielle Anbieter für Verwaltungssoftware wie für Steuererklärungen, ERPs usw. braucht es nicht mehr, da alle dieselbe Qualität an Verwaltungsleistungen in Anspruch nehmen können, ohne bürokratische Prozesse als Hürden zu erleben.

What if we connect meaning and action to these symbols? The most prominent example of this is administration (German: Verwaltung). I don’t only mean public administration or governments, but also business administration. The kind of symbol manipulation you have to do to organize, coordinate, distribute something.

Through administration, humans can grow beyond themselves: Suddenly it’s not one person needing to speak to everyone else, but there is a central communication channel, a central register or a central instruction-provider which, based on certain previously agreed-upon rules, plus a subjective sense of obligation or desire in the followers, multiplies a command across many minds.

Unfortunately, since forever, administration has been used to centralize power. No person in power can actual hold that power without their administrators: accountants, controllers, tax advisors, lawyers.

Entire empires are built on that and they are called the “Big 4”: Ernst & Young, KPMG, PwC and Deloitte.

Right now, administrative procedures are so complex that executing them becomes very costly: Either you need to pay actual people to execute them, or there are software companies which have transformed this pattern-based procedural knowledge into code and then sell the access to this code. Other empires are built on that foundation: SAP, Intuit, DATEV and many others.

The main result of this is that large companies have a structural advantage against small businesses: They don’t need to worry about the jungle of rules and regulations because they have experts which figure those out for them. Single-person businesses are fundamentally limited in that way.

But what if they weren’t?

The primary purpose which I see for AI is not in its generative capabilities, but in its structuring capabilities. What I am already actively working on is using AI to figure out all the convoluted bureaucratic processes that prevent people from realizing their full potential. All the lack of legibility won’t go away simply by us screaming at politicians “make bureaucracy easier!”. No party will be able to do that, because the lobby of bureaucrats, of people that earn their living and have built their entire career on executing bureaucracy, is gigantic.

I don’t mean using AI as in “look Claude, do my taxes for me” and the LLM then magically assembling all the data. Instead, I mean a fundamental transition of how we currently store data overall: Away from ununified formats in disparate systems, towards each one of us having a sovereign data storage and execution environment in which applications can be run which can basically do anything.

Whether it’s “extract page 1 from this PDF” or “file my taxes”. It’s all patterns. But in contrast to how applications work right now (such as the App Store, Google Play, apt, or any individually downloaded executable), we need a fundamentally new format.

Each of these packages consists of a set of methods, and the package itself defines an ontology for all the inputs and outputs of these methods. When you install multiple applications, interoperability doesn’t arise because a higher authority defines “the one” ontology, but because applications can define “crosswalks”, mappings between ontologies. This way, your personal ontology is only composed of exactly what you need.

The methods themselves are defined in WebAssembly for maximum platform interoperability, no matter if the code is running in the browser or in any processor architecture.

Finally, everyone will have the opportunity to publish methods themselves on a “Wikipedia of digital patterns”, resulting in a global federated directory of methods. This won’t be a single large server, but Semantic Web. Building software will become delightful assembling of interoperable Legos.

I will take it upon me to start with the basics: an ERP, everything about taxes and, further down the line, banks and insurances. In the future, no one should need to pay for accounting or taxing software ever again. But of course I’m not a tax lawyer and I know barely anything about the depths of an ERP, so it’ll be upon AI to figure that out. I doubt it’ll be that hard.

Having your own business will become a fundamental human right. No one should need to be an employee, just because they don’t have the resources or capacity to deal with all the excessive bureaucracy of today’s nation states and institutions.

Beispiel:

• Du lagerst 1 kg Silber.

• Ich gebe dir einen Schein:
  „Dieser Schein entspricht 1 kg Silber.“

Dann gibt es kein Inflationsproblem.

Warum?

Weil:

• jeder Schein exakt auf eine reale Ressource zeigt,

• keine zusätzlichen Ansprüche erzeugt werden,

• keine „Verdopplung“ entsteht.

Selbst nach 100 Jahren bleibt:

• 1 Schein = 1 kg Silber.

2. Der kritische Übergang

Jetzt passiert etwas Neues:

Der Schein wird weitergegeben.

Nicht mehr nur:

• „Ich schulde DIR Silber“

sondern:

• „Jeder akzeptiert diesen Schein als Geld.“

Ab hier wird es gefährlich.

Denn jetzt kann jemand anfangen, mehr Scheine auszugeben als reales Silber existiert.

3. Der exakte Inflations-Kick-in-Point

Der entscheidende Punkt ist NICHT:

• Bevölkerung,

• Unternehmensanzahl,

• Staatsgröße,

• Marktgröße.

Sondern:

Sobald Forderungen (claims) als allgemein umlaufendes Zahlungsmittel verwendet werden UND ihre Menge schneller wächst als reale Güterproduktion.

Das ist der eigentliche Ursprung von Inflation.

Warum moderne Banken Inflation überhaupt ermöglichen

Heute entsteht Geld meistens nicht dadurch, dass jemand Gold einzahlt.

Sondern:

• Banken vergeben Kredite,

• dabei entstehen neue Einlagen,

• diese Einlagen funktionieren wie Geld.

Also:

Bank → Kredit → neues Kontogeld → neue Kaufkraft.

Dadurch entstehen zusätzliche Ansprüche auf die Wirtschaft.

Das funktioniert solange:

• Produktion mitwächst,

• Vertrauen stabil bleibt,

• nicht zu viele Ansprüche gleichzeitig eingelöst werden wollen.

Wenn aber:

• Geldansprüche schneller wachsen als reale Produktion,
  dann steigen Preise.

Das ist Inflation.

Wie man ein Geldsystem von Anfang an so bauen würde, dass Inflation gar nicht erst entstehen kann

Das Grundprinzip wäre:

GELD UND KREDIT TRENNEN

Das ist der Kern.

Systemdesign ohne strukturelle Inflation

Ebene A — echtes Geld

Dieses Geld darf:

• nur vollständig gedeckt existieren,

• nicht verliehen werden,

• keine Mehrfachansprüche erzeugen.

Beispiel:

• 100 kg Silber im Lager,

• exakt 100 Zertifikate.

Nie mehr.

Dann kann keine monetäre Inflation entstehen.

Ebene B — Kredit

Menschen dürfen natürlich trotzdem:

• investieren,

• verleihen,

• Unternehmen finanzieren.

ABER:

Diese Kredite dürfen nicht gleichzeitig als „sofort verfügbares Geld“ gelten.

Das ist extrem wichtig.

Denn moderne Inflation entsteht hauptsächlich dadurch, dass:

• dieselbe Basis gleichzeitig mehreren gehört.

Beispiel:

Du glaubst:

• „Mein Konto hat 1000 €.“

Die Bank hat dieselben 1000 € aber bereits verliehen.

Der Kreditnehmer gibt sie ebenfalls aus.

Jetzt existieren faktisch doppelte Ansprüche.

Genau dort beginnt das Inflationspotenzial.

Die eigentliche Regel zur Inflationsvermeidung

Ein perfektes antiinflationäres System hätte folgende Verfassungsregel:

Jeder sofort einlösbare Geldanspruch muss zu 100 % gedeckt sein.

Und:

Alles, was nicht vollständig gedeckt ist, darf rechtlich nicht als Geld behandelt werden.

Sondern nur als:

• Investment,

• Anleihe,

• Risikoanlage,

• Fonds,

• Kreditvertrag.

Warum das historisch fast nie dauerhaft eingehalten wurde

Weil Gesellschaften immer wieder Vorteile darin sehen, zusätzliche Kaufkraft zu erzeugen:

• Kriege finanzieren,

• Wachstum beschleunigen,

• Schulden tragbar machen,

• Banken retten,

• Krisen abfedern.

Inflation ist deshalb oft kein „Unfall“, sondern eine Folge davon, dass man:

• mehr Ansprüche erzeugen möchte,
  als reale Ressourcen aktuell decken.

Der tiefere strukturelle Punkt

Ein vollständig stabiles Geldsystem ist nur möglich, wenn:

Geld = reiner Anspruchsspeicher

und NICHT gleichzeitig:

Geld = expansives Kreditsystem

Denn:

• Kredit will wachsen,

• Geldstabilität will Begrenzung.

Diese beiden Ziele stehen strukturell in Spannung.

Das eigentliche induktive Ergebnis

Wenn man vom Mikrofall ausgeht:

Mikro:

1 IOU (“I owe you” = Schuldschein) ↔ 1 reales Gut
→ keine Inflation.

Dann Schritt für Schritt vergrößert:

• mehr Teilnehmer,

• übertragbare Scheine,

• Banken,

• Kredite,

• zirkulierende Ansprüche,

dann entsteht Inflation exakt an diesem Übergang:

Wenn Ansprüche auf reale Güter selbst als handelbares Geld zirkulieren UND vervielfältigt werden können.

Nicht Größe erzeugt Inflation.

Sondern:

• Mehrfachansprüche,

• umlauffähige Kreditgeldschöpfung,

• und fehlende harte Begrenzung der Geldrepräsentationen.

Das ist der eigentliche „Kick-in-Point“.

Für mich ist er völlig klar: Ich möchte Techniken wiederentdecken und Geschichten sammeln, die uns wieder naturverbundener leben lassen können.

Der Bereich, in dem ich mich in letzter Zeit am häufigsten aufhalte, ist mit praktisch dogmatischer Sturheit der genau gegenteilige Bereich. Der Bereich, der zwar weiß, dass er der Erde entsprungen ist, der aber stets gen Himmel schaut. Der Bereich, der sich selbst am Leben erhält, weil er Dualität erzeugt: Die Sprache, das Symbolische, das Formelle, das Regelbasierte, das Exakte, das Technische, das Rationale, Null und Eins.

Doch der Grund dafür, dass ich darauf so fokussiert bin, ist nicht, weil ich es mag. Ganz im Gegenteil. Oft sträubt sich alles in mir dagegen, aber ich sehe es als meine Pflicht an, weil ich scheinbar diesen inneren Trieb habe, also warum ihn nicht für das Wohl der Menschheit gebrauchen? Also irgendwie mag ich es schon, weil sich zumindest meine Arbeit sehr bedeutungsvoll anfühlt, aber rein körperlich ist es einfach unfassbar belastend und erschöpfend.

Auf abstrakter Ebene war es der frühe Morgen des 30. Juni 2024, an dem mir zum ersten Mal der Begriff “Einheit/Unity/hen” + “Liebe/Love/philia” im Kopf erschien, was für mich eine sehr emotionale Angelegenheit war. Natürlich habe ich direkt die Domain registriert (auf diesen Begriff ist eh noch nie jemand gekommen), was dann zu https://henophilia.org geworden ist.

2025 war für mich ein sehr hartes Jahr, da ich zwar irgendwie wusste, wie ich mich in meinem Körper fühlen wollte, allerdings total planlos war, wie ich das in die Realität umsetzen könnte. Ich bin umher geirrt, zwar nicht komplett ziellos, aber zumindest mit keiner erreichbaren nächsten Stufe vor mir.

Seit Anfang diesen Jahres ist das anders, weil ich die Bedeutung von Essen und Sport entdeckt habe (ich berichtete).

Und auch, wenn ich das in Richtung Sport immer noch nicht begriffen habe und ich zumindest bei dem Teil derzeit noch ziellos umher irre, ist es beim Essen ganz anders. Gerade jetzt steht hinter mir ein Gericht, das ich eben aus dem Backofen geholt habe, und ich freue mich darauf, zu essen. Ich kann kaum überbetonen, was für ein großes Ding das für mich ist. Bis Anfang diesen Jahres war Essen für mich nicht mehr als eine lästige Verpflichtung, semi-leckere Dinge zu essen, einfach um zu überleben. Doch inzwischen kenne ich Rezepte, die ich wirklich mag und werde immer geübter im Kochen.

Ich habe inzwischen nicht nur rational erkannt, sondern auch körperlich gelernt, dass mir Naturnähe beim Essen sehr gut gefällt. Es ist mein allererster Schritt bei der Realisierung meines neuen Lebens. Ich hoffe, etwas Ähnliches in den nächsten Monaten auch in Richtung Sport zu erleben, also zum ersten Mal in meinem Leben so wirklich zutiefst positive Erlebnisse in Verbindung mit körperlicher Aktivität zu haben, da ich derartige Erlebnisse einfach noch nicht hatte.

Seit Beginn des Jahres haben sich so zwei Säulen in meinem Leben ergeben: Himmel und Erde, Geist und Körper, Symbolik und Erleben, Denken und Sein, Planen und Bauen, kosmisch und bodenständig, Arbeiten und Gefühle.

Angenommen, meine Spiegelung auf einem kristallklaren See würde sich nicht zur Seite erstrecken, sondern nach oben und unten gleichmäßig, dann fühlt es sich an, als würde die Spiegelung immer länger werden, sowohl nach oben als auch nach unten.

Ich strebe in die höchsten Höhen, nämlich unter anderem in die Transformation aller bestehenden globalen Regierungs-/Governance-Strukturen in eine vereinheitlichte formale Sprache. Das Erschaffen einer Computerarchitektur, die sich daraus auszeichnet, dass für sie alle anderen technischen Systeme feindlich reverse-engineert wurden, um die gesamte globale IT auf Semantic Web zu bringen. Das Herstellen eines Weges, damit jeder weltweit seinen Regierungen jederzeit unmittelbar Feedback geben kann, und diese das nicht mehr ignorieren können. Dass Menschen zuhause einen kleinen Daten-Vault haben können, um endlich auch physisch echte Eigentümerschaft über ihre Daten haben zu können. Banken gründen. Welthunger lösen. Weltfrieden. Go big or go home.

Aber ich weiß auch, dass mein inneres Kind Liebe, Nähe und Gefühle braucht. Ich bin unheimlich enthusiastisch über meine technischen, brainy Ziele, aber in Wahrheit ist es gar nicht mein Ziel, Welthunger zu lösen oder Weltfrieden zu erzeugen, denn auch wenn ich selbst viel dafür tun kann, muss die eigentliche Transformation ja über mehrere Generationen erfolgen, da viele Menschen in ihren Denkmustern festgefahren sind.

Ich will also die Maschine bauen, die dazu führt.

Diese Maschine wäre einfach ein Stück Software, das Governance-Strukturen von menschlicher Sprache in formale Sprache übersetzen kann, um diese Strukturen in Computersystemen zu repräsentieren, plus eine Architektur für eine Laufzeitumgebung und eine zugehörige Referenzimplementierung. Es geht um genau die Verwaltungsstrukturen, deren Funktionsweise (also die Regeln, nach denen sie operieren) sowieso schon einvernehmlich in der jeweiligen Gruppe beschlossen wurde, und wo wir nun den “Missing Link” zwischen Rechtsdokumenten (bspw. Gesetzestexte, Statuten, Verträge, Urkunden) und IT schaffen müssen. Es geht nicht um die Auslegung (die bliebe natürlich bei Menschen), sondern um die Umsetzung. Ich baue formale Systeme nicht, um das Leben zu ersetzen, sondern um es von unnötiger formaler Last zu befreien.

Mein Ziel ist, in der Verwaltung von allem komplett vom Papier wegzukommen, und gleichzeitig Privatsphäre und Interoperabilität zu maximieren.

Das, was derzeit sowieso schon Millionen beim Staat, bei Versicherungen, bei Banken usw. angestellte Programmierer machen. Diese sind Teil des Sands im Getriebe der Gesellschaft: Die Übersetzung von Entscheidungen in IT dauert einfach zu lange. Sie sollte ohne Zeitverzögerung erfolgen. Und ich bin in dieser glücklichen, seltsamen Position, in meinem Job unfassbar viel Erfahrung mit regulatorisch korrekten Computersystemen (also Steuersoftware für Banken) gesammelt zu haben, sodass es sich auch irgendwie wie Verschwendung anfühlen würde, wenn ich das jetzt nicht nutzen würde.

Dieser Übersetzer muss einfach erst mal laufen. Alle Informationen, basierend auf welchen dieses System operieren würde, gibt es schon: die Gesetze, die Verordnungen, die Dienstanweisungen, teils öffentlich, teils privat. Öffentliches bleibt öffentlich, Privates bleibt privat und der Übersetzer von Regierungsstrukturen in formale Sprache ist open source.

Programmierer und alle anderen, die routiniert mit rein Software-bezogener IT interagieren, sollte es nicht mehr geben. Große Datenzentren oder Serverfarmen sollte es nicht mehr geben, da jeder seine Daten zuhause und unter der eigenen Kontrolle haben sollte.

Und wenn das erst mal erledigt ist, dann geh ich überall in die Natur, in den Wald oder Dschungel und mach erst mal Sabbatical. Ich freu mich soooo sehr darauf, irgendwann einfach den Laptop zum letzten Mal auszuschalten. Wenn ich einfach weiß, der Samen ist gepflanzt, die “Epidemie der Eigenverantwortlichkeit” (im positiven Sinne) breitet sich aus, das Flugzeug fliegt und ich muss endlich nicht mehr jeden Tag vor dem Bildschirm meinen Geist und Körper missbrauchen.

Ich denke schon, dass ich früher oder später wieder echten Spaß daran finden würde, mit Computersystemen zu interagieren. Coding Art wird gigantisch werden, sobald diese Transformation erst mal passiert ist.

Aber erst mal will ich, solange wie ich mich danach fühle (vielleicht nur ein paar Monate, vielleicht viele Jahre), Abstand nehmen von allem mit Bildschirmen und gleichzeitig wissen, dass “meine Aufgabe”, was die Bildschirme betrifft, erledigt ist. Dass ich keine Videocalls mehr machen muss, keine E-Mails mehr beantworten muss, nichts mehr programmieren muss, keine Blogbeiträge mehr schreiben muss. Wortwörtlich “von der Bildfläche verschwinden”. In diesem Sabbatical würde ich mich höchstwahrscheinlich bedeutend verändern, sodass alles danach sowieso noch nicht absehbar ist.

Ich hoffe so sehr, dass ich die Ankündigung des entsprechenden Projekts bereits in diesem Jahr machen kann.

Ich frage mich, ob mich irgendwann jemand aufhalten wird. Falls ja, erinnert euch an mich :D

Die Grundidee ist diese:

Hier in der Gegend machen viele Leute miteinander Geschäfte.

• Der Hof liefert was an die Bäckerei.

• Die Bäckerei kauft was beim Elektriker.

• Der Elektriker braucht vielleicht wieder was vom Hof oder vom Tischler.

Und so geht das dauernd hin und her.

Normal läuft das so:

1. Jeder schreibt jedem eine Rechnung.

2. Dann überweist jeder jedem Geld.

3. Dann wartet der eine auf sein Geld, damit er den anderen bezahlen kann.

Und am Ende ist da ein ganz schönes Gewusel.

Unser Gedanke ist:

Man kann das schlauer machen.

Dafür gründet man eine Genossenschaft.

Also einen Zusammenschluss von den Leuten, die da mitmachen wollen.

Die Genossenschaft gehört den Mitgliedern gemeinsam und macht eine einzige Sache:

Sie führt für alle ordentlich Buch darüber, wer wem was geliefert oder geleistet hat, und rechnet das gegeneinander auf.

Das heißt:

• Wenn du was lieferst, kommt das auf dein Konto als Plus.

• Wenn du was beziehst, kommt das auf dein Konto als Minus.

Und am Ende guckt man nicht mehr auf jede einzelne Rechnungskette, sondern nur noch darauf, was bei jedem unterm Strich rauskommt.

Das ist der eigentliche Trick:

Nicht mehr das ganze Hin und Her zählen.

Sondern nur noch den Saldo.

Ein kleines Beispiel:

1. Der Hof macht eine Lieferung an den Elektriker für 600 Euro.

2. Der Elektriker kauft später für 200 Euro was vom Hof.

Normal gäbe es da zwei Zahlungen oder zwei Rechnungen, die man einzeln verfolgen muss.

In der Genossenschaft sagt man einfach:

• Der Hof hat 600 Euro geliefert und 200 Euro bezogen oder andersrum verrechnet.

• Unterm Strich hat der Hof also 400 Euro zu kriegen.

• Der Elektriker hat unterm Strich 400 Euro zu zahlen.

Das ist schon alles.

Mit mehreren Leuten wird das noch nützlicher.

Zum Beispiel:

• Der Hof liefert an die Bäckerei für 500 Euro.

• Die Bäckerei kauft beim Tischler für 500 Euro.

• Der Tischler macht beim Hof was für 500 Euro.

Wenn jeder jedem einzeln Geld überweist, gibt es drei Zahlungen.

Mit der Genossenschaft sieht man:

Das hebt sich komplett im Kreis auf.

Unterm Strich hat keiner mehr was zu kriegen und keiner mehr was zu zahlen.

Dann braucht auch keiner Geld hin und her zu schieben.

Und genau da fängt der Nutzen an:

• Weniger Überweisungen.

• Weniger Durcheinander.

• Weniger Warterei.

Jetzt kommt die Frage, die völlig richtig ist:

Ja schön, aber wenn am Ende einer im Plus ist und einer im Minus, von wem kriegt der sein Geld und an wen zahlt der andere?

Die Antwort ist:

Nicht mehr direkt untereinander.

Sondern über die Genossenschaft.

Also:

• Wer am Ende im Minus ist, zahlt an die Genossenschaft.

• Wer am Ende im Plus ist, bekommt von der Genossenschaft Geld.

Die Genossenschaft ist also die Kasse in der Mitte.

Das ist wichtig.

Sonst hättest du ja wieder das alte Durcheinander.

Am Ende hat also nicht jeder mit fünf anderen abzurechnen,

sondern jeder nur noch mit einer Stelle:

mit der Genossenschaft.

Stell dir das ruhig vor wie einen Ausgleichstopf in der Mitte.

• Alle, die unterm Strich was schulden, zahlen da rein.

• Alle, die unterm Strich was zu kriegen haben, bekommen daraus ihr Geld.

So wird aus ganz vielen einzelnen Zahlungswegen eine einzige klare Abrechnung pro Mitglied.

Und je mehr Leute mitmachen, desto wichtiger wird genau das.

Denn bei zwei oder drei Leuten kann man sich das noch hinlegen und ausrechnen.

Bei sechs, acht oder zwölf Leuten verliert jeder den Überblick, wenn er die ganzen Wege im Kopf behalten will.

Darum macht man das nicht mit Grübeln, sondern mit Konten.

Jeder hat ein Konto bei der Genossenschaft.

Da wird alles eingetragen.

Oben drauf, was geliefert wurde.

Unten drunter, was bezogen wurde.

Und ganz unten steht:

Saldo.

Also nur noch:

Was bleibt unterm Strich?

So verliert man gerade nicht den Überblick.

Denn man muss sich nicht merken:

Wer schuldete noch mal wem was, und wer hat schon wen bezahlt?

Man muss nur noch sehen:

• Steht jemand bei plus oder bei minus?

• Wenn jemand bei plus steht, bekommt er Geld.

• Wenn jemand bei minus steht, zahlt er Geld.

Ganz praktisch wäre das für die Leute hier zum Beispiel so:

• Der Hof liefert Eier, Kartoffeln oder Fleisch.

• Die Bäckerei liefert Brot und Kuchen.

• Der Elektriker macht Arbeiten.

• Der Tischler baut oder repariert was.

• Der Landmaschinenbetrieb kümmert sich um Technik.

• Und das Gasthaus kauft vielleicht bei mehreren ein.

Dann laufen den Monat über viele Rechnungen.

Aber statt dass jeder jedem sofort hinterherläuft, kommt das alles erstmal in die gemeinsame Abrechnung.

Und zu einem festen Zeitpunkt, sagen wir einmal im Monat, wird geguckt:

• Wer ist im Plus?

• Wer ist im Minus?

Dann wird genau dieser Rest ausgeglichen.

So kann es sein, dass einer zehn Geschäfte gemacht hat, aber am Ende trotzdem nur eine einzige Zahlung leisten muss.

Oder eine einzige Auszahlung bekommt.

Und das ist der große Vorteil:

Man rechnet schlauer ab, als wenn jeder alles einzeln bezahlt.

Nun ist wichtig:

Das soll keine Bank sein.

Also nicht so, dass da wild Geldgeschäfte gemacht werden oder Sparbücher geführt werden oder Kredite wie bei einer richtigen Bank vergeben werden.

Sondern die Genossenschaft ist erstmal nur das gemeinsame Rechen- und Abrechnungssystem der Mitglieder.

Sie sorgt dafür,

dass Leistungen ordentlich erfasst,

gegeneinander verrechnet

und am Ende sauber ausgeglichen werden.

Darum ist die Form als Genossenschaft auch so passend.

Weil eine Genossenschaft ja genau dafür da ist, dass Menschen oder Betriebe sich zusammentun, um gemeinsam etwas praktisch Nützliches zu organisieren.

Nicht für fremde Investoren.

Sondern für die eigenen Mitglieder.

Hier wäre der Nutzen:

Einfachere Abrechnung.

Weniger Hin und Her.

Weniger Druck mit kurzfristig verfügbarem Geld.

Mehr Ordnung.

Mehr Verlässlichkeit untereinander.

Damit das nicht im Chaos endet, braucht es natürlich klare Regeln.

Zum Beispiel:

1. Alles muss ordentlich eingetragen werden.

   Nicht nach Gefühl, sondern sauber.

2. Es muss feste Abrechnungszeiten geben.

   Zum Beispiel einmal pro Woche oder einmal pro Monat.

3. Es muss Grenzen geben, wie weit jemand ins Minus gehen darf.

   Sonst bestellt einer immer weiter und kann am Ende nicht zahlen.

4. Es muss klar sein, was passiert, wenn einer nicht rechtzeitig zahlt.

5. Alle müssen nachvollziehen können, was auf ihrem Konto steht.

Ohne solche Regeln taugt das nichts.

Mit solchen Regeln wird daraus aber eine saubere Sache.

Wenn man das ganz schlicht sagen will, dann ist es im Grunde so:

Früher hat jeder jedem hinterherüberwiesen.

Hier sagt man:

Wir schreiben erstmal alles ordentlich auf, rechnen das gegeneinander weg, und nur der Rest wird wirklich bezahlt.

Oder noch einfacher:

Wir handeln weiter ganz normal miteinander.

Wir machen nur das Abrechnen in der Mitte schlauer.

Und wenn du das in einem einzigen Satz sagen willst, dann vielleicht so:

Das ist eine Genossenschaft von Leuten aus der Gegend, die gegenseitige Geschäfte nicht dauernd einzeln abrechnet, sondern erstmal zusammenführt, gegeneinander verrechnet und am Ende nur noch den Rest auszahlt oder einzieht.

Oder ganz küchentischtauglich:

Das ist eine gemeinsame Kasse mit ordentlich geführtem Zettelwerk, damit nicht mehr jeder jedem einzeln hinterherlaufen muss.

Und der Kern ist wirklich nur dieser:

Nicht jeder an jeden.

Sondern alle über eine gemeinsame Mitte.

Und am Ende zählt nur,

was unterm Strich übrig bleibt.

Alles, was später groß, teuer und kompliziert aussieht, kann man dort sehen.

Der Spielplatz ist der Markt; die Kinder sind Marktteilnehmer; die Dinge sind Vermögenswerte; die Zusagen sind Verträge.

1. Die einfachste Sache überhaupt

Lina sagt zu Tom:

„Wenn es nachher regnet, gibst du mir deinen Schirm. Dafür gebe ich dir jetzt drei Murmeln.“

Mehr ist am Anfang nicht los.

Lina hat ein Problem: Sie will nicht nass werden.
Tom übernimmt dieses Problem gegen Bezahlung.

Danach ist das Problem nicht weg. Es sitzt nur jetzt bei Tom.

Linas Sorge ist das Risiko; Toms Zusage ist die Risikoübernahme; die drei Murmeln sind die Prämie.

2. Warum Tom nicht einfach ruhig sitzen bleibt

Tom denkt:

„Was ist, wenn es wirklich regnet? Dann bin ich meinen Schirm los.“

Also geht Tom zu Mia und sagt:

„Wenn es nachher regnet, gibst du mir deinen Schirm. Dafür bekommst du zwei Murmeln.“

Jetzt ist die Lage so:

Lina hat Tom drei Murmeln gegeben.
Tom hat Mia zwei Murmeln versprochen oder gegeben.
Tom behält eine Murmel.

Das ist die ganze Sache in klein.

Tom hat ein Problem übernommen.
Dann hat er einen Teil dieses Problems weitergereicht.
Die Differenz ist das, was bei ihm bleibt.

Toms Geschäft mit Mia ist die Absicherung; das Weiterreichen ist die Risikoüberwälzung; die eine Murmel ist die Marge.

3. Warum diese eine Murmel nicht „freies Geld“ ist

Tom ist jetzt nicht einfach schlau und fertig.

Denn was passiert, wenn es regnet und Mia schon nach Hause gegangen ist?

Dann muss Tom trotzdem an Lina liefern.

Das heißt: Die eine Murmel gehört Tom nicht deshalb, weil er besonders nett war. Sie gehört ihm deshalb, weil er die ganze Kette gebaut hat und am Ende gerade stehen muss, wenn sie reißt.

Mias möglicher Ausfall ist das Gegenparteirisiko; Toms Pflicht gegenüber Lina ist die Primärverbindlichkeit; Toms verbleibender Ärger ist das Restrisiko.

4. Das gleiche mit einem Fußballbild

Nico sagt:

„Ich brauche morgen unbedingt das Ronaldo-Bild. Wenn du es mir besorgst, gebe ich dir fünf Murmeln.“

Sophie sagt zu Nico:

„Ja.“

Danach geht Sophie zu Ben und sagt:

„Wenn ich morgen das Ronaldo-Bild brauche, gibst du es mir für drei Murmeln.“

Jetzt ist alles wieder gleich gebaut:

Nico zahlt fünf.
Sophie zahlt drei.
Zwei bleiben bei Sophie.

Wieder ist das Wichtigste nicht das Bild.
Das Wichtigste ist, dass Sophie zuerst eine Zusage verkauft und danach eine Gegenzusage einkauft.

Nicos Wunsch ist der Kundenbedarf; Sophies Zusage ist das Erstgeschäft; Bens Zusage ist das Gegengeschäft; die zwei Murmeln sind der Bruttoertrag.

5. Das gleiche mit einem Platz auf der Schaukel

Lea sagt:

„Ich will nachher sofort auf die Schaukel. Wenn du mir den Platz freihältst, gebe ich dir zwei Sticker.“

Paul sagt:

„Okay.“

Paul geht zu Jonas, der in der Schlange vor Lea steht:

„Wenn du mich nachher vorlässt, bekommst du einen Sticker.“

Lea zahlt zwei Sticker.
Paul gibt Jonas einen Sticker.
Paul behält einen Sticker.

Auch hier ist die Sache gleich:

Jemand bezahlt für Sicherheit.
Jemand anders wird bezahlt, damit er Platz macht.
In der Mitte sitzt der Organisator und behält die Differenz.

Leas Zahlung ist der Preis für Vorrang; Jonas’ Vorlassen ist die Ausführung; Paul ist der Intermediär; der Sticker ist die Vermittlungsmarge.

6. Jetzt wird es genauer: Was der Mittlere wirklich verkauft

Nehmen wir den Regenfall noch einmal.

Lina kauft nicht „einen Schirm“.
Lina kauft etwas viel Konkreteres:

Sie kauft den Satz:
„Wenn es schlimm wird, ist es nicht mehr mein Problem.“

Tom verkauft also keine Sache.
Tom verkauft eine Zusage.

Und wenn Tom zu Mia geht, kauft er dort auch keine Theorie.
Er kauft wieder eine Zusage.

Darum ist die ganze Sache viel einfacher als sie klingt:

Erst wird eine Zusage verkauft.
Dann wird eine Gegenzusage gekauft.
Die Differenz bleibt in der Mitte.

Der Schirm ist nur der Liefergegenstand; verkauft wird der Schutz; Toms Versprechen ist ein Risikotransfervertrag; Mias Versprechen ist die Rückversicherung.

7. Warum Tom Regeln aufschreiben will

Nach dem dritten oder vierten solchen Geschäft sagt Tom nicht mehr jedes Mal alles neu.

Er sagt zu Mia, Ben und Jonas:

„Bevor wir weiter handeln, gilt Folgendes:
Wer etwas verspricht, muss es halten.
Wer nicht liefert, verliert seinen Pfandchip.
Wer später behauptet, es sei anders gewesen, bekommt nichts zurück.“

Jetzt haben wir etwas Neues.

Tom macht nicht nur einzelne Geschäfte.
Er baut zuerst ein Regelwerk, damit spätere Geschäfte schneller gehen.

Auf dem Spielplatz ist das einfach ein Zettel mit Regeln.
Ohne diesen Zettel gäbe es dauernd Streit.

Der Zettel mit Regeln ist der Rahmenvertrag; jedes spätere einzelne Versprechen ist ein Einzelgeschäft; die Vorab-Regeln sind die Standarddokumentation.

8. Warum Tom Pfand verlangt

Mia sagt zwar, sie gibt im Regen ihren Schirm.
Tom denkt aber: „Und wenn sie dann einfach wegrennt?“

Also sagt er:

„Gut, aber du gibst mir jetzt deinen roten Pfandchip. Wenn du später nicht lieferst, behalte ich ihn.“

Jetzt ist die Sache noch klarer.

Tom kauft nicht nur die Zusage von Mia.
Er verlangt zusätzlich etwas in der Hand, falls Mia später nicht tut, was sie versprochen hat.

Das ist nichts Geheimnisvolles.
Es ist einfach Pfand.

Der Pfandchip ist die Sicherheit; Toms Recht auf den Chip ist die Besicherung; Mias Pflicht dazu ist die Stellung von Sicherheiten.

9. Warum manchmal nicht der Schirm fehlt, sondern Murmeln

Stell dir vor, Tom hat Lina schon drei Schirme für später versprochen.
Jetzt wollen von ihm plötzlich alle, dass er heute schon Pfand hinterlegt.

Tom hat genug Schirme, aber nicht genug Murmeln.

Was macht er?

Er geht zu Emma und sagt:

„Ich gebe dir bis morgen mein seltenes Glitzerbild. Dafür gibst du mir jetzt sofort fünf Murmeln. Morgen kaufe ich mein Bild zurück.“

Jetzt passiert etwas sehr Konkretes:

Tom beschafft sich nicht Schutz vor Regen.
Tom beschafft sich einfach sofort Murmeln.

Er gibt vorübergehend etwas Wertvolles aus der Hand, um heute zahlen zu können.

Das Glitzerbild gegen heutige Murmeln mit Rückkauf morgen ist ein Wertpapierpensionsgeschäft; die fünf Murmeln sind Finanzierung; Emmas Schutz ist die Sicherheit.

10. Warum manchmal nicht Murmeln, sondern ein ganz bestimmtes Bild gebraucht wird

Diesmal braucht Tom kein Geld.
Er hat Lina versprochen, ihr morgen genau das Ronaldo-Bild zu geben.

Tom hat viele Bilder, aber nicht dieses eine.

Also geht er zu Ben und sagt:

„Leih mir bis morgen dein Ronaldo-Bild. Ich gebe dir dafür einen Pfandchip und morgen bekommst du das Bild zurück plus eine Murmel.“

Hier kauft Tom nichts Allgemeines.
Er braucht genau diesen einen Gegenstand.

Nicht irgendein Bild.
Nicht irgendeinen Trost.
Genau dieses eine.

Das geliehene Ronaldo-Bild ist ein Wertpapierdarlehen; der Pfandchip ist die gestellte Sicherheit; die extra Murmel ist die Leihgebühr.

11. Was „weiterreichen“ in einer größeren Runde bedeutet

Jetzt wird der Spielplatz realistischer.

Tom hat nicht nur ein Geschäft.

Lina will einen Schirm.
Nico will ein Ronaldo-Bild.
Lea will einen Platz auf der Schaukel.
Mara will morgen ein Stück Schokokuchen sicher haben.
Felix will, dass jemand seinen Ball zurückholt, falls er über den Zaun fliegt.

Tom sitzt jetzt mit fünf Zusagen da.

Er schaut nicht auf jede einzeln.
Er schaut auf alles zusammen.

Er merkt:

Für Lina braucht er vielleicht Mia.
Für Nico braucht er Ben.
Für Lea braucht er Jonas.
Für Mara braucht er Alina, die beim Kuchen steht.
Für Felix braucht er Can, der gut klettern kann.

Tom baut jetzt keine einzelne Rettung mehr.
Er baut eine ganze Kette von Gegenzusagen.

Toms gesamtes Heft ist das Portfolio; die vielen einzelnen Probleme sind Einzelrisiken; die vielen Gegenzusagen zusammen sind das Hedge-Buch.

12. Warum es billiger wird, wenn vieles zusammenkommt

Jetzt passiert etwas Wichtiges.

Tom merkt, dass nicht alle Probleme gleichzeitig schlimm werden.

Wenn es regnet, ist die Schaukel vielleicht sowieso leer.
Wenn der Ball über den Zaun fliegt, ist das Kuchenproblem egal.
Wenn Jonas Lea vorlässt, kostet ihn das nichts, wenn er sowieso nicht schaukeln will.

Tom erkennt also:

Nicht jedes Problem braucht seine eigene volle Gegenlösung.
Manchmal kann eine einzige gute Beziehung mehrere kleine Probleme abfedern.

Darum verdient jemand, der viele Geschäfte gleichzeitig organisiert, oft mehr als jemand, der nur eines betrachtet.

Nicht weil er zaubern kann.
Sondern weil sich viele Dinge gegenseitig teilweise ausgleichen.

Das gemeinsame Betrachten vieler Probleme ist Netting; das teilweise gegenseitige Aufheben ist Diversifikation; der geringere Bedarf an Gegenlösungen ist Effizienzgewinn.

13. Jetzt kommt der eigentliche Spielplatz-Unternehmer

Bisher war Tom nur jemand, der geschickt Zusagen weiterreicht.

Jetzt wird er größer.

Er sagt:

„Alle, die bei mir Geschäfte machen wollen, benutzen meine Regeln.
Ich habe mein Heft.
Ich habe meine Pfandchips.
Ich entscheide, wem ich glaube.
Ich weiß, wer immer pünktlich liefert.
Ich weiß, wer oft Probleme macht.
Und ich kann viele Zusagen gleichzeitig ordnen.“

Jetzt verkauft Tom nicht nur einzelne Lösungen.

Er verkauft auch:

• Schnelligkeit

• Ordnung

• Verlässlichkeit

• Überblick

• Zugang zu den richtigen Kindern

• weniger Streit

• weniger Ausfälle

Tom ist jetzt kein einzelner Tauschpartner mehr.
Er ist der Mittelpunkt eines kleinen Systems.

Tom ist jetzt nicht nur Händler, sondern Plattform; sein Heft ist die Infrastruktur; seine Kenntnis über die anderen ist Informationsvorsprung; seine Stellung in der Mitte ist Intermediation.

14. Warum andere Tom überhaupt bezahlen

Lina könnte theoretisch direkt zu Mia gehen.

Warum tut sie es nicht immer?

Weil Tom Dinge kann, die Lina nicht kann oder nicht will:

Tom weiß, wer zuverlässig ist.
Tom kennt die Regeln.
Tom hat Pfänder in der Hand.
Tom hat mehrere Möglichkeiten gleichzeitig.
Tom kann einen Plan B bauen, falls Plan A ausfällt.
Tom führt Buch.

Also zahlen andere nicht nur für den Schirm oder das Bild.
Sie zahlen dafür, dass Tom sich kümmert und dass Tom schon weiß, mit wem er reden muss.

Toms Mehrwert ist nicht der Gegenstand, sondern die Intermediationsleistung; sein Wissen ist Due Diligence; sein Plan B ist Risikomanagement; sein Buchführen ist Operations.

15. Wo Tom am meisten verdient

Tom verdient nicht am meisten, wenn er selbst dauernd mit einem Schirm durch die Gegend läuft.

Tom verdient am meisten, wenn er viele Beziehungen hat.

Je mehr Kinder zu ihm kommen, desto mehr weiß er.
Je mehr er weiß, desto weniger muss er hektisch improvisieren.
Je besser er seine Gegenseiten kennt, desto billiger kann er Probleme weiterreichen.

Das heißt:

Der größte Vorteil ist nicht unbedingt der Besitz der Sache.
Der größte Vorteil ist oft der Besitz der Ordnung.

Viele Beziehungen sind Flow; billigeres Weiterreichen ist bessere Ausführung; der Besitz der Ordnung ist Marktstellung; Toms Vorteil ist Skaleneffekt.

16. Jetzt kommt jemand, der noch reicher wird als Tom

Jetzt stell dir vor, es gibt auf dem Spielplatz nicht nur Tom, sondern noch Sarah.

Tom organisiert selbst viele Geschäfte.
Sarah macht etwas anderes.

Sarah sagt zu zwanzig Kindern:

„Gebt mir jede Woche Murmeln.
Ich kümmere mich darum, dass daraus mehr wird.
Dafür bekomme ich immer einen kleinen festen Teil.
Und wenn ich besonders viel daraus mache, bekomme ich zusätzlich einen großen Extra-Teil.“

Jetzt passiert etwas Neues.

Sarah bekommt nicht nur Geld, wenn ein einzelnes Geschäft klappt.
Sarah bekommt schon Geld dafür, dass die anderen ihr überhaupt ihre Murmeln anvertrauen.

Und wenn Sarah selbst Eigentümerin des ganzen Hefts, der Regeln, des Sammelkastens und der ganzen Organisation ist, dann gehört ihr nicht nur ein einzelner Gewinn.
Dann gehört ihr die ganze Maschine.

Der kleine feste Teil ist die Management Fee; der große Extra-Teil ist die Performance Fee; Sarahs eigener Kasten ist die Managementgesellschaft.

17. Warum Sarah viel reicher werden kann als Tom

Tom kann an vielen einzelnen Differenzen verdienen.

Sarah kann an etwas Größerem verdienen:

• Jede Woche bringen neue Kinder Murmeln.

• Alte Kinder lassen ihre Murmeln bei ihr.

• Sie bekommt einen festen Anteil, selbst wenn nichts Spektakuläres passiert.

• Bei besonders guten Ergebnissen bekommt sie noch einmal extra.

• Andere helfen ihr beim Organisieren.

• Aber der Kasten, das Heft und die Regeln gehören ihr.

Tom ist sehr gut in einzelnen Ketten.
Sarah besitzt die Stelle, an der sehr viele Ketten zusammenlaufen.

Darum kann Sarah viel schneller sehr reich werden.

Nicht weil sie in jedem einzelnen Fall besser rät.
Sondern weil sie am Ort sitzt, an dem ständig etwas abfließt und bei ihr hängenbleibt.

Toms Einkommen ist transaktionsbezogen; Sarahs Einkommen ist wiederkehrender Gebührenstrom; Sarahs Eigentum an Kasten und Regeln ist Plattformbesitz.

18. Der Unterschied zwischen dem fleißigen Organisator und der Besitzerin der Maschine

Tom ist ein sehr guter Mittler.

Er nimmt Probleme an.
Er reicht sie weiter.
Er behält Differenzen.

Sarah ist einen Schritt weiter.

Sie besitzt:

• die Kasse

• das Heft

• die Regeln

• die Beziehungen

• den Platz, an dem alle ihre Murmeln sammeln

Tom verdient an einzelnen Problemen.
Sarah verdient daran, dass überhaupt viele Kinder immer wieder über sie laufen.

Das ist der Punkt, an dem aus „geschickt“ wirklich „sehr reich“ werden kann.

Tom ist ein gut bezahlter Operator; Sarah ist Eigentümerin der Gebührenmaschine; der Unterschied ist Arbeitseinkommen versus Eigentumsertrag.

19. Wer das alles bezahlt

Niemand muss darüber streiten. Auf dem Spielplatz sieht man es direkt.

Lina bezahlt mit Murmeln für Sicherheit.
Nico bezahlt mit Murmeln für ein besorgtes Bild.
Lea bezahlt mit Stickern für einen gesicherten Platz.
Tom bezahlt Ben, Mia und Jonas dafür, dass sie Teile der Last übernehmen.
Sarah bekommt von allen laufend einen Anteil dafür, dass ihre Maschine benutzt wird.

Am Ende fließen die Murmeln immer von jemandem weg.

Die Frage ist nur:

Wer zahlt für Bequemlichkeit?
Wer zahlt für Sicherheit?
Wer zahlt für Ordnung?
Wer zahlt dafür, nicht selbst organisieren zu müssen?
Wer zahlt dafür, dass jemand anders die Kette baut und gerade steht?

Lina, Nico und Lea sind die Kunden; Ben, Mia und Jonas sind Gegenparteien; Sarahs laufender Anteil ist Gebührenabfluss; die Murmelströme sind Zahlungsflüsse.

20. Der komplizierteste Fall

Jetzt setzen wir alles zusammen.

Es ist Freitagmittag.

Lina will Regenschutz.
Nico braucht ein seltenes Bild bis morgen.
Lea will sofort auf die Schaukel.
Mara will für später ein Stück Kuchen gesichert haben.
Felix will, dass sein Ball notfalls zurückgeholt wird.
Sieben weitere Kinder geben Sarah jeweils jede Woche Murmeln, damit sie sich um ihre Probleme kümmert.

Tom organisiert einzelne Ketten:
Schirm, Bild, Platz, Kuchen, Ball.

Sarah besitzt das Heft, die Pfandchips, die Kiste, die festen Regeln und die Beziehungen zu fast allen wichtigen Kindern.

Tom verdient daran, dass er einzelne Probleme teurer annimmt, als er sie weitergibt.

Sarah verdient daran,
dass Tom überhaupt über ihre Ordnung läuft,
dass viele Kinder ihre Murmeln bei ihr parken,
dass jede Woche etwas zu ihr fließt,
und dass bei besonders guten Wochen ein extra großer Teil bei ihr bleibt.

Tom kann wohlhabend werden.

Sarah kann sehr reich werden.

Nicht, weil sie den besten Schirm hält.
Nicht, weil sie am besten klettert.
Nicht, weil sie das seltenste Bild besitzt.

Sondern weil sie die Stelle besitzt, an der viele Zusagen, Pfänder, Murmeln und laufende Anteile zusammenkommen.

Toms Netz aus Einzelketten ist die operative Marktmaschine; Sarahs Sammelkasten mit laufenden Anteilen ist die Asset-Management-Plattform; der Übergang von Tom zu Sarah ist der Übergang von Handelsmarge zu skalierbarem Fee-Business.

21. Der saubere Schluss

Die ganze Sache sieht auf dem Spielplatz so aus:

Erst übernimmt jemand gegen Bezahlung ein Problem.
Dann gibt er Teile dieses Problems weiter.
Dann behält er die Differenz.
Dann merkt er, dass Regeln, Pfänder und viele Beziehungen mehr wert sind als ein einzelner guter Tausch.
Dann merkt jemand anders, dass noch mehr Geld darin steckt, nicht nur einzelne Ketten zu bauen, sondern die ganze Stelle zu besitzen, über die diese Ketten laufen.

Das ist die vollständige Ordnung vom Einfachsten bis zum Komplexesten.

Am Anfang steht nur ein Satz:

„Wenn es regnet, gebe ich dir meinen Schirm.“

Am Ende steht eine ganze Maschine:

Viele Kinder zahlen laufend an diejenige Person, die Regeln, Pfänder, Beziehungen, Kasse und Übersicht besitzt.

Und genau dort entsteht das meiste Geld.

Die erste Zusage ist das Einzelrisikogeschäft; das Weiterreichen ist Hedging und Intermediation; Regeln und Pfänder sind Vertrags- und Sicherheitenstruktur; die ganze Maschine ist eine skalierbare Finanz- und Gebührenplattform.

• Event sourcing / Kappa architectures

• Semantic Web and stream reasoning

• ISO 25964-2 vocabulary interoperability

• NeuroSymbolic AI

• Modern neurosymbolic programming frameworks like Scallop

The original goal was simple: identify the most serious academic projects that connect these domains.
The result was a much deeper picture of how several research traditions have evolved and partially converged.

This article reconstructs the entire exploration—from early Semantic Web infrastructure projects to the most alive NeuroSymbolic AI frameworks today.

1. The Original Question

The starting point of the investigation was:

What are the top-tier academic projects connecting event sourcing (event-driven/Kappa architectures) with Semantic Web technologies and ISO 25964-2 thesaurus interoperability?

The short answer was immediately surprising:

There is no single canonical project combining all three.

Instead, the research landscape splits into two major clusters:

Cluster A — Semantic Event & Stream Processing

• RDF stream processing

• semantic complex event processing

• real-time reasoning over evolving knowledge graphs

Cluster B — Vocabulary Interoperability

• SKOS and ISO 25964

• thesaurus mapping

• controlled vocabulary infrastructure

The overlap between these clusters remains thin, but several projects approach it from different directions.

2. The Foundational Semantic Web Projects

LarKC — The Large Knowledge Collider

One of the most ambitious projects in this space was LarKC, funded under the EU FP7 program between 2008–2011.

LarKC attempted to solve a fundamental challenge:

How do we perform reasoning over web-scale knowledge when the data is noisy, incomplete, heterogeneous, and constantly changing?

Instead of building a single massive reasoner, LarKC proposed a pipeline architecture:

retrieve → abstract → select → reason → decide

This approach introduced several ideas that later became mainstream:

• incomplete reasoning

• workflow-based reasoning pipelines

• pluggable reasoning components

• distributed semantic computation

LarKC produced a service-oriented platform allowing reasoning plugins to be composed into distributed workflows.

It also inspired research in:

• stream reasoning

• semantic middleware

• hybrid AI architectures

However, LarKC itself did not survive as a production platform.

Its legacy instead lived on in several subfields.

3. The Rise of Semantic Stream Reasoning

The most influential descendant of LarKC was the stream reasoning research field.

This field attempts to answer a central question:

How can machines reason over continuous streams of data rather than static knowledge bases?

Important systems included:

C-SPARQL

Continuous SPARQL queries over RDF streams.

ETALIS

A semantic complex event processing engine.

CityPulse

A large EU project for real-time semantic processing of smart-city data streams.

These systems introduced key ideas:

• RDF streams

• continuous queries

• semantic event detection

• real-time reasoning over knowledge graphs

Although influential academically, many of these systems eventually slowed down or stopped active development.

4. The ISO 25964 Vocabulary Ecosystem

Parallel to the stream reasoning world, another ecosystem evolved around controlled vocabularies.

ISO 25964-2 focuses on interoperability between thesauri and other knowledge organization systems.

Several major infrastructure projects emerged.

Skosmos

A widely used vocabulary publication platform.

Features include:

• browsing SKOS vocabularies

• SPARQL integration

• multilingual thesaurus support

Skosmos remains one of the most active repositories today.

JSKOS Server

A backend infrastructure for vocabulary storage and mapping.

Key capabilities include:

• concept management

• mapping between vocabularies

• concordances and annotations

• streaming change notifications via WebSockets

This makes JSKOS Server one of the rare systems combining vocabulary infrastructure with event-style updates.

Cocoda

A collaborative tool for creating mappings between knowledge organization systems.

It enables the practical work required by ISO 25964-2:

• vocabulary alignment

• mapping creation

• cross-domain terminology integration

Together, Skosmos, JSKOS Server, and Cocoda form the most alive modern ecosystem for semantic vocabulary interoperability.

5. The Current Semantic Streaming Landscape

Most early stream-reasoning systems are no longer the center of innovation.

The modern ecosystem includes newer projects such as:

RDF-Connect

A framework for RDF-based streaming data pipelines.

OntopStream

A system enabling streaming virtual knowledge graphs using Apache Flink.

Kolibrie

A modern Rust-based RDF stream reasoning engine.

I-DLV-sr

A logic-based system for reasoning over streaming data using Apache Flink.

Among these, Kolibrie is particularly interesting.

6. Kolibrie — A Modern Stream Reasoning Engine

Kolibrie is developed by the Stream Intelligence Lab at KU Leuven.

It focuses on:

• continuous SPARQL queries

• reasoning over timestamped triples

• sliding and tumbling windows

• integration with machine learning

Kolibrie is currently used primarily for:

• benchmark evaluation

• research experiments

• neurosymbolic stream reasoning research

It does not yet power large production systems but is actively used in academic research.

7. The Shift Toward NeuroSymbolic AI

While exploring these systems, the investigation naturally expanded into NeuroSymbolic AI.

NeuroSymbolic systems aim to combine:

• neural learning

• symbolic reasoning

• probabilistic logic

• structured knowledge representations

Several major frameworks dominate the academic landscape.

8. The Most Alive NeuroSymbolic AI GitHub Projects

The most active academic projects today include:

Scallop

A neurosymbolic programming language based on Datalog.

DeepProbLog

A probabilistic logic framework integrating neural networks.

PyNeuraLogic / NeuraLogic

A differentiable logic programming framework.

DeepSeaProbLog

An extension supporting richer probabilistic reasoning.

DeepStochLog

A framework combining grammars, probabilities, and neural networks.

PEIRCE

An emerging framework combining LLMs with symbolic reasoning.

These systems represent different approaches to the same core problem:

How can symbolic reasoning and neural learning be integrated into a single framework?

Among them, Scallop stands out as one of the most ambitious projects.

9. The History of Scallop

Scallop evolved through several distinct phases.

Phase 1 — Prehistory

Scallop builds on earlier systems like:

• TensorLog

• DeepProbLog

• probabilistic deductive databases

These systems struggled with scalability due to exact probabilistic reasoning.

Phase 2 — Scallop v1 (2021)

The first Scallop system appeared in a NeurIPS 2021 paper.

Its main innovation was:

scalable differentiable reasoning using Datalog

Instead of evaluating all proofs, Scallop computes the top-k proofs for queries.

This dramatically improved scalability.

Phase 3 — Scallop as a Programming Language (2023)

The PLDI 2023 paper reframed Scallop as a full language.

Key ideas:

• relations as the core data model

• Datalog as the reasoning language

• provenance semirings for differentiable reasoning

At this stage Scallop became a full programming ecosystem including:

• compiler

• interpreter

• REPL

• Python/PyTorch bindings

Phase 4 — Education and Community

Scallop became widely used for teaching neurosymbolic programming.

The project hosts tutorials and materials for:

• LOG22

• SSFT22

• PLDI23

• SSNP24 summer school

This transformed Scallop from a research prototype into a learning platform for the field.

Phase 5 — Integration with Foundation Models

Recent work extends Scallop to integrate with:

• vision models

• language models

• multimodal foundation models

Plugins such as:

• scallop-gpt

• scallop-clip

show how symbolic reasoning can be combined with modern AI systems.

10. Where the Field Stands Today

The investigation revealed a fascinating landscape.

Three major ecosystems coexist:

Semantic Stream Reasoning

Focus on real-time reasoning over data streams.

Vocabulary Interoperability

Focus on controlled vocabularies and thesaurus mapping.

NeuroSymbolic AI

Focus on integrating neural learning with symbolic reasoning.

The biggest gap is the intersection of all three.

There is still no flagship system combining:

• event sourcing / Kappa architectures

• semantic stream reasoning

• ISO 25964 vocabulary interoperability

• neurosymbolic reasoning

But the pieces now exist.

11. A Possible Future Architecture

A realistic modern architecture might look like this:

Event Log (Kafka / Kappa architecture)
        ↓
Semantic Stream Layer
(RDF-Connect / Kolibrie)
        ↓
NeuroSymbolic Reasoning
(Scallop / DeepProbLog)
        ↓
Vocabulary & Mapping Layer
(JSKOS Server / Skosmos / Cocoda)

Such a stack could support:

• real-time knowledge graph reasoning

• semantic interoperability

• explainable AI decisions

• controlled vocabulary governance

12. Final Thoughts

This exploration began with a simple question about event-driven semantic architectures.

It ended by mapping an entire research ecosystem spanning:

• Semantic Web infrastructure

• stream reasoning

• controlled vocabulary interoperability

• neuro-symbolic programming

What emerged is a clear lesson:

The future of intelligent systems is likely hybrid.

Not purely neural.
Not purely symbolic.
Not purely streaming.

But a combination of all three.

And the pieces of that architecture are already being built today.

Eine freie Gesellschaft braucht klare Regeln, überprüfbare Fakten und verständliche Verfahren.

Heute scheitern Menschen nicht an Gesetzen, sondern an undurchsichtigen Systemen.

Unser Ziel ist eine neue Form von Ordnung:

Eine Gesellschaft, in der Institutionen klar, offen und verständlich funktionieren.

Nicht weniger Regeln.
Bessere Regeln.

Nicht weniger Staat.
Ein lesbarer Staat.

Nicht weniger Institutionen.
Offene Institutionen.

Unser Leitbild

Wir nennen dieses Leitbild:

Klarheitsordnung.

Eine Klarheitsordnung bedeutet:

• Regeln sind eindeutig formuliert.

• Verfahren sind verständlich.

• Fakten sind überprüfbar.

• Konflikte werden gelöst, nicht versteckt.

Unsere Politik folgt einem einfachen Prinzip:

Jede Unstimmigkeit ist ein Auftrag zur Klärung.

Nicht zum Machtkampf.

Unsere wichtigsten Begriffe

Diese Begriffe prägen unsere Politik.

Klarheitsstaat

Ein Staat, dessen Regeln verständlich und überprüfbar sind.

Lesbare Institutionen

Institutionen, deren Verfahren jeder nachvollziehen kann.

Fakten statt Formulare

Institutionen sollen überprüfbare Fakten austauschen, nicht Papier.

Einmal-Prinzip

Menschen geben Informationen nur einmal an.

Portable Rechte

Rechte gehören den Menschen, nicht den Systemen.

Offene Verfahren

Jeder kann verstehen, wie Entscheidungen zustande kommen.

Konfliktlösungspflicht

Jede erkannte Unklarheit muss aktiv geklärt werden.

Bürokratiefrieden

Institutionen lösen Probleme, statt neue zu erzeugen.

Institutionelle Souveränität

Menschen behalten Kontrolle über ihre institutionellen Fakten.

Verfahrensgerechtigkeit

Gerechtigkeit entsteht durch faire Verfahren.

Unsere Vision

Wir wollen eine Gesellschaft, in der:

• Bürger ihre institutionelle Identität besitzen.

• Unternehmen ihre Rechte einfach nutzen können.

• Behörden miteinander sprechen können.

• Verfahren schnell und fair ablaufen.

Unser Ziel ist:

eine Ordnung ohne institutionellen Nebel.

Kapitel 1

Der lesbare Staat

Heute ist der Staat für viele Menschen unverständlich.

Verfahren sind kompliziert.
Regeln widersprechen sich.
Zuständigkeiten sind unklar.

Wir wollen:

einen lesbaren Staat.

Das bedeutet:

• Gesetze müssen verständlich formuliert sein.

• Verfahren müssen klar beschrieben sein.

• Entscheidungen müssen nachvollziehbar sein.

Unsere Leitlinie:

Kein Gesetz ohne klare Anwendung.

Kapitel 2

Konfliktlösung statt Konfliktverwaltung

Viele Institutionen verwalten Konflikte, statt sie zu lösen.

Wir wollen eine andere Kultur.

Unsere Grundregel:

Unstimmigkeiten müssen aktiv geklärt werden.

Wenn Regeln unklar sind, müssen sie präzisiert werden.

Wenn Verfahren widersprüchlich sind, müssen sie vereinheitlicht werden.

Wenn Zuständigkeiten unklar sind, müssen sie eindeutig geregelt werden.

Konflikt ist keine Niederlage.

Konflikt ist Information.

Kapitel 3

Fakten statt Formulare

Heute müssen Menschen immer wieder dieselben Dinge beweisen.

Das ist ineffizient und ungerecht.

Wir wollen:

Fakten statt Formulare.

Institutionen sollen verifizierbare Fakten austauschen können.

Ein Mensch oder Unternehmen muss einen Nachweis nur einmal erbringen.

Danach kann er überprüft werden.

Kapitel 4

Das Einmal-Prinzip

Informationen gehören den Menschen.

Deshalb gilt:

Ein Fakt wird einmal erfasst und überall anerkannt.

Dieses Einmal-Prinzip gilt für:

• Identität

• Wohnsitz

• Unternehmensdaten

• Qualifikationen

• Nachweise

Das reduziert Bürokratie und stärkt Vertrauen.

Kapitel 5

Portable Rechte

Rechte dürfen nicht an Systeme gebunden sein.

Sie müssen portabel sein.

Ein Mensch muss seine Rechte und Nachweise mitnehmen können.

Ein Unternehmen muss seine institutionelle Identität überall nutzen können.

Das nennen wir:

institutionelle Bewegungsfreiheit.

Kapitel 6

Offene Institutionen

Institutionen dürfen keine geschlossenen Systeme sein.

Sie müssen offen funktionieren.

Das bedeutet:

• offene Standards

• transparente Verfahren

• überprüfbare Entscheidungen

Institutionelle Macht darf nicht aus Intransparenz entstehen.

Kapitel 7

Verwaltung als Konfliktlöser

Wir wollen eine neue Rolle für Verwaltung.

Verwaltung soll nicht blockieren.

Verwaltung soll klären.

Das nennen wir:

lösende Verwaltung.

Eine lösende Verwaltung fragt nicht zuerst:

„Warum geht das nicht?“

Sondern:

„Wie können wir dieses Problem klar lösen?“

Kapitel 8

Starke Bürger

Eine Klarheitsgesellschaft stärkt Bürger.

Menschen verstehen ihre Rechte.

Menschen können Verfahren nachvollziehen.

Menschen können Entscheidungen prüfen.

Das nennen wir:

institutionelle Selbstbestimmung.

Kapitel 9

Starke Wirtschaft

Auch Unternehmen profitieren von Klarheit.

Gründen wird einfacher.
Compliance wird verständlicher.
Regeln werden vorhersehbar.

Das nennen wir:

Regelsicherheit statt Regelchaos.

Kapitel 10

Europäische Klarheit

Europa braucht gemeinsame Verständlichkeit.

Unsere Vision ist:

ein interoperables Europa.

Das bedeutet:

• kompatible Verfahren

• verständliche Regeln

• gegenseitige Anerkennung von Fakten

Europa wird stärker durch Klarheit.

Kapitel 11

Bildung für eine Klarheitsgesellschaft

Institutionelle Kompetenz muss Teil der Bildung werden.

Menschen müssen lernen:

• wie Institutionen funktionieren

• wie Verfahren aufgebaut sind

• wie Konflikte gelöst werden

Wir nennen das:

institutionelle Bildung.

Kapitel 12

Grenzen der Klarheit

Nicht alles muss formalisiert werden.

Manche Dinge brauchen menschliches Ermessen.

Deshalb gilt:

Klarheit, wo sie schützt.
Offenheit, wo sie menschlich bleibt.

Eine gute Ordnung kennt ihre Grenzen.

Schlusswort

Unsere Politik folgt einem einfachen Gedanken.

Eine freie Gesellschaft braucht keine undurchsichtigen Systeme.

Sie braucht klare Regeln, verständliche Verfahren und überprüfbare Fakten.

Wir wollen eine Gesellschaft,

in der Institutionen nicht Angst erzeugen,
sondern Vertrauen schaffen.

Eine Gesellschaft,

in der Konflikte nicht versteckt werden,
sondern gelöst.

Eine Gesellschaft,

in der Ordnung nicht kompliziert ist,
sondern klar.

Das nennen wir:

Klarheitsgesellschaft.

Und dafür stehen wir.

Forms. Offices. Waiting rooms. Signatures.

But that’s just the surface.

At its core, bureaucracy is something much simpler:

a system that determines which facts about the world are officially recognized.

Who owns a company.
Who has a right to benefits.
Who is a citizen.
Who can act for an organization.
What a payment means.
What a permit authorizes.

These are not merely administrative details. They are the mechanisms that update society’s shared state.

And the technology that manages those mechanisms is surprisingly primitive.

The Hidden Infrastructure of Society

If you step back far enough, modern civilization runs on three invisible layers.

1. Physical infrastructure – roads, electricity, logistics.

2. Digital infrastructure – networks, cloud computing, data centers.

3. Institutional infrastructure – the rules and records that define legal reality.

We have spent decades improving the first two layers.

But the third layer — institutional infrastructure — is still largely fragmented, opaque, and manual.

Across finance, healthcare, government, law, and commerce, the same pattern appears again and again:

• institutions store facts in isolated systems

• procedures are executed through opaque workflows

• verification happens retroactively through audits

• participants depend on gatekeepers to access legitimacy

The result is enormous friction.

Not because society lacks laws or institutions.

But because we lack a shared grammar for administration.

The Political Question Hidden Inside Software

At first glance, this might sound like a purely technical problem.

It isn’t.

It is fundamentally political.

If institutions are the systems that recognize facts and rights, then the design of those systems determines who can participate, who must ask permission, and who controls legitimacy.

This leads to a powerful idea:

What if legitimacy could be distributed rather than centralized?

Not by abolishing institutions, but by redesigning the infrastructure beneath them.

A New Political Philosophy: Procedural Institutionalism

The worldview that emerges from this idea can be summarized as Procedural Institutionalism.

It is not anti-state.

It is not libertarian.

It is not technocratic.

Instead, it focuses on a single principle:

Society should run on clear rules and verifiable facts rather than opaque institutional discretion.

From this principle follow several core values.

1. Law-First Foundations

Digital systems must implement legal rules rather than replace them.

2. Deterministic Administration

Public procedures should execute according to explicit rules applied to verifiable facts.

3. Compliance by Design

Legal compliance should occur at the moment of action rather than years later through audits.

4. Distributed Legitimacy

Authority should arise from verifiable records rather than centralized control of ledgers.

5. Sovereignty of Institutional Identity

Individuals and organizations should control the records that define their legal existence.

6. Institutional Portability

Rights and records should move with the entity they belong to.

7. Procedural Transparency

Institutional rules must be understandable and inspectable.

8. Open Institutional Infrastructure

Governance infrastructure should operate as open interoperable standards.

9. Modular Governance

Administrative systems should be composed of reusable procedural components.

10. Anti-Rent Infrastructure

Legitimacy systems should not enable monopolistic gatekeeping.

11. Subsidiarity of Authority

Decisions should occur at the lowest competent level.

12. Verifiable Public Truth

Official facts must be auditable and traceable to evidence.

13. Institutional Resilience

Legitimacy should not depend on any single organization.

14. Administrative Minimalism

Institutional systems should minimize friction for participation.

Taken together, these principles describe something new:

a civilization where bureaucracy becomes infrastructure rather than a profession.

Why This Matters: Real Problems in Germany

This isn’t abstract theory.

In Germany, the tension between legal clarity and procedural friction appears everywhere.

Migration and residency procedures

Life-changing rights often depend on overloaded local authorities and opaque processes.

Citizen services

Routine tasks like registration or identity documents still involve fragmented systems and repeated proof of the same facts.

Social benefits

Support programs often require complex evidence loops that delay help for those who need it most.

Business formation

Starting a small organization can involve navigating layers of administrative complexity that disproportionately favor large actors.

Healthcare and social services

Institutional responsibilities are fragmented across multiple agencies with limited procedural interoperability.

Federal fragmentation

Different states often implement the same laws through incompatible administrative systems.

Across these domains, the core frustration is the same:

Rights exist in theory, but accessing them requires navigating opaque procedural systems.

The Missing Piece: A Grammar of Administration

The key insight is that most administrative systems share the same underlying structure.

Every institutional procedure involves:

1. a legal rule

2. facts that must exist

3. evidence proving those facts

4. a decision process

5. a record that updates institutional reality

Yet today these components are scattered across incompatible systems.

To fix this, we need a shared semantic and procedural infrastructure.

Fortunately, many of the pieces already exist.

The Emerging Technical Stack

Over the past two decades, an ecosystem of standards has quietly emerged that could form the backbone of institutional interoperability.

At the core lies a simple technology:

RDF — the universal semantic graph

The Resource Description Framework models information as subject-predicate-object statements.

This allows facts from different systems to be connected into a shared graph.

Around RDF, a family of vocabularies provides specialized capabilities.

Data and catalog standards

• DCAT — describing datasets and data services

• DQV — expressing data quality

• PROF — defining profiles of specifications

• VoID — describing linked datasets

Core semantic building blocks

• SKOS — controlled vocabularies and taxonomies

• PROV-O — provenance and traceability

• OWL-Time — temporal modeling

Institutional actors

• ORG ontology — organizational structures

• RegOrg — registered organizations

• vCard RDF — people and contact information

Governance and rights

• ODRL — permissions and obligations

• Web Annotation — commentary and references

Structured datasets

• RDF Data Cube — statistical data models

Together these vocabularies form a semantic toolkit for modeling institutions.

Domain Standards: The BIRD Pattern

Some sectors already have domain-specific semantic standards.

For example:

Finance

• BIRD — banking reporting dictionary

• ISO 20022 — financial messaging

• XBRL — financial reporting

• LEI — global legal entity identifiers

Healthcare

• FHIR — clinical data exchange

• SNOMED CT and LOINC — medical vocabularies

Procurement

• UBL and Peppol — procurement and invoicing standards

Land administration

• LADM — land ownership modeling

These sector standards show what is possible when a domain agrees on shared semantics.

But they still operate largely in isolation.

Discovering the Vocabulary Universe

A number of repositories catalog the world’s ontologies and vocabularies.

The most important include:

Linked Open Vocabularies (LOV)

A curated directory of reusable linked-data vocabularies.

BARTOC

A large registry of knowledge organization systems.

prefix.cc

A practical registry of thousands of RDF namespaces.

Bioregistry

A metaregistry aligning multiple ontology registries.

FAIRsharing

A curated index of standards, repositories, and policies.

BioPortal and OLS

Large biomedical ontology repositories.

AgroPortal and EcoPortal

Domain repositories for agriculture and ecology.

These resources reveal the scale of the semantic ecosystem that already exists.

Food as a Case Study

Food illustrates how domain ontologies can interconnect entire industries.

Key standards include:

FoodOn

A comprehensive food ontology in OWL/RDF for traceability and quality.

AGROVOC

A multilingual FAO vocabulary with tens of thousands of concepts across agriculture and food.

GS1 Web Vocabulary

Linked-data terms for product information in global supply chains.

AgroPortal

A repository hosting numerous agri-food ontologies.

These vocabularies enable interoperability across farming, retail, logistics, and regulation.

They are examples of how semantic infrastructure can coordinate complex systems.

The Real Opportunity

When you combine:

• legal document standards

• semantic vocabularies

• provenance tracking

• digital identity systems

• domain-specific ontologies

you begin to see the outline of a new layer of infrastructure.

A layer where:

• institutions exchange facts instead of documents

• compliance occurs in real time

• rights become machine-verifiable

• organizations maintain portable institutional records

In such a world, administrative complexity collapses.

Not because rules disappear.

But because rules become explicit and executable.

From Bureaucracy to Infrastructure

Historically, bureaucracies evolved as professional systems for managing institutional complexity.

But once procedures become formalized and interoperable, much of that complexity becomes infrastructure.

Just as cloud computing replaced private data centers, institutional infrastructure may replace large parts of administrative bureaucracy.

The result would not be the end of institutions.

It would be their transformation.

A world where:

• institutions exchange facts rather than documents

• compliance occurs during execution

• legitimacy is distributed across verifiable records

• participation no longer depends on navigating opaque systems

In other words:

bureaucracy becomes part of the operating system of civilization.

The Future Conflict

For the past century, political conflict often centered on questions like:

• market versus state

• capital versus labor

• regulation versus deregulation

The next conflict may look different.

It may be about something deeper:

centralized legitimacy versus distributed legitimacy.

Not about abolishing institutions.

But about redesigning their infrastructure so that legitimacy becomes transparent, portable, and verifiable.

The Long View

We are still in the early stages of this transformation.

But the pieces are already visible:

• semantic web standards

• global identifiers

• digital identity frameworks

• domain ontologies

• interoperable data models

Put together, they form the beginnings of a new layer of civilization.

A layer where institutional processes become computable, inspectable, and interoperable.

A layer where the grammar of administration is finally made explicit.

And once that happens, something profound becomes possible:

institutions that scale with the complexity of modern society without becoming incomprehensible to the people they serve.

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:

1. the law defines what can exist

2. the law defines what must be recorded

3. the administration verifies evidence

4. an authority records the fact

5. 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.

es gibt in der Geschichte der Menschheit zwei Arten von Revolutionen.

Die einen sieht man.

Sie tragen Fahnen.
Sie erschüttern Throne.
Sie lassen Kanonen sprechen.

Die anderen sieht man nicht.

Sie beginnen in der Stille der Gedanken.
Sie wachsen im Schatten der Begriffe.
Und eines Tages stellen wir fest, dass sich die Ordnung der Welt verändert hat.

Wir leben heute in einer solchen Revolution.

Man sagt euch: Es sei die Revolution der Maschinen.

Ich sage euch: Es ist die Revolution der Verfahren.

Denn betrachtet die Welt, wie sie ist.

Was entscheidet über eure Arbeit?
Ein Verfahren.

Was entscheidet über eure Steuern?
Ein Verfahren.

Was entscheidet über eure Rechte?
Ein Verfahren.

Was entscheidet darüber, ob eine Tür sich öffnet oder verschlossen bleibt?

Ein Verfahren.

Die moderne Zivilisation ist ein gewaltiges Gewebe von Regeln.

Und dieses Gewebe wird immer öfter nicht mehr von Menschen vollzogen,
sondern von Maschinen.

Doch täuscht euch nicht.

Die Maschinen entscheiden nicht.

Sie vollstrecken.

Sie vollstrecken, was zuvor geschrieben wurde.

Denn Software ist nichts anderes als die Maschine, die geschriebene Regeln ausführt.

Sie verwaltet Ressourcen.
Sie verwaltet Geld.
Sie verwaltet Beziehungen.
Sie verwaltet Rechte.

Mit einem Wort:

Sie verwaltet das Schicksal des Alltags.

Und hier, Bürgerinnen und Bürger, liegt die eigentliche Gefahr unserer Zeit.

Denn während die Maschinen immer mehr Entscheidungen vollstrecken,

verschwinden die Regeln, nach denen sie handeln.

Sie verschwinden in Programmen.

Sie verschwinden in Plattformen.

Sie verschwinden in undurchsichtigen Systemen.

Und so entsteht ein neues Geheimnis der Macht.

Nicht mehr das Geheimnis der Krone.

Nicht mehr das Geheimnis des Altars.

Sondern das Geheimnis der Algorithmen.

Doch ich frage euch:

Hat die Menschheit nicht schon einmal gegen ein solches Geheimnis gekämpft?

Hat sie nicht schon einmal eine Sprache erobert?

Erinnert euch.

Es gab eine Zeit, da gehörte die Schrift wenigen.

Die Priester lasen.

Die Fürsten unterschrieben.

Das Volk schwieg.

Dann geschah etwas Gewaltiges.

Das Volk lernte lesen.

Und plötzlich konnten Menschen sehen,
was über sie geschrieben wurde.

Das war der Anfang der Freiheit.

Denn Freiheit beginnt dort,

wo Macht lesbar wird.

Heute stehen wir vor derselben Aufgabe.

Die Schrift unserer Zeit sind nicht nur Bücher.

Die Schrift unserer Zeit sind Prozesse.

Die Formulare.
Die Entscheidungslogiken.
Die digitalen Verfahren.

Die unsichtbaren Verfassungen,
nach denen unsere Gesellschaft funktioniert.

Und solange diese Verfassungen verborgen bleiben,

bleibt auch die Freiheit unvollständig.

Darum sage ich euch:

Die nächste große Aufgabe der Zivilisation ist nicht die Maschine.

Die nächste große Aufgabe ist die Grammatik der Verwaltung.

Die Regeln der Gesellschaft müssen sichtbar werden.

Die Prozesse der Institutionen müssen lesbar werden.

Die Verfahren der Macht müssen überprüfbar werden.

Stellt euch eine andere Welt vor.

Eine Welt, in der die Organisation der Gesellschaft nicht mehr in proprietären Systemen verborgen ist.

Eine Welt, in der die Verfahren der Institutionen öffentlich sind.

Eine Welt, in der jede Regel gelesen werden kann,
jede Entscheidung nachvollzogen werden kann,
jede Ausnahme erklärt werden muss.

Eine Welt mit einer großen Bibliothek.

Nicht einer Bibliothek der Bücher.

Sondern einer Bibliothek der Handlungen.

Eine Enzyklopädie der Verfahren.

Eine Sammlung der Modelle, nach denen Menschen gemeinsam handeln.

Dort könnte jemand sagen:

„Ich möchte eine Schule gründen.“

Und die Welt würde antworten:

Hier ist das Verfahren.

Er könnte sagen:

„Ich möchte eine Genossenschaft organisieren.“

Und die Welt würde antworten:

Hier ist das Modell.

Er könnte sagen:

„Ich möchte eine Verwaltung schaffen, die gerecht ist.“

Und die Welt würde antworten:

Hier sind die Regeln.

Man wird euch sagen:

Das ist unmöglich.

Man hat immer gesagt, Freiheit sei unmöglich.

Man hat gesagt, Demokratie sei unmöglich.

Man hat gesagt, Gleichheit sei unmöglich.

Doch die Geschichte kennt eine Richtung.

Sie bewegt sich immer dorthin,

wo das,
was für alle gilt,

auch von allen verstanden werden kann.

Aber hört mich gut.

Die Öffnung der Verfahren ist nur der Anfang.

Denn eine Gesellschaft, die ihre Regeln selbst schreiben will,

muss auch lernen, sich selbst zu regulieren.

Nicht durch Angst.

Nicht durch blinde Autorität.

Sondern durch Mündigkeit.

Durch Verantwortung.

Durch die Fähigkeit, das eigene Leben in Balance zu halten—

in Arbeit, in Beziehungen, in Gemeinschaft, in Sinn.

Denn eine freie Gesellschaft entsteht nicht durch Technik.

Sie entsteht durch reife Menschen.

Darum rufe ich euch nicht zu den Barrikaden aus Stein.

Ich rufe euch zu den Barrikaden aus Begriffen.

Schreibt die Verfahren.

Schreibt die Regeln.

Schreibt die Modelle der Institutionen.

Schreibt sie so,
dass jeder sie lesen kann.

Schreibt sie so,
dass jeder sie prüfen kann.

Schreibt sie so,
dass niemand sie besitzen kann.

Und wenn eines Tages die Menschen zurückblicken auf diese Epoche,

auf dieses Jahrhundert der Maschinen,

dann soll man sagen:

Sie haben nicht nur Computer gebaut.

Sie haben etwas Größeres getan.

Sie haben die unsichtbare Verfassung der Welt sichtbar gemacht.

Sie haben die Grammatik der Macht geöffnet.

Sie haben den Menschen die Fähigkeit zurückgegeben,

die Regeln ihrer eigenen Gesellschaft zu schreiben.

Und an diesem Tag

wird man erkennen,

dass die größte Erfindung des digitalen Zeitalters

nicht die künstliche Intelligenz war,

sondern die öffentliche Sprache der Gerechtigkeit.

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   object

Example:

Alice   worksFor   CompanyX

This 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 model

This 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:

1. Append-only fact log

2. Logical rules

3. 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.

The text proposes a radical yet constructive alternative: the creation of a public, decentralized “Library of Actions” — a shared, versioned, and accountable repository of executable rules, processes, and institutional procedures. Such an infrastructure would make governance legible at the level of execution, enabling citizens not only to read laws and policies, but to inspect, contest, and collaboratively refine the mechanisms by which they are applied. By separating policy from mechanism, embedding revision and appeal into system design, and embracing polycentric governance models, this vision seeks to transform administration from a closed technical domain into a democratic practice.

Rather than abolishing bureaucracy, the proposal aims to socialize it — rendering its logic transparent, its evolution traceable, and its authority accountable. In doing so, it reframes software not as a neutral tool, but as a site of constitutional significance. The republic of the future, it argues, will not be defined by the institutions it proclaims, but by the architectures it exposes. Where rules are executable, they must also be visible; where systems decide, they must also explain. Only then can freedom survive in an age governed by code.

Citizens,

We live in an age that calls itself free —
and yet it breathes through forms.

We live in an age that calls itself digital —
and yet it is governed by invisible writers.

We have been told that power today is fluid, distributed, networked.
But look more closely.

Power has not disappeared.
It has solidified.

It has solidified in protocols.
In data fields.
In decision trees.
In the unseen sentences by which machines render judgment.

Once the world was ruled by swords.
Then by laws.
Today, by architectures.

Not command —
but structure.

Not will —
but default.

Not decree —
but code.

And we have made the gravest error of our era:
We believed administration was merely technical.
We believed software was merely a tool.
We believed rules became neutral once digitized.

But every architecture is a constitution.
Every interface is a statute.
Every database is a registry of reality.

And whoever writes the registries
writes the world.

They tell you: The systems are too complex.
They tell you: Only specialists may build them.
They tell you: Trust the platforms — they know best.

But I ask you:

Since when has democracy meant only the election of persons?
Is it not participation in the rules
by which action is carried out?

What is the value of a ballot
if the real execution of the world
takes place inside closed architectures?

What is the value of a right
if its application is processed by opaque decision engines?

What is the value of a law
if its operative reality
is interpreted and implemented by the few?

No — the great question of our time is not:
Who governs?

But rather:
Who writes the grammar by which governance is executed?

There was a time when knowledge was locked in monasteries.
Then came the printing press —
and writing stepped into the light.

Today we have arrived at another monastery.
Its walls are made of fiber optic cables.
Its monks wear headsets.
Its liturgy is called “deployment.”

And once again, writing is enclosed —
not as text, but as execution.

We have created a world
in which words do not merely persuade,
but act.

A form decides.
An algorithm grants or denies.
A rule set determines who is visible and who is not.

This is not the end of bureaucracy.
It is its culmination.

But if the world is made of executable rules,
then the true revolution is not the destruction of administration —
it is its opening.

Imagine a library.

Not a library of opinions.
Not a library of books.

But a library of actions.

A public collection of processes,
of decision rules,
of institutional procedures
that structure our common life.

An encyclopedia not of knowledge,
but of effect.

Within it, every rule would be visible —
not only as a sentence,
but as executable form.

Not merely as intention,
but as a verifiable chain of decisions.

Within it, one could see:

Who formulated this rule?
Which version preceded it?
Which alternative was rejected?
Which exception was introduced?
What appeal is possible?

Within it, power would not be hidden —
but referencable.

Not secret —
but citable.

Not monolithic —
but branchable.

For a living order is not a tower.
It is a network.

Many centers.
Many layers.
Many responsibilities.

Polycentric like a city.
Linked like a nervous system.
Revisable like a conversation.

They will say: This leads to chaos.

But what is more chaotic
than a world
in which we cannot see
the rules that govern us?

They will say: This threatens stability.

But what is more unstable
than power
that cannot explain itself?

No — true stability arises
where rules are criticizable,
where decisions are justifiable,
where processes are revisable.

An order without appeal
is not order —
it is rigidity.

An architecture without revision
is not progress —
it is concrete.

Therefore every decision
must carry its reasoning with it.
Every rule
must reveal its provenance.
Every change
must bear its history.

Like a text with footnotes.
Like a thought with sources.
Like a law with commentary.

But understand me clearly:

This is not a call for technical omnipotence.
It is not a dream of a world
where everything is computed.

It is the opposite.

It is the restoration of competence.

Tools can liberate
or they can incapacitate.

A tool that only experts may operate
is a throne.

A tool that is understandable
is an invitation.

Therefore the new architecture
must not only be open —
it must be learnable.

Not only decentralized —
but comprehensible.

Not only distributed —
but accountable.

A society that wishes to write its own rules
must educate itself.
Must debate.
Must correct.
Must listen.

Democracy is not a state.
It is a practice.

And perhaps it begins again —
not in the streets,
but in the repository.

Not in revolt against persons,
but in the opening of structures.

The coming revolution
will not carry banners.

It will carry protocols.

It will not storm Bastilles.
It will open black boxes.

It will not cry:
“Give us bread!”

It will say:
“Show us the process.”

And when one day our children ask
what we did in the age of machines,
may we answer:

We made the world legible.
We made the rules shareable.
We made execution accountable.

We did not abolish administration.
We socialized it.

We did not fight technology.
We made it convivial.

We did not destroy power.
We made it referencable.

And in opening the script,
we opened the future.

For where rules are visible,
freedom begins.

And where freedom begins,
history begins anew.

Denn was ist unsere Zeit?

Sie nennt sich digital, doch sie ist vor allem administrativ.
Sie nennt sich frei, doch sie ist vor allem formularisch.
Sie nennt sich modern, doch sie lebt—noch immer—von einem mittelalterlichen Geheimnis:
dass wenige schreiben, und viele gehorchen.

Man sagt euch: Die Welt ist zu kompliziert.
Man sagt euch: Nur Experten dürfen die Regeln in Maschinen verwandeln.
Man sagt euch: Vertraut der Cloud, vertraut dem Konzern, vertraut dem „Service“.
Und während ihr vertraut, wird eure Wirklichkeit in fremden Rechenzentren verhandelt—
wie einst eure Steuern in fremden Palästen.

Doch ich sage euch: Die Zivilisation ist nichts anderes als Schrift, die wirkt.
Gesetz ist Schrift. Vertrag ist Schrift. Verwaltung ist Schrift.
Und Software—ja, Software!—ist nur die Maschine, die Schrift vollstreckt.

Wenn das so ist, dann ist die große politische Frage unserer Epoche nicht zuerst:
„Welche Partei regiert?“
Sondern: Wer besitzt die Grammatik, nach der die Welt ausgeführt wird?

Wer hat die Macht, aus einem Satz einen Prozess zu machen?
Wer hat die Macht, aus einer Absicht eine Berechtigung zu machen?
Wer hat die Macht, aus einem Recht eine Benutzeroberfläche zu machen—
und aus einer Ausnahme eine Fehlermeldung?

Heute ist diese Macht zentralisiert.
Nicht nur in Ministerien. Nicht nur in Verwaltungen.
Sondern in Plattformen. In proprietären Systemen. In Black Boxes.
Die neue Bürokratie trägt Hoodie und verkauft Abonnements.

Und doch—hört genau hin—
in den Tiefen der Technik, in der stillen Logik der Standards,
liegt bereits ein anderer Kontinent bereit.

Es gibt Notationen, geschaffen, um menschliche Abläufe zu beschreiben: Prozesse, Entscheidungen—
nicht als Hexerei, sondern als Sprache.
Es gibt die Möglichkeit, Modelle so klar zu machen, dass sie ausgeführt werden können,
ohne dass jedes Mal ein Priesterstand aus Entwicklern die Bedeutung neu deutet.
Und es gibt Netze, die zeigen—trotz all ihrer Unvollkommenheiten—
dass Information nicht im Palast wohnen muss, sondern im Volk: verteilt, zäh, schwer zu zensieren.

Was fehlt also?

Nicht Rechenleistung.
Nicht „Innovation“.
Nicht noch ein Start-up.

Was fehlt, ist eine Institution, die keine Behörde ist.
Ein Archiv, das kein Ministerium ist.
Ein Gesetzbuch, das nicht aus Papier besteht.

Was fehlt, ist eine Bibliothek der Handlungen.

Eine öffentliche, dezentrale Enzyklopädie—
nicht der Meinungen, sondern der Abläufe.
Nicht der Biografien, sondern der Verfahren.
Nicht der Weltanschauungen, sondern der Weltvollzüge.

Eine Wikipedia der Geschäftsprozesse:
in der man den Satz „So soll es sein“ nimmt—
und ihn übersetzt in klare, überprüfbare, maschinenlesbare Formen:
in Prozesse, in Entscheidungen, in Regeln.

Dann würde ein Mensch sagen:
„Ich will eine Genossenschaft verwalten.“
und die Welt antwortete nicht mit einem Angebot,
sondern mit einer Struktur.

Er würde sagen:
„Ich will eine Schule organisieren.“
und es entstünde nicht ein Vertrag mit einem Konzern,
sondern eine ausführbare Verfassung für sein Vorhaben.

Er würde sagen:
„Ich will Sozialleistungen gerecht, transparent, anfechtbar gestalten.“
und das System würde nicht „bitte warten“ sagen—
sondern: „Hier ist der Prozess. Hier ist die Entscheidung. Hier ist der Beweis.
Hier ist der Widerspruchsweg.“

Denn das ist die eigentliche Revolution:
Nicht dass Maschinen für euch handeln.
Sondern dass ihr die Regeln seht, nach denen Maschinen handeln.

Heute heißt es „KI“.
Morgen wird das Wort verschwinden.
Und übrig bleibt das, was immer übrig bleibt, wenn der Lärm endet:
die Klarheit.

Die Klarheit darüber, wo ein Text noch zweideutig ist.
Die Klarheit darüber, wer eine Ausnahme eingeführt hat.
Die Klarheit darüber, welche Entscheidung wem nützt.
Die Klarheit darüber, dass Governance nicht im Geheimen gedeiht.

Und wenn diese Bibliothek dezentral lebt—
wenn ihre Seiten nicht auf einem Server liegen, den man abschalten kann—
wenn sie in den Händen vieler Knoten ruht, vieler Orte, vieler Gemeinschaften—
dann verliert das Imperium der Plattformen seine natürliche Nahrung: Abhängigkeit.

Dann wird die Cloud wieder zu dem, was sie im Himmel immer war:
eine Form, die vorüberzieht—keine Festung, die euch gehört.

Doch ich warne euch:
Eine solche Bibliothek ist nicht nur Technik. Sie ist Ethik.
Sie verlangt eine Schule der Mündigkeit.

Denn eine Gesellschaft, die ihre Verfahren selbst schreiben will,
muss auch lernen, sich selbst zu regulieren:
nicht-hierarchisch, dialogisch, verantwortungsvoll—
als erlernbare Kompetenz, nicht als Privileg.

Dies ist die Wahl unserer Zeit:

Entweder wir lassen die Schrift der Welt weiterhin von wenigen verfassen
und nennen es Komfort.

Oder wir öffnen den Quelltext der Zivilisation
und nennen es Demokratie.

Ich rufe euch nicht zu den Barrikaden aus Pflastersteinen.
Ich rufe euch zu den Barrikaden aus Begriffen.

Schreibt die Wörterbücher der Verwaltung.
Schreibt die Modelle der Gerechtigkeit.
Schreibt die Prozesse der Solidarität.
Schreibt die Entscheidungen so, dass man sie prüfen kann.
Schreibt sie so, dass sie nicht gekauft werden müssen.
Schreibt sie so, dass sie nicht besitzen, sondern dienen.

Und wenn man euch sagt: „Das ist utopisch“,
antwortet: „Nein. Utopisch ist zu glauben, Zentralisierung sei stabil.“

Denn die Geschichte hat eine eigentümliche Richtung:
Sie geht dorthin, wo das, was für alle gilt, auch von allen verstanden werden kann.
Sie geht dorthin, wo Macht sich rechtfertigen muss.
Sie geht dorthin, wo Schrift nicht herrscht, sondern befreit.

Möge die nächste Revolution nicht die der Fahnen sein,
sondern die der Formulare—
nicht die der Parolen, sondern der Protokolle—
nicht die der Gewalt, sondern der Verifikationen.

Und wenn man eines Tages fragt, was wir getan haben,
in dieser Epoche der Maschinen,
dann soll man sagen:

Sie haben den Menschen das Schreiben zurückgegeben.
Und mit dem Schreiben—die Welt.

But also software.

What does software fundamentally do?

Software is there for administration. Even just the kernel starts with that: it manages registers of processes, keeps logs, organizes sharing just one or a handful of processors between different processes, and so much more.

But it doesn’t stop there. Computer systems nowadays also manage official registers, such as birth registers, company registers, banks, insurances, social states, as well as many other kinds of bureaucracy.

Fundamentally, software does nothing else but to streamline bureaucracy. The concept of “digital transformation”, which is often considered more of a 2010s era term, is more up to date than ever before.

The purpose of software is to take as little input from the user as possible (in order to save time), to create maximally useful output.

What should software look like in the coming age?

I think, with coding AIs, we see a very clear trend: People just want to express their ideas in human language, and then the software should build them.

Right now, it’s still quite buggy, especially for more complex use cases. Additionally, AI coding tools typically don’t handle the deployment at all, at least not out of the box. Once you can choose between any hosting provider in the world to host the software you built, all existing commercial software will become worthless.

If I have a company or an association and want to manage my members, my emails, my accounting, payments, etc., why should I ever pay a software vendor for that again?

It will be either just one spoken or written sentence, or just one click to choose the perfect template for me from a global library – and I have my fully autonomous, fully sovereign environment to manage all my sensitive data, independent from any software vendor and even independent from any big cloud.

The clou is: What future software engineering will look like will not need any human engineers anymore. That is on purpose and by design.

When software manages anything, there’s always a human language document underlying:

• a law (for national obligations),

• a contract (for bi-/tri-/…lateral obligations, which concern a countable number of independent parties), or

• a policy document (for internal obligations).

What now needs to be built is an AI-based input layer which can transform any such document into a more abstract, internationalized description of the intended administrative system, from employee salaries, to a simple revenue sharing agreement, to eventually all the world’s tax laws becoming harmonized, to everything else that can be administered in written form.

For this, LLMs in their current form are not necessary, as they are way too “general purpose”.

After all, the laws, contracts and policies simply need to be translated by the LLM into a hyper-condensed “administration system description language”, and then an interpreter will run this language. Using an LLM to generate code in a general-purpose language like Rust, TypeScript, C++ or anything else here would not be suitable, because generating them would be a waste of tokens and code should not be treated in the same way like unstructured human language. The goal should be to encode legal concepts a bit like Huffman does it: very common terms (e.g. “party”) get short code words, less common terms get long code words.

No “reasoning” (in the way how the AI industry currently understands it) will need to be used, because internally, the system must first try to find any ambiguities in the input text, and when those are all resolved, it is going to act fully deterministically. LLMs can already run on end user devices already, so all the big data centers are not necessary anymore, because why centralize when you can decentralize?

Therefore every law, contract or policy document needs to be translated into this “international meta language of administration” only once. It’ll become like the Wikipedia of machine-readable laws.

When that is done, all software vendors will be kaput, because why should anyone pay for software or use a public cloud ever again, if any imaginable and useful type of software is at your fingertips, hosted wherever you want?

I believe that we will see a massive mobilization of micro-entrepreneurs, of people becoming independent from any employer and following their own passion.

For an economy to be inclusive to truly everyone, the cost of running any kind of company must be zero. Founding should not cost anything, making the annual report shouldn’t cost anything, a tax advisor should not be necessary for regular operations, knowing a thousand bookkeeping accounts should not be necessary, a proper ERP should just be “built-in” and be the open source market standard. Only that’s what I would call actual economic inclusivity, where founding and running a company properly must be accessible to anyone, so that you can actually concentrate on running your business instead of all the administrative stuff around it.

That kind of software is of course exactly what I’m working on.

What I’ve been working on intensely over the last about 1.5 years. I could give a long lecture about what I’ve done in this direction already. It’s very theoretical at parts, but I’m slowly making progress to turning it into real code.

The purpose of the system we’re creating is to be able to turn any contract, statutes document, policy document or law into a digital administrative structure.

Basically, what COBOL always wanted to be: Business people formulating what they want to build. But while COBOL quickly became clunky, with LLMs we get another shot at solving this problem.

But the most important issue is to migrate existing systems into this more harmonized structure, and to always keep them upgradable.

Schemas must be decided upon cooperatively, but when an upgrade has been decided upon, it must also be rolled out to all network participants quickly.

Employment will, in large parts, not exist anymore.

So basically I think that AI will give back humans their humanity.

AI will be a very thin veil: the easy input layer. Within the machine, everything must be according to formally verified rules. But to get data into it, at some point the translation of messy human speech into a more structured, legal form must happen. And it should best happen at the very beginning (i.e., at the input layer), so that issues in this translation process from human language into this more formal type of language can be detected by the end-user immediately.

Computers will not become human, but humane.

They will not consist of windows and little icons and big and small messy buttons anymore. No one will want commercial software anymore if it doesn’t talk the universal language of computers.

The solution is not one shared language, but the intentional interoperability of every language.

First we identify common concepts that are just obvious facts of reality: Persons, Coordinates, Time, Documents, SI units, these kinds of things.

Then we identify more high-level concepts. For example a German GmbH (limited liability company) is constructed in the following two steps:

• a law: the “Regulation on the establishment and maintenance of the company register” (https://www.gesetze-im-internet.de/gesrv/anlage_1.html) → this defines the schema of the German company register

• a certain type of document (in German: the “Registerblatt”, which is the proof that a certain type of company actually exists and what its status is), which you can get from https://www.handelsregister.de/rp_web/welcome.xhtml?cid=1

Before you have this document, you cannot reliably assume that the GmbH exists at all.

Same thing (extracting schema from law or contract → instantiating schema with data) will happen all the time. In both parts LLMs are needed at the input layer:

• to read out what the structure is

• to structure messy input data according to such a structure

Once the structure has been determined and approved by experts, data should of course preferably be input in a way where it doesn’t even become unstructured in the first place, so that no LLMs are needed to handle input, as the user prompt has already been maximally specific and unambiguous. The opposite of this desirable case would be, for example, receiving documents as scans. But, as always, real things are the ground truth, so that when data is read out from a scanned document, and at some point someone detects a mistake made by the OCR, the document will always be immediately accessible, as the chain can always be traced back, no matter how far into the different data processing steps.

We will just need to build this structure once, do it properly, and then we’ll have a super valuable asset for all of humanity.

What did Apple want in the beginning? Making computers more beautiful, more easily accessible. Make them do exactly what we want, as quickly as possible. And consequently, radically reducing time people spend on computers. I think it’s necessary to return to these roots.

Making computers beautiful makes it necessary to have a fundamental shift of how computing is organized. From centralized to peer-to-peer and end-to-end-encrypted. From managed by corporations and governments to self-managed. Collaboratively standardized schemas. Personal data repositories. Data sovereignty/Self-Sovereign Identity. Auto-sync with all data silos which need to be attached. Event-driven architectures, real-time by default. Smooth workflows, simply because “all systems are go.”

It’s gonna feel sooooo good.