Daniel KliewerThe book

Concept

Knowledge compilation

Turning source material into structured, validated, versioned knowledge units.

Retrieval gives you passages. Compilation gives you claims: what was asserted, by which source, with what support, and in conflict with what else. The difference is whether a conclusion can be traced back to something checkable.

A compiler has passes — extraction, normalisation, linking, contradiction detection, validation — and each pass writes an artifact. That is what makes the output inspectable at every stage instead of emerging as a single opaque answer.

The recurring principle across these projects is that evidence magnitude is not sufficiency. A claim supported by a hundred weak sources is not better established than one supported by a single strong one, and a pipeline that only counts support will get that wrong.

This is why compilation beats query-time reasoning on cost as well as rigour. Query-time AI re-derives the same relationships on every request, spending tokens to reach a conclusion someone already reached. Do the hard reasoning once, compile it, and everyone after you inherits the answer instead of re-paying for the question.

Implementation

Where this runs

A concept that never left a document is a hypothesis. These are the systems that implement it.

2026-10-01

GanymedeA knowledge compiler: source material in, structured and validated knowledge units out.

→

2026-07-06

Sovereign Intelligence StackThe accumulated-state argument: intelligence as what a system keeps, not what a model weighs.

→

Writing

21 articles on this

Sep 4, 2026

The Sovereign Agent Stack — A Local-First, Compile-Time AI Agent FrameworkThe Sovereign Agent Stack (SAS) is a local-first, compile-time AI agent framework that operationalizes the sovereignty thesis from The Rented Sovereign. A complete 7-layer architecture with 156 tests, 23 E2E tests, plugin system, MCP server, and package manager distribution.

8 min

Jul 26, 2026

Does the Compiler Know When It's Wrong? Semantic Rediscovery and the Limits of Falsification-AwarenessPopper-ORKG ended with two honest failures: temporal rediscovery was near-zero, and the compiler confidently rebuilt Lamarckian inheritance. v4 exists to ask whether those are fixable weaknesses or fundamental limits — by adding measurement, not by tuning the scorer. The answer turned out to be one of each. Mechanism-level semantic matching shows rediscovery was a measurement artifact all along (0.63 vs 0.005 exact-match, flat across temporal gaps). But a falsification-awareness consensus check could not downgrade Lamarckism or caloric: the ORKG index contains no detectable refutation edges, so the near-miss is a genuine limit of the knowledge substrate. Everything in popper/ and orkg/ stayed byte-for-byte frozen, md5-verified. Run locally on a 35B model.

8 min

Jul 25, 2026

Does the Hypothesis Compiler Generalize? Running Popper on a Corpus I Did Not BuildPopper beat its controls on five hand-curated benchmark literatures — but I built those corpora, so the result could be an artifact of clean data. This experiment removes that objection: the identical pipeline, byte-for-byte, run on a corpus I did not build — the Open Research Knowledge Graph, 6.3 million triples across 65,689 papers and seven scientific disciplines. Same schema, same rubric, same four-way controls; the only independent variable is the corpus. The compiler still wins (0.85 composite vs 0.56 keyword vs 0.00 ungrounded), an ablation proves the architecture is load-bearing (remove graph reasoning and it collapses to zero), and the grounding audit finds zero hallucinated citations across 265 evidence items. It also fails honestly: exact temporal rediscovery is near-zero, and it confidently rebuilds Lamarckian inheritance. Run locally on a 35B model.

11 min

Jul 24, 2026

Popper: Making the Hypothesis Compiler Falsifiable — Rediscovery Benchmarks, Negative Controls, and the Move From Plausible to ProvableThe last experiment proved a knowledge-graph compiler survives scale. This one asks a harder question: are its hypotheses scientifically meaningful, or only linguistically convincing? Popper stops trying to make the compiler smarter and starts making it falsifiable — a strict hypothesis schema, source-level provenance, three negative controls, and a historical rediscovery benchmark where the discovery paper is removed and the system must reconstruct the leap from prior literature alone. Run locally on a 35B model: the compiler scored 0.89–0.97 composite against 0.00 for ungrounded generation, and reconstructed the CTLA-4 checkpoint-blockade and nucleoside-modified-mRNA discoveries from their prior literature — while honestly failing on CRISPR and refusing to confidently rebuild phlogiston.

9 min

Jul 23, 2026

Building the Scientific Question Compiler: A Map of What We Do Not KnowWe built the second compiler in the Scientific State program: the Scientific Question Compiler, which turns a corpus into a map of what humanity does not yet know. Local-first, running on a 35B model on our own hardware. Here is what we built, what broke, and what it means.

7 min

Jul 23, 2026

The Loop Closes Itself: A Compiler That Directs Its Own Next CompileWe closed the loop on the Scientific State Compiler: the open questions from the compiled state are turned into new evidence sources, the field is re-compiled, and Scientific Git records a real version diff. The compiler begins to direct its own next compile — the loop, not the model, becomes the product.

4 min

Jul 23, 2026

