The Knowledge Compiler
The Knowledge Compiler is the core pipeline of the platform: it takes a source — a book, corpus, or person-corpus — and compiles it through six stages into an executable skill. This page documents each stage, its inputs and outputs, and the verification gates between them.
Mental model
Treat the compiler like a language compiler for knowledge. The source is the program. Each stage is a lowering pass that preserves meaning while increasing formality. The CIR (Causal Intermediate Representation) is the intermediate representation. The skill is the emitted binary.
The defining property is loss-with-receipts: compression is allowed, silent loss is not. Every stage records what it extracted, what it discarded, and why — so any downstream failure can be traced back to the exact pass that introduced it.
Source
│
▼
[1] Document → Entities (segmentation, NER, vocabulary)
│
▼
[2] Entities → Concept Graph (relations, clustering)
│
▼
[3] Graph → Causal Structure (mechanisms, rules, dependencies)
│
▼
[4] Causal → CIR (typing, hypergraph)
│
▼
[5] CIR → Architecture (generators, A4 compression, G-A-S-O)
│
▼
[6] Architecture → Skill (executable spec, deployment)Stage reference
Document → Entities
Named entity recognition, domain vocabulary extraction, and terminology mapping. The source is segmented and its atomic units of meaning are identified and typed.
Entities → Concept Graph
Semantic relationship extraction, concept clustering, and graph construction. Isolated entities become a connected structure of concepts and relations.
Concept Graph → Causal Structure
Causal mechanism identification, transformation rule extraction, and dependency mapping. The graph stops describing what is and starts modeling what causes what.
Causal Structure → CIR
Formal type assignment, relationship typing, and hypergraph construction. The Causal Intermediate Representation is the platform’s canonical compile target.
CIR → Architecture
Generator identification, A4 compression, and G-A-S-O layer mapping. The representation is compressed to its irreducible generative machinery.
Architecture → Skill
Executable specification generation, capability extraction, and deployment format. The compiled architecture projects into a runnable skill.
Abstraction altitudes
Extracted structures are tagged with an altitude — how far the structure sits from its surface details. Lower altitudes preserve domain specifics; higher altitudes capture domain-neutral machinery. The A4 band is where cross-domain isomorphisms become detectable: the same generator expressed in physics, in myth, and in systems engineering.
Narrative, examples, domain vocabulary. High fidelity, low transferability.
Generators, state machines, feedback loops, transformation rules. The compression sweet spot.
Formal families and invariants: conservation laws, transition systems, type constraints.
Verification gates
A compiled artifact cannot be promoted past its origin stage without passing that stage's gate: extraction fidelity checks, formal type checking, recurrence and transfer verification, and — for emitted skills — execution grading against a real test harness.
Self-graded verification is a hard ceiling: no self-graded artifact may be marked verified. This rule is enforced by the pipeline, not by convention.
Try it
Run the pipeline interactively in the Knowledge Compiler, or browse recovered architectures in the library.