# Liberating Domain Knowledge For decades experts have watched their knowledge be translated into other people's code — thinned, hardened, placed beyond their direct control. Fluid returns authorship to the people who know: AI drafts, accountable experts decide, and applications follow what they accept. ## Ask who knows Ask who in an organization knows how the work actually works, and nobody hands you a manual. You are given a name. Every knowledge-intensive institution has these people — the partner who can tell you which rule bends and which one breaks, the nurse who knows what the protocol means on a night shift, the compliance officer who can say why the exception was granted five years ago and why it would be refused today. Then ask what authority that person has over the systems that run the work. In most institutions, the honest answer is: none. They can request. They can wait. They can work around. The person who knows cannot change the system, and the people who can change the system do not know. This paper is about that arrangement — where it came from, what it costs the people inside it, and what happens when it ends. ## The quiet expropriation The arrangement begins with a translation. The expert describes how the work works; a team of analysts and developers translates the description into schemas and code. Everyone means well. And three things are lost on the way. Fidelity first: prose becomes meetings, meetings become specifications, specifications become code — each step an interpretation of an interpretation, and the reasoning falls away earliest, as the first paper showed. Then revisability: what was fluent knowledge in a person becomes frozen structure in a mechanism, and the next change is surgery. And finally ownership, the loss nobody records. Once the knowledge runs as code, it belongs — in every practical sense — to whoever maintains the code. The expert can no longer read it, verify it, or revise it in the terms of their field. Their field is in there somewhere, thinned and hardened, but it is no longer theirs. Nobody expropriated anyone deliberately. The translation did it. ## Consultant to your own expertise Watch what the expert becomes on the far side of the translation. They are interviewed at the start of every project, as raw material. They validate other people's renderings of their field, in review sessions where they can spot ten errors but authorize nothing. They file tickets against systems that enforce yesterday's version of their own knowledge — and wait in the same queue as everyone else. The institution pays them for expertise, then rate-limits that expertise through a change process. So the experts route around it. The shadow systems of the first paper are exactly this: the spreadsheet, the checklist, the private decision tree — the places where the profession's living knowledge keeps working while the official systems trail behind. The shadow system is where expert authority goes into exile. The most telling detail: institutions train their juniors on the workarounds. The knowledge that should be the institution's most guarded asset is passed hand to hand, informally, beside the systems — because there is nowhere in the systems for it to live. ## The categories belong to the vendor Zoom out from one institution and the arrangement gets worse. Most organizations do not even run on their own frozen interpretation — they run on someone else's. The categories the work must fit, the fields on the form, the steps in the workflow: owned by a vendor, designed for a market average, shared with a thousand other customers. None of this is an argument against shared software — the scale, the maturity, the proven workflows are real gains. The trade is semantic. The profession adapts to the product: whatever does not fit the vendor's model is configured around, bolted on, or exiled to the spreadsheets. Even deep customization is expressed in the vendor's terms, on the vendor's schedule, and often lost at the next migration. An organization's most specific asset — how it actually does its work, the accumulated judgment of its people — has no first-class home anywhere in its own systems. Be precise about what is being claimed. An organization does not own the legislation it follows, or the standards of its profession — those come from outside, and should. What is its own is how it interprets and applies them: its methods, its policies, its accumulated judgment. The executable representation of that knowledge should be governed by the organization that holds it — not surrendered to vendor structures or a translation layer. Conventional architecture surrenders it quietly, one schema at a time. ## Why it was this way It is worth being fair about why this happened, because nobody chose it. For most of software's history, making knowledge executable meant formalizing it — in code, in rules, in models — and formalization was a rare, specialist skill. Someone had to stand between the expert and the machine. Generations of tools tried to narrow that gap — rules engines, model-driven platforms, domain languages — and the specialist stayed in the middle. Where a tool did put authoring directly in the expert's hands, it was the spreadsheet: direct, and ungoverned. The profession got its own artifact back only by keeping it outside the system. The translation layer was never a conspiracy; it was the bridge that could be built, and the analysts and engineers who carried meaning across it did that work honestly and well. The arrangement had one justification: interpretation was expensive. Formalizing a field — the concepts, the rules, the exceptions — cost so much that you did it once, froze the result, and lived with the drift. Institution after institution made the same trade. Most no longer remember making it. That justification is expiring — but be precise about which cost has fallen. Drafting has become cheap: describing your field in your own words can now produce a structured, checkable candidate model. Judgment has not become cheap. Deciding what is true, weighing evidence, resolving disagreement — those remain as expensive as ever, and that is exactly the point. The bottleneck has moved from producing formal representations to governing their truth. Which raises the question the old arrangement never had to answer: if formalizing is no longer the barrier, where should authority sit? ## The inversion, stated for people The answer of this series, stated for people. Humans describe their own field — in their own language, with their own evidence. AI proposes the model: structured, versioned, formally validated. The expert reviews it in the terms of their field — not in code — and decides. Only what they accept becomes the system. Read carefully what that does to authority. A proposal contains candidate judgments — which concepts exist, how a rule should read, what an exception means. AI may supply all of that; it drafts faster and wider than any analyst ever did. What it cannot hold is authority: the standing to make an interpretation the institution's truth. That standing stays human, and in this arrangement it moves to the person qualified to exercise it. This is the opposite of the fear that AI replaces the professional. Accountable human authority is the one participant that cannot be removed. AI does the drafting. The expert holds the pen that signs. And returning authorship does not mean any expert's first account becomes truth. Experts disagree; evidence changes; regulators rule; organizations choose. The difference is where all of that now happens: in the domain artifact itself — attributed, reviewable, versioned — instead of disappearing into implementation. Fluid does not remove interpretation. It gives interpretation a governed home. A model remains a claim about a domain, as the manifesto puts it — but now it is a claim someone signed, in a form qualified peers can inspect and contest. Engineering does not disappear either — it relocates, and it stays a partnership. Someone must build and harden the substrate that makes any of this trustworthy: the language, the validation, the deterministic runtime, the traces. And someone must keep testing whether a model is coherent, computable and safe to run — which is engineering judgment, exercised beside domain judgment rather than in place of it. What ends is only the arrangement that made engineers the custodians of domain meaning by default — not because they held the knowledge, but because they held the code. ## The partner records the rule This is not a thought experiment. The platform is standing, and we are building the first systems on it now. This is how the first systems we are building work. No prose specification thrown over a wall. No development queue. The professional who understands a rule records it — for an external rule, that means recording a firm's reading of it: what it requires, when it applies, what evidence satisfies it. When a regulator publishes a new guideline, the person who read it can have that reading proposed the same afternoon — and once it has passed its own review and acceptance, it is live in the work their colleagues do. What disappears is the development queue, not the review and not the controls. Notice what that makes the system: a profession beginning to operate on its own recorded knowledge, with the recording done by the people who hold it. The liberation this paper describes is not a roadmap slide. It is what we are building, right now, alongside the professionals whose judgment it has to carry. And it does not arrive in one place only. The same accepted rule governs the specialist's working surface, what a client is shown, and what an auditor is able to reconstruct — different views of one accepted version, not three implementations that can drift apart. ## Knowledge can compound Something else becomes possible when knowledge gains a governed form: it can start to behave like capital. Recorded knowledge stays. The problem the first paper called the quietest — expertise walking out the door — inverts: what the expert records outlives their tenure, versioned, attributed, reviewable by their successors. The firm stops renting a frozen rendering of its own field and starts accumulating its own governed account of the field. And it compounds beyond one firm. A governed domain can be packaged: versioned, reusable, composable. The next firm in the same profession does not start from zero; it starts from what the profession has already recorded, and adds its own way of working. A shared package is not a vendor's average returning by the back door — the difference is governance. It is a base the profession can inspect, version, extend, and explicitly depart from, rather than a schema it must silently conform to. Under the old architecture, every organization paid full price to freeze its own copy of the same field. Under this one, a profession can record its shared knowledge, keep governing it together, and compete on what each firm does with it. Every field recorded makes the next related one cheaper — not a network effect bolted onto a product, but what knowledge does when it finally has a form that can be shared without being lost. Like any capital, recorded knowledge can also depreciate. A governed model stays valuable only while it is used, challenged, and revised — versioning preserves what was believed; governance decides whether it should remain authoritative. Knowledge compounds only when it can also be challenged. ## What liberation asks Honesty requires the other half: authority returned is responsibility returned. Making knowledge explicit is harder than leaving it tacit. Recording forces decisions that intuition never had to make, and a system that runs on your recorded rules will hold you to them — every result traceable to a version that was reviewed and accepted. What holds you is exactly what you accepted and nothing else. Inside Fluid's execution boundary nothing generative runs: the same domain version, the same input and the same configuration produce the same result, with a trace back to the accepted rules and decisions that produced it. AI drafts. It does not decide, and it does not improvise while the work is running. Some professionals will want that pen; others will prefer to review what colleagues record. Both are fine. What matters is where the authority sits: with the people responsible for the domain, in the language of their field. And not everything should be recorded. Some knowledge is tacit, situational, ethical — judgment that ought to stay live rather than be reduced to a model. Liberation is not converting the expert into software. It is letting the profession govern what is made explicit, and keeping human judgment sovereign where formalization ends. For fields built on accountability, all of this is the point rather than the price. The account of the standard you are held to becomes one your profession has read, interpreted and accepted in the open — not a vendor's average of it, not a translation's approximation of it. That is a demanding kind of freedom. It is also the only kind worth the name. ## The point Strip the series to its spine. The first paper showed institutions running on frozen interpretations of a moving world, and professionals working around their own systems. The second showed an industry aiming its most powerful new engine at the wrong artifact, multiplying frozen meaning faster. This paper says what the alternative is for: the accountant, the lawyer, the doctor, the compliance officer — the people who know how the work works — recording their own field, and the application running on what they accepted. What that means has been made precise across three papers: no opaque handoff of meaning into separately maintained code, no hidden copy of the domain left to drift inside an implementation, no development project for changes the domain can already express. No intermediate layer. No translation loss. No waiting. The work changes, and the software follows. That is a change in software architecture, but it was never what made this matter. What makes it matter is where authority over meaning lives. It lives with the people who know, inside the governance that makes their judgment accountable. ## The argument ends. The work starts. The platform is standing; the first systems are going up on it now. What comes next is not more argument — it is the systems themselves, and the people who build them. That is the invitation. - [Join us — help build Fluid](https://fluid.nu/en/building-fluid) - [Download this paper as PDF](../papers/liberating-domain-knowledge.pdf)