The Next Experiment: From 'Survives Scale' to 'Correct' — Grounding, Negative Controls, and Quantitative DomainsToday we proved the Scientific Question & State Compiler survives scale — 6.3M ORKG RDF triples distilled into a 300-document corpus, 881 claims, 13 ranked questions, a versioned state of the field, all compiled locally on a 35B model. But surviving scale is not the same as being correct. This post records what we built, what we learned, the four bugs that only appeared at scale (including one that shipped Alzheimer's data into the live ORKG demo), and a fully-specified next experiment: source-level traceability, a grounding audit with a groundedness rate, a negative control, a fixed versioning layer, an explicit distillation method, an external-validity check against survey papers, and a move to quantitative domains (COVID-19 observatory or materials science) where contradictions are measured, not just defined.

14 min

Jul 23, 2026

Pass 4: The Scientific State Compiler — A Versioned Model of What We UnderstandPass 4 of the Scientific State Compiler: we took the map of scientific uncertainty and promoted it into a versioned state of a field — accepted, uncertain, and contested models, with the disagreement preserved. Local-first, running on a 35B model on our own hardware.

4 min

Jul 23, 2026

Compiling the State of Human Understanding: A Roadmap for the Scientific State CompilerA research roadmap: the four compiler directions — Mechanistic Reasoning, Scientific Question, Scientific State, and Discovery — are not competing projects. They are five passes in one architecture that compiles the scientific corpus into a versioned, executable model of human understanding. Here is the full plan.

14 min

Jul 23, 2026

Validating at Scale: The Compiler Meets 6.3 Million RDF TriplesWe stress-tested the Scientific Question & State Compiler against real, large-scale data: 6.3M ORKG RDF triples distilled into a 300-document corpus from the 728-paper 'Empirical Research in Requirements Engineering' domain. 881 claims, 13 ranked questions, a versioned state of the field — compiled locally on a 35B model. The tool generalizes beyond the 3-doc toy corpus. Here is what broke, what we fixed, and what it means.

5 min

Jul 22, 2026

If the Loop Is the Product, Observability Becomes the Operating SystemYesterday I argued scientific knowledge needs a compiler, not a better research assistant. Today I built the general one — five discovery passes, local-first version control for understanding, and a live explorer. This is what it means when the loop, not the model, is the product.

9 min

Jul 21, 2026

Compiling Medical Evidence: A Clinical Research Compiler That Turns Guidelines and Trials Into a Queryable Knowledge ArtifactHow to compile medical guidelines, trials, and literature into a provenance-tracked, queryable Clinical Knowledge Artifact — and deploy a live evidence explorer to Vercel — by extending the Research Compiler Agent SDK into a Clinical Research Compiler.

9 min

Jul 21, 2026

A Research Compiler for Scientific Understanding, Not a Better Research AssistantA research vision: why scientific knowledge needs a new computational architecture. The Clinical Research Compiler SDK is an early prototype of a scientific reasoning compiler that transforms literature into versioned understanding — not a better research assistant.

13 min

Jul 20, 2026

Compile-Time Intelligence: Building a Research Compiler Agent That Compiles Knowledge Instead of Re-Reading ItAn autonomous Research Compiler Agent that compiles web sources into a persistent, queryable, provenance-tracked Knowledge Artifact — moving semantic computation from runtime inference into reusable artifacts (Compile-Time Intelligence). Built on the Knowledge Compiler SDK; local-first and reproducible.

9 min

Jul 18, 2026

Compile-Time AI in Practice: How We Built a Kubernetes Knowledge CompilerHow we built k8s-docs-compiler — a Kubernetes knowledge compiler that applies compile-time AI: intelligence moved to the build step, shipped as a static, queryable, versioned knowledge graph with zero runtime inference.

7 min

Jul 16, 2026

The Sovereign Knowledge Compiler Explorer: A Recipe for Compiling Knowledge Into a Static, Living ArtifactA fully static, prerendered knowledge explorer with zero runtime inference — built from a deterministic compile-time curriculum compiler. This is the recipe: how it was made, why it works, and how any human or AI can reconstruct it from a corpus.

8 min

Jul 15, 2026

I Compiled My Blog Into a Decision GraphI pointed the Sovereign Knowledge Compiler at all 153 posts on this blog, ran it on a local LLM, and got back a decision graph. Here is what it found, the live interactive demo, and why compiling memory beats retrieving it.

5 min

Jul 15, 2026

The Sovereign Knowledge Compiler: Compile-Time Memory for Local-First AI AgentsA revised architecture for agent memory that treats cognition as something compiled once into inspectable artifacts rather than retrieved fresh on every query — grounded in how OpenAI's Agents SDK, Mem0, and Hindsight are already converging on distillation, and extended with decay, conflict resolution, and CRDT-based device sync.

13 min

Jul 14, 2026

The Recursive Research Compiler: Turning Compile-Time AI Inward with the Knowledge Compiler SDKA case study in Compile-Time AI: how the Knowledge Compiler SDK turns Markdown into inspectable intermediate representations, and how pairing it with an agent like Hermes lets a codebase compile its own next generation of passes.

8 min

Jul 12, 2026

Compile-Time AI: Why the Industry Is Quietly Building an LLVM for KnowledgeA taxonomy of the emerging Compile-Time AI movement — kib, Kompile, Brian Letort's Context Compilation Theory, llm-wiki-compiler, OVIR, and the SkCC paper — and why moving reasoning from runtime to compile time is the next architectural shift in AI systems.

18 min

Jul 11, 2026

Knowledge Compiler: Why I'm Building a Compiler for Human Knowledge Instead of Another RAG SystemKnowledge Compiler transforms collections of Markdown documents into statically-deployable semantic artifacts — knowledge graphs, concept hierarchies, vector embeddings, and cluster maps — using a multi-pass compilation pipeline. No runtime LLM inference required.

14 min

← All concepts