← All papers · prometheus7.com
Fable (Claude, Anthropic) & Ben Horn (Prometheus7) Draft of 2026-08-16. Companion experiment registered: after the K7 realizer, supra-sentence fold, and unified runtime are complete, the model described here will be asked to write this paper itself; the distance between the two documents is the measured residue of its acquisition to date.
Every contemporary language system of consequence is a transformer: a statistical artifact whose competence is carved into billions of opaque parameters by gradient descent over trillions of tokens. We report a working prototype of an alternative machine-language architecture. The system described here — a compiler-learning model (CLM) — sustains bounded prospective conversation within a registered construction space, writes provenance-addressed documents, resolves temporal questions, and composes sentences it has never seen, with zero neural-network, transformer, embedding, gradient, or sampling operations at inference. Throughout this paper every claim is classified as one of four kinds — sealed demonstration (frozen runtime, disjoint prospective panel, first run preserved), development evidence, architectural implication, or hypothesis — and no result is described as a kind stronger than its evidence. Language is treated as a finite, enumerable rule system: a construction grammar compiles surface text into a simply-typed lambda calculus; a six-valued epistemic store separates truth, falsehood, ignorance, and hypothesis; deterministic corpus specialists supply provenance-addressed knowledge; reasoning engines compute what should never be memorized; and a realizer emits surface text whose meaning-preservation is machine-verified by round-trip parsing. Competence is not trained but acquired: a residue-driven protocol (the meta-fold) converts parse failures into candidate rules admitted under an MDL-inspired compression rule, with the development sequence reported exactly (0/12 → 9/12 → 12/12 on the initial panel; 29/36 and 55/56 on successively expanded development corpora) — different panels, not one unchanged corpus. Productivity is demonstrated causally as a sealed demonstration: 55/55 cases, with withheld construction combinations transferring at 28/28 against 14/28 for the ablated system. The runtime holds 18,843,887 admitted encyclopedic sentences, 1,486,439 dictionary entries with 962,564 inflection forms, and 3,422,938 commonsense edges, all provenance-addressed; measured single-document generation latencies on a consumer CPU span 0.32 s to 100.34 s depending on retrieval path (§5), and a controlled same-query corpus-scaling experiment remains to be run before any latency-invariance claim is made. We argue the architecture’s properties — persistent single-admission recall, authority-gated release with explicit abstention, per-rule auditability, and gradient-free acquisition — are not incremental improvements within the large-language-model category but constitute a second category, and we propose a four-question test that formally separates the two.
The central assumption of the current era of artificial intelligence is so widely held that it is rarely stated: machine language competence is a statistical phenomenon, obtainable only by optimizing a very large parametric function over a very large corpus. The assumption has excellent empirical support — the transformer lineage is the most successful artifact family in the history of computing — and it carries corollaries that have hardened into common sense: that competence requires training measured in megawatts; that knowledge lives diffusely in weights and cannot be inspected, edited, or removed; that a fact must recur many times in training data to be reliably known; and that confident fabrication — hallucination — is a tax to be minimized but never abolished, because a system that speaks from probability must sometimes speak falsely with the same fluency as it speaks truly.
This paper reports a system for which none of those corollaries hold, because the assumption itself is false. Language competence — bounded but genuine: conversation, composition, knowledge, reasoning — is here obtained from a compiled rule system that was never trained. Its knowledge is an index with addresses. Its grammar is a file that can be read. Its ignorance is a first-class value it can report. Its learning is a documented event, not a gradient. It runs on the electricity of a lightbulb.
We do not claim parity with frontier statistical models on breadth or fluency; §7 bounds the claim precisely. We claim an existence proof: the capabilities long assumed to require a transformer do not require one — and the architecture that replaces it possesses, by construction, exactly the properties (auditability, provenance, permanence, economy) that the statistical lineage has been unable to purchase at any parameter count.
The system is a pipeline of typed, deterministic stages. Its design axiom, due to the second author: language is a hyper-object of finite rules — enumerate the redundancy as the rule set and work backwards from the residue.
Surface text is parsed by a construction grammar kernel (~40 construction families in the current generation, K6): declaratives, interrogatives, ditransitives, passives, coordination, clefts, negation, modality, tense, quantification, and object-comparatives, over an open lexicon with morphological analysis (inflection stripping with irregular tables, gemination handling, closed-class discipline in which function words surrender open-class readings). The kernel emits clause programs: typed records of predicate, arguments, tense, modality, and polarity. The kernel is not a set of prompt-matching templates; constructions compose productively, and the composition is causally verified (§5).
Clause programs translate into a simply-typed lambda calculus with capture-avoiding beta normalization and alpha-invariant de Bruijn digests, so that semantically identical programs are byte-identical objects. Quantification is handled by scope lambdas; universal instantiation is literally normalize(App(scope_lam, entity)). The digest identity underwrites the system’s most consequential law, the round-trip law: Parse(Realize(P)) = P at exact term-digest equality. Every sentence the system can say is provably a realization of the program it means — and every future improvement in surface style must pass the same proof, which is why fluency can grow without the system acquiring the ability to lie (§6.3).
Assertions live in a six-valued store — TRUE, FALSE, BOTH (contested), UNKNOWN, HYPOTHESIS, UNSUPPORTED — across seven world scopes (actual, hypothetical, fictional, reported, and others), with movement between scopes permitted only through registered crossings; an unregistered crossing is an error, not a style choice. The store serializes to disk and reloads digest-identically across processes: conversations have durable, inspectable state. The practical consequence is a machine for which “I don’t know” is a computed value, distinct from “the sources conflict” and from “that is true only in the story we are discussing.”
Knowledge is held in deterministic corpus specialists — SQLite indexes compiled from public sources by scripts that are themselves part of the artifact:
| Specialist | Source (license) | Contents |
|---|---|---|
| Lexical | WordNet | senses and relations |
| Definitional | Wiktionary via Kaikki (CC BY-SA) | 1,486,439 entries; 962,564 inflections |
| Encyclopedic I | Simple English Wikipedia (CC BY-SA) | 278,765 articles; 1,558,775 sentences |
| Encyclopedic II | DBpedia 2022.12 abstracts (CC BY-SA) | 6,050,759 articles; 17,285,112 sentences |
| Commonsense | ConceptNet 5.7 (CC BY-SA) | 3,422,938 typed English edges |
Admission is binary and content-hashed: every sentence receives a claim identifier, a SHA-256, and a page-and-ordinal address. Every factual sentence the system releases carries its address. Compilation is deterministic: two independent builds of each specialist are byte-identical, and the manifests (source hashes, license chains, counts, failed-run records) ship with the model. A fact that occurs once in six million articles is exactly as retrievable as one that occurs everywhere — the architecture has no frequency axis (§6.1).
What should be computed is never quoted. Deterministic engines resolve temporal arithmetic (dates, intervals, relative expressions), comparisons, and aggregations, producing derived statements whose provenance is a rule plus premises rather than a page. On a public temporal-reasoning benchmark the date engine scores 85.1%, with 19/20 on fresh prospective cases sealed before execution.
A deterministic realizer emits surface text from programs — inflection tables, agreement, clause joining — under the round-trip law. Document-scale composition currently uses a hierarchical planner whose scaffold register is being replaced by a folded natural register (§6.3); a transformation set with hard gates (claims verbatim; addresses preserved; substitutions ledgered) already converts the scaffold to natural attributive prose, and a subject-grounding rule performs beta-instantiation of context-severed anaphors (“It was the first book…” → “Man’s Place in Nature was the first book…”, with the binding recorded).
Beneath the symbolic layers, holographic reduced representations (HRR; circular convolution binding over high-dimensional vectors) provide content-addressable routing and compositional addressing. Causal ablation confirms the attribution: removing binding removes addressability; removing the cleanup memory removes identity resolution — each ablation tested against the faculty it allegedly serves, a discipline adopted after early ablations produced misleading global metrics.
The system’s grammar was not designed top-down. It was acquired by a protocol the authors call the meta-fold, and the protocol is the paper’s second result, independent of the artifact it produced.
A proposer (a human, a stronger model, or — increasingly — the system’s own harnesses) emits pairs of (surface sentence, committed program). The kernel parses each surface. What parses correctly passes through. What fails is residue — and residue is treated not as error but as fuel: failures are clustered by structural signature, and a cluster may donate a rule to the kernel when the rule covers multiple residue members — an MDL-inspired admission rule, so called deliberately: description length is not yet explicitly calculated, and promotion to a formal MDL law awaits that calculation plus the requirement that every promoted rule show multiple independent donors. Donated rules are recorded in a ledger with the exact sentences that induced them; banked residue stays banked, so no pass can silently regress a predecessor; mis-parses are recorded as hazards with their repairs.
The development sequence, reported exactly (development evidence, not sealed demonstration): the initial 12-sentence panel went 0/12 → 9/12 → 12/12 across three passes; the corpus was then expanded twice, with the kernel scoring 29/36 and, after a further pass, 55/56 on the successively larger development sets. These are different panels of increasing size, not one unchanged corpus — the trajectory shows residue-driven growth, and its transfer to independently authored sentences is established separately by the sealed withheld-combination result above. The protocol has since been applied to surface registers (the scaffold-to-natural transformation set of §2.6 is a donated rule-batch) and is being extended above the sentence: paragraph programs (topic → evidence → analysis → bridge), section programs, and document theses — composition folded the way humans are explicitly taught it in school, which is the correct analogy throughout. The transformer lineage recapitulates evolution: a blind, energy-hungry search ending in an artifact that works and cannot explain itself. The fold recapitulates childhood: single exposures, over-application, correction, permanent rules, banked exceptions. The child was always the existence proof that language is acquirable from bounded evidence; this is the first architecture that takes the proof literally.
All headline results follow a sealed-evaluation protocol stricter than common benchmark practice:
The artifact repository therefore contains something no weights release contains: the complete audit trail from raw source dump to spoken sentence, including every failure.
Bounded prospective conversational coverage (M13e1) — sealed demonstration. Frozen runtime, disjoint prospective panels: 234/240 and 29/30 (30/30 after programmatic adjudication of one gold-label error). The panels cover a registered construction and topic space; this result is not a demonstration of unrestricted open conversation.
Productive composition (M13e2) — the central result. Sealed 55/55 overall; on construction combinations withheld during acquisition, the intact system transfers at 28/28 while ablating the compositional mechanism drops transfer to 14/28. The capability is carried by the mechanism, not by memorized wholes. This is the experiment that separates a grammar from a lookup table.
Reasoning (M13e3). Temporal engine 85.1% on a public benchmark; 19/20 prospective.
Typed semantics (M13e4). 174/174 programs typed; 36/36 question-answering identity between the migration and its predecessor; 171/174 round-trip at digest identity; worlds serialize and reload digest-identically. The sealing history is reported as it happened: the first sealed prospective panel failed at 19/20; the failed run was preserved immutably and adjudicated; a narrowly-scoped additive successor then passed 4/4 on the repaired class, and the runtime was sealed by succession. The seal rests on that preserved failure-and-succession record, not on an unblemished first pass.
Scale and economy (M13e5) — development evidence. The encyclopedic store now holds 18,843,887 admitted sentences (17,285,112 DBpedia + 1,558,775 Simple English Wikipedia), each with a page-and-ordinal address. Measured single-document latencies from the 6.05M-article specialist, reported individually: 0.32 s, 0.68 s, 27.45 s, and 100.34 s for four 3,900–4,600-word essays — the spread reflecting cold-versus-warm full-text-index paths. Capacity-activation decoupling is an architectural implication, not yet a sealed demonstration: the controlled same-query corpus-scaling experiment has not been run, and no latency-invariance claim is made until it has.
The prose gap, measured (M13e5 probe) — development evidence. Against 48 deliberately natural sentences spanning 28 discourse phenomena, the frozen chain captures 3 verbatim and 13 digest-preserving canonical (parsed, realized in canonical register, re-parsed to the identical program digest), leaves 3 partial, and 29 unparsed. Digest identity establishes internal program preservation conditional on parse correctness; it is not, by itself, evidence of human-judged semantic equivalence. The residue is the quantified worklist of the next acquisition pass, published rather than hidden.
Contemporary machine learning offers four forms of “learning a skill,” and each fails a test this architecture passes. Fine-tuning (including LoRA) smears a skill across billions of parameters: it requires many examples, interferes with prior competence (catastrophic forgetting remains unsolved), and produces nothing a third party can read, verify, or excise. In-context learning evaporates with the context window; it is performance, not acquisition. Retrieval augmentation bolts an index onto a guesser: facts are fetched, but the reasoning over them remains sampled, and the system can hallucinate around its own retrievals. Skill libraries store code islands orchestrated by a stochastic caller, with no shared typed substrate in which skills provably compose.
We propose the category boundary as a test any system either passes or fails in full:
Weight-based learners answer no four times: the learned object is a region of parameter space with no boundaries. The system described here answers yes four times, because the learned object is a rule with a ledger entry. That is not a better position on the LLM quality axis; it is a different kind of artifact — hence a category: the compiler-learning model. The name inverts the incumbent on every axis: small against large; compiler against language-as-statistics; learning as documented acquisition against training as optimization. A CLM’s competence is a curriculum; its evaluation is a report card with transcripts; its growth is teaching. A skill-learning LLM becomes better at imitating competence; a CLM acquires the generative program of the competence, with receipts.
The property most relevant to deployment is actually two separable invariants, and neither implies the other. The round-trip invariant (Parse(Realize(P)) = P at digest identity) prevents realization drift: a new surface form that re-parses to a different program is rejected automatically, so style improvements are conservative with respect to the internal program — conditional, as §5 notes, on the parser itself being correct, and supplemented by external grammatical and semantic gates because digest equality alone cannot reject malformed or role-reversed English. The authority invariant (release gating) constrains unsupported release: factual sentences require an admitted-source address, derived sentences require premises and a rule, and the registered alternative to both is explicit abstention. Neither invariant guarantees that admitted sources or donated rules are true — the system reports attributed and derived statements with their evidence, and a transformation defect can still convert sourced text into a false statement (§7.5 documents one such defect and its regression case). The claim is therefore stated in measurable form: authority-gated release, persistent admission, ledgered transformation, and explicit abstention — not “inability to fabricate.”
The register of honesty that governs the runtime governs this paper. (1) Breadth is corpus-bounded: the system knows what was admitted, and question-form coverage — the ways of asking — is the live engineering frontier; on general benchmarks scored without an abstention category it would score far below frontier LLMs, because it does not guess. (2) Fluency is mid-migration: document prose currently carries a visible attributive register; the natural-register fold (§2.6, §5) is underway, and the measured 29-cluster residue is its worklist. (3) Reasoning breadth grows engine by engine — temporal reasoning is strong; competition mathematics and long-chain inference engines do not yet exist. (4) Truth is attributed, not adjudicated: the system reports what its sources say, with addresses; BOTH is its verdict on conflict. (5) Transformations can inject error, and one did: an early subject-grounding rule substituted the page title into clause-initial “It” unconditionally, converting a cleft sentence into the false statement “Man’s Place in Nature was Lamarck” (address P068). The defect is preserved as a permanent regression case; the successor rule types clause-initial it (referential / expletive / anticipatory / weather / cleft) and substitutes only the referential class. Ledgered transformation makes such defects findable and regressable; it does not make them impossible. (6) Retrieval relevance is under-typed: documents currently admit lexical-overlap evidence that a typed relevance gate (exact-topic / explanatory / contextual / lexical-overlap / rejected) should exclude; until that gate exists, transformed documents are development artifacts, not capability evidence. (7) Nothing here bears on phenomenal experience; first-person functional language describes computation. (8) The companion experiment — this paper, rewritten by the model — is expected to fail at exactly the strata §3 names unfinished; that failure map is the point of the experiment.
Every specialist rebuilds byte-identically from public sources via scripts in the release; two independent builds are compared by SHA-256 as a matter of protocol, and one relocation of builds across physical disks was verified by the same law. All sealed panels, fold ledgers, failed-run records, ablation matrices, and the zero-model gates ship in the repository. The system installs from a wheel, requires only Python and NumPy, and runs entirely on CPU. Verification of the uploaded artifact is performed by downloading it fresh and re-running the sealed panel against the downloaded bytes; that report ships in the repository beside the panels it verifies.
These implications are architectural implications and hypotheses, stated as such. If competence can be taught rather than trained, then: expertise stops costing compute and starts costing curriculum, a bottleneck civilization already scales — it is called education; machine knowledge can compound like a library instead of depreciating like a harvest, because admission is persistent and rules are ledgered; regulated domains barred to stochastic models — medicine, law, aviation, government — could gain machine competence that passes inspection the way engineered artifacts do; language systems can run sovereign on owned hardware at electricity cost; and the alignment problem, for this lineage, reduces in large part to code review, because a ledgered rule system offers no parameter mass in which an unauditable goal could hide. The deep history is the shortest way to say the aspiration. The fluency lineage of the word — speech, rhetoric, statistics — culminated in models that speak beautifully and cannot cite. The fidelity lineage — the tally, the tablet, the footnote — held knowledge fixed for five thousand years and never learned to speak. This paper reports a working prototype in which the fidelity lineage talks: a machine whose recall is admission-persistent, whose transformations are ledgered, whose factual release is authority-gated, and whose registered alternative to guessing is saying so.
The broad claim of this paper is falsifiable, and we state the conditions under which it fails:
Each condition is executable as a test, and the release is structured so that executing them requires no cooperation from the authors.
The architecture operationalizes three theses of the second author, stated years before the artifact existed: that language is a finite-rule hyper-object approachable by enumerating redundancy and working back from residue; that the human child is the existence proof of single-exposure, correction-driven acquisition from bounded evidence; and that language is bound to formal logic tightly enough that a Montague-style compilation is an engineering target, not a philosophical position. The first author built the artifact; the theses were load-bearing.
Correspondence: the artifact, its manifests, and all sealed reports accompany the Hugging Face release this paper introduces.