Causalontology

_{Benchmark scores by the reference implementation, PrologAI, on the public training sets — pure symbolic induction, no LLM.}

What do these badges mean? — a plain-language guide to every ribbon (click to open)

Each badge above is a claim, and every claim deserves a plain explanation. Here they are, row by row, written for a newcomer. (The label side of each ribbon is a neutral grey, matching the PrologAI and Mentova badges; the colored right side runs a single warm fade across the project's official eight-color palette - from bright gold-yellow at the first honor, down through the oranges and reds, to a deep crimson-black at the license. See BRANDING.md.)

Row 1 — The Honors

ARC-AGI-1 | 400/400=100% — ARC-AGI stands for the Abstraction and Reasoning Corpus for Artificial General Intelligence: a famous series of public tests designed to measure whether a machine can genuinely reason about puzzles it has never seen, rather than repeat patterns it memorized. This badge says that Causalontology's reference implementation, PrologAI, solved all 400 of 400 tasks in the first benchmark's public training set — a perfect score — using pure symbolic induction: readable logic rules discovered from the puzzle examples, with no Large Language Model (no LLM — the text-predicting technology behind modern chatbots) involved at all. The badge links to PrologAI so you can inspect the work.
ARC-AGI-2 | 120/120=100% — the same story for the second, harder generation of the benchmark: all 120 of 120 public tasks solved, a perfect score, by the same glass-box symbolic methods. (Honesty note, exactly as the fine print says: both scores are on the public training sets — the openly published task collections — stated precisely and without inflation.)
WORLD'S FIRST | REIFIED CAUSATION ONTOLOGY STANDARD — the centerpiece claim. To reify means to turn an idea into a thing you can hold, name, and examine — here, turning "A causes B" from a bare arrow into a full object carrying its timing, its strength, its conditions, and its evidence. An ontology is an organized inventory of what exists and how things relate. A standard is a published specification anyone can implement, in any programming language, with a shared test suite deciding what counts as correct. This badge claims Causalontology is the first to deliver all three in one: causation, made into first-class objects, as an open standard.

Row 2 — The Standard

CONFORMANCE VECTORS | 137 — a conformance vector is a published test case: an input and the exact result a correct implementation must produce. There are 137 of them in this repository (V01–V38 the re-frozen original suite, V39–V119 the 2.0.0 and 3.0.0 additions, V120–V137 the 4.0.0 additions), and the rule is simple: an implementation is Causalontology-conformant if and only if it passes every one. This is how a Python version, a Java version, and a Prolog version can all be guaranteed to agree without sharing a single line of code.
OBJECT KINDS | 21 — everything in Causalontology is one of exactly twenty-one kinds of object: ten type-tier content kinds (occurrent, causal_relation_object, continuant, realizable, stratum, bridge, cross_stratal_seam, port, conduit, quality), seven token-tier content kinds (token_individual, token_occurrence, state_assertion, token_causal_claim, and the three 4.0.0 arrivals attitude, predicted_occurrence, prediction_error — a particular history, local by default), and four provenance kinds (assertion, enrichment, retraction, succession — the signed records saying who claims, adds, withdraws, or rotates what). Twenty-one kinds, no exceptions — a learnable vocabulary for all causal knowledge, at every level of description and for both laws and histories.
LOCKED DECISIONS | 30 — the specification records 30 design decisions as locked: settled on purpose, in writing, so builders can proceed without the ground shifting under them (the original twenty-seven of the 1.0.0 lineage, plus three locked in the 2.0.0 re-mint — the new kinds and token tier, the bridged-reachability and skips changes, and Principle P7's whole-word naming). The register has since been amended twice, each time by EXTENSION rather than override: the 3.0.0 amendment added three extension decisions, and the 4.0.0 amendment added five more. Changing one requires a formal, versioned process — not a quiet edit.

Row 3 — The Foundations

CANONICAL | RFC 8785 — an RFC (Request for Comments) is a published internet standard. RFC 8785 defines one exact, byte-for-byte way to write a piece of JavaScript Object Notation (JSON) data, so that the same information always produces the same bytes regardless of who wrote it or how they formatted it. Causalontology uses it so that identity can never depend on formatting accidents.
IDENTITY | SHA-256 — SHA-256 (the Secure Hash Algorithm, 256-bit) is a mathematical fingerprint function: feed it any content and it produces a unique fixed-length code, and any change to the content changes the code. In Causalontology, an object's identity IS the fingerprint of its content — which means two strangers anywhere on Earth who express the same causal claim automatically produce the same identifier, and their contributions merge with no coordinator.
SIGNED | ED25519 — Ed25519 is a fast, widely trusted digital signature scheme. A signature is mathematical proof that a specific keyholder — and nobody else — produced a record. In Causalontology every assertion, every added word, every retraction is signed, so every piece of knowledge in the commons has a verifiable author, and forging someone else's contribution is impossible.
JSON-LD | LINKED DATA — JSON-LD (JSON for Linked Data) is a way of writing ordinary JSON so that it is simultaneously valid linked data — the web-standard format that lets knowledge from different sources connect into one global graph (the technology family behind Wikidata). Causalontology data speaks that language natively, so it can plug into the wider knowledge ecosystem for free.

Row 4 — The Character

GLASS BOX | ALWAYS — a black box gives you an answer but hides its reasons; a glass box lets you see every step. Everything here is inspectable: every claim traces to a named rule and a signed author, and you can always ask "why?" and get a readable answer. This is the project's deepest commitment.
STIGMERGY | BUILT IN — stigmergy is coordination through the shared environment itself: the way a half-built wall shows the next worker exactly where the next brick goes. In Causalontology, incomplete knowledge is visible and queryable — a claim missing its timing, a term nobody has defined, two claims that contradict — so the store itself continuously announces what most needs doing next, and any contributor (human or machine mind) can ask for the most valuable gap and fill it.
EVIDENCE | ACTING > WATCHING — Causalontology grades its evidence, and the top grade is intervention: the source acted and observed what followed, like a child flipping a switch rather than staring at it. Acting breaks the ambiguity that haunts pure observation — a coincidence in the data cannot survive your own hand on the switch. Every piece of knowledge carries its evidence grade, so consumers can weigh doing above watching.

Row 5 — The Lineage

FLAGSHIP APPLICATION | MENTOVA PROLOGAI — PrologAI is the glass-box cognitive architecture that serves as Causalontology's reference implementation, and Mentova is the synthetic mind built on it — the first full application of this ontology, and one day the first machine mind to read the commons' gaps and contribute causal knowledge back. The badge links to Mentova.
BOOK | AGI'S MISSING LINK — this repository is the data-structure layer of the book Causalontology: AGI's Missing Link, whose thesis is that the component most conspicuously missing from today's AI is an explicit, learnable, inspectable model of cause and effect, acquired by acting on the world. The complete, lay-readable canon is right here: Causalontology_Standalone_Design_v27.txt.
LICENSE | ATTRIBUTION ALWAYS; NO PROFIT, NO PROBLEM — the project's license, in its own words: credit the source always, and using it without profit is never a problem. It is the friendly name for the Apache License 2.0 text (see LICENSE and NOTICE), one license covering everything here — the code, the data, the specification, and the architecture.

Causalontology

"Where The Universe is concerned, Nouns are but guests in the House of Verbs." — D. R. Dison

A verb-first noun-hosting ontology — reality is what happens, and things are its participants. A programming-language-neutral standard and a shared global commons for reified causation — the data-structure layer of the book Causalontology: AGI's Missing Link.

The World's First

Causalontology's identity, stated from five angles — each the same claim, that this is a first-of-its-kind synthesis:

Reification / Timing / Learning. "Causalontology is the world's first synthesis of reified causal representation, temporal-mechanistic modeling, and interventional learning into a single glass-box unified ontology."

Noun / Verb Governance. "Causalontology is the world's first synthesis of a process-first causal calculus, a continuant noun backbone, and a realizable hinge between them — one foundational ontology governing the verbs and hosting the nouns."

The Bridge. "Causalontology is the world's first synthesis of symbolic causal reasoning, the philosophy of process, and embodied interventional learning, unified in a single glass-box ontology."

Scholarly Framing. "Causalontology is the world's first synthesis of process ontology, causal modeling, and constructivist learning into a single foundational ontology."

Succinctly. "Causalontology is the world's first synthesis of reification, temporal causation, and interventional learning in one unified, glass-box ontology."

And this repository adds a further first of its own: to our knowledge, the first specification to deliver reified, provenance-signed causation as a programming-language-neutral standard with a shared, stigmergic commons — offered, glass-box style, with its evidence: the specification, the conformance vectors, and the running implementations, all inspectable.

Every term above is explained for a newcomer in the master document: Causalontology_Standalone_Design_v27.txt — the complete, self-contained canon of this repository.

What is Causalontology?

Causalontology is a verb-first noun-hosting ontology. Verb-first: the atomic building block is the occurrent — the happening — and the fundamental unit reifies the master verb, causes, itself; even knowing is verb-first, because knowledge enters by acting (intervention) or by active watching — where the viewer identifies with the actor and internally simulates the action, as when you learn a dance from an instructional video — rather than by passive watching, through which little enters (2.0.0 gives that internally simulated intervention its own simulation evidence grade, distinct from raw observation and physical intervention). Noun-hosting: things (continuants) are first-class citizens, but they are understood through what they do and what happens to them — Causalontology governs the verbs and hosts the nouns, with realizable entities as the hinge between them.

Causalontology's purest form is a specification, not a program. It separates the data structure of causation and its rules (programming-language-neutral) from any implementation (twenty exist, from Prolog to Kotlin/Native). Two familiar pictures, held together:

A standard — like a W3C or IETF specification: a normative document plus a conformance test suite, with independent implementations that all agree because they all pass the same tests.
A commons — like Wikidata, specialized to causation: one shared, world-wide, provenance-first store of causal knowledge that developers everywhere (and autonomous minds) draw from and contribute to.

The reference implementation is PrologAI, a glass-box cognitive architecture, driving the synthetic mind Mentova.

Now at 4.0.0 - three additions, all additive

Causalontology is now at version 4.0.0. It is a major version because it adds three new object kinds - by the standard's own rule, that is always major - but for anyone adopting it the step is gentle: everything is additive, and no record you already hold changes.

This release was earned, not guessed. The standard's discipline forbids adding capabilities from the armchair: the 4.0.0 change order sat gated until konnectome - the glass-box regional-brain build on this substrate - hit two real walls in a real build (2026-07-22): it could hold another agent's false, nested belief privately but could not share it as a signed, evidence-graded, content-addressed record, and its prediction loop could compute a prediction error each tick but could not record an expected occurrence as distinct from an observed one. Those two findings, with the owner's written authorization, opened the gate; the change order's remaining candidates stay held, each awaiting its own finding.

Three things arrive, all token-tier:

The attitude - the doxastic kind. attitude records that a HOLDER - a modeled agent inside the ontology, never a cryptographic key - believes, desires, intends, knows, expects, or fears some content, referenced by identity. The content may be FALSE (an attitude records what a mind contains, not what is true, and a false belief raises no conflict - that mismatch IS the false belief, first-class and shareable), and it may be another attitude, so "A believes that B believes X" is a two-level structure. This is the substrate of theory of mind.
The predicted occurrence - the expectation. predicted_occurrence is the sibling of token_occurrence that has not (yet) happened: the occurrent type a predictor expects, at a stated wall-clock or ordinal-tick window (exactly one dimension, never both), with an optional identity-bearing strength - the predicted probability, part of the predicted content itself. A prediction is NOT a claim of fact: a forecast and a report of the same content carry different identifiers.
The prediction error - the comparator's signal, reified. prediction_error pairs a prediction with the occurrence that did - or did not - fulfil it (an absent observed means nothing arrived), carrying the signed, graded discrepancy, read actual-minus-expected. The predictive loop becomes first-class and inspectable rather than a transient number.

With these, the vocabulary grows from eighteen kinds to twenty-one (the token tier from four to seven), and the conformance suite grows from 119 vectors to 137 (all green in the Python reference binding).

Migration from 3.0.0. Nothing you already have breaks. All three additions are additive and identity-preserving: because an object's identity is the fingerprint of only the fields it actually carries, every valid 3.0.0 record keeps its identifier byte-for-byte and stays valid under 4.0.0 - witnessed directly by vector V136, which re-pins the exact frozen 3.0.0 bytes under the 4.0.0 implementation. To adopt, a consumer need only add support for the three new kinds so that it can accept records that use them; a consumer that never encounters them needs no change at all. The 119 vectors of 3.0.0 are unchanged, and the 4.0.0 gate is simply their superset: the full 137-vector suite.

The normative source for all of this is the Standalone Design, Causalontology_Standalone_Design_v27.txt; the per-language rollout plan lives in docs/Causalontology_4_0_0_Release_Plan.txt.

The Twenty-One Kinds of Thing

Ten type-tier content kinds — pure, immutable, content-addressed (SHA-256 over RFC 8785 canonical bytes):

Kind	Prefix	What it is
Occurrent	`occurrent:`	a process or event type (a verb), optionally pitched at a `stratum`
Causal Relation Object	`causal_relation_object:`	the fundamental unit: a reified causal claim — causes, effects, mechanism, temporal window, modality, context, `refines` lineage, `skips`
Continuant	`continuant:`	a thing that endures (a noun)
Realizable entity	`realizable:`	a disposition, function, or role — with an identity-bearing `label`
Stratum	`stratum:`	a level of description within a named stratification scheme
Bridge	`bridge:`	a cross-stratal identity map: one coarse occurrent IS a set of finer ones
Cross Stratal Seam	`cross_stratal_seam:`	3.0.0 — a managed jump across non-adjacent strata: endpoints, an honest `mechanism_status` (`unmodeled` vs `absent`), an optional drawn `chain`, and the coarsest-stratum home rule
Port	`port:`	a typed interface borne by a continuant
Conduit	`conduit:`	a typed connection from port to port — a pipe, or a computer
Quality	`quality:`	a property type a thing can bear

Seven token-tier content kinds — immutable, content-addressed, local by default (see spec/safety.md):

Kind	Prefix	What it is
Token Individual	`token_individual:`	a particular thing (THIS one)
Token Occurrence	`token_occurrence:`	a particular happening, at absolute time
State Assertion	`state_assertion:`	a particular value over a particular interval
Token Causal Claim	`token_causal_claim:`	a particular causing, optionally under a covering law
Attitude	`attitude:`	4.0.0 — what a HOLDER's mind contains: a modeled agent `believes` / `desires` / `intends` / `knows` / `expects` / `fears` a content object — the content may be false, may be another attitude (nesting), and the holder is never the signing key
Predicted Occurrence	`predicted_occurrence:`	4.0.0 — an occurrence a predictor EXPECTS at a stated wall-clock or tick window — an expectation, never a report; optional identity-bearing strength (the predicted probability)
Prediction Error	`prediction_error:`	4.0.0 — the comparator's signal, reified: a prediction paired with the occurrence that did (or did not) fulfil it, carrying the signed discrepancy, actual minus expected

Four provenance kinds — signed (Ed25519), add-only records:

Kind	Prefix	What it says
Assertion	`assertion:`	who claims it, on what evidence (intervention > observation > simulation), how strongly, optionally citing token `evidenced_by`
Enrichment	`enrichment:`	who added which alias, participant, or taxonomy link — every word has an author
Retraction	`retraction:`	a source's honest withdrawal of its own record — history never erased
Succession	`succession:`	key rotation with lineage

The load-bearing decision: content is separated from provenance, uniformly. The same claim from any number of sources is one object; contradictory claims coexist, each with signed provenance; trust is a consumer-chosen policy, never forced consensus. The whole store merges by set union — a Conflict-free Replicated Data Type (CRDT) by construction.

Storage and federation — the commons is a network, not a server

No single machine holds the commons, and by design none has to. Because every object's identifier is the SHA-256 hash of its own content and the store merges by set union with no coordinator — the same math as the InterPlanetary File System (IPFS), Git, and Dat — the commons is a peer-to-peer federation: many nodes, each holding some of the data, gossiping new objects and converging to the same whole regardless of order. This is now live and self-healing: nodes gossip each new record to their peers as it arrives and a background anti-entropy pass reconciles any two replicas by comparing Merkle roots and shipping only the delta, so the commons converges even when gossip is dropped or a peer restarts — every inbound item verified by hash and signature, no coordinator, token tier not federated by default. With phase four merged, the four-phase storage-and-federation build is now complete — a durable, self-healing, horizontally scalable commons that anyone can read from a light client, cache at the edge, or help host a slice of; what remains is adoption, not architecture.

Tiers of participation. Full nodes hold everything; partial nodes hold a slice (sharding is trivial because identity is a hash); light clients hold almost nothing and verify locally, trusting no one — every record is signed (Ed25519) and self-certifies by its hash.
What bounds the size. The commons federates laws (the type tier), not diaries (the token tier, local by default) — nearer Wikidata-scale than "every experience of every mind."
Free storage properties. Immutable content-addressed objects give deduplication, integrity (the hash is the checksum), and permanent caching for free; a node is a content-addressed blob store plus a locally rebuilt index.
Durability before adoption. Signed snapshot dumps (like Wikidata's), shipped over IPFS, BitTorrent, or Hypertext Transfer Protocol Secure (HTTPS) and verifiable byte-by-byte, give global redundancy before a single live peer is recruited. Now available: a genesis node exports a deterministic, content-addressed snapshot committed by a Merkle root and signed with its Ed25519 key, with a detached checksum and signature — anyone can verify every byte and stand up a mirror by union-merge (token tier excluded by default). See spec/snapshot.md.
The phased build. (1) a persistent content-addressed node — done: the reference Tier A store is now durable (SQLite in write-ahead logging (WAL) mode), idempotent by content address, and integrity-checked on write, with every endpoint and byte unchanged; (2) a genesis full node plus signed snapshot dumps — done: deterministic, Merkle-committed, Ed25519-signed dumps, verifiable offline and mirror-able by union-merge, token tier excluded by default; (3) live Tier B federation with gossip and anti-entropy — done: nodes gossip new records to configured peers (batched, idempotent, loop-free) and a background pass reconciles by Merkle-root comparison and delta-only exchange, every inbound item verified by hash and signature before merge; (4) light clients, content-delivery network (CDN) caching, and hash-prefix sharding — done: a light client holds almost nothing and verifies every object by hash and every record by signature; immutable content carries immutable cache headers and an entity tag (ETag) equal to its identifier, cacheable forever behind any CDN, while mutable views are not; and a partial node holds only a hash-prefix slice, advertised on GET /shards and resolvable across nodes, with phase-three federation running per shard. All four phases are delivered — the build is complete.

Full design: Part 21, "Commons Storage and Federation Design," in the canon (Causalontology_Standalone_Design_v27.txt).

Quickstart (30 seconds)

{ "type": "occurrent", "label": "press_button", "category": "action" }
{ "type": "occurrent", "label": "light_on",     "category": "state_change" }
{ "type": "causal_relation_object", "causes": ["occurrent:press_button"], "effects": ["occurrent:light_on"] }

That third document — a degenerate causal_relation_object, just cause and effect — is already valid, and the store lists it as a gap inviting enrichment (GET /gaps?kind=missing_field). Someone (or some mind) later refines it with a temporal window and modality, and the gap visibly closes. That is stigmergy: the structure's own partiality guides the next contribution. Full walkthrough: examples/quickstart.md.

Install (one line, your language)

Honest install note at 4.0.0. The registries below still carry the 2.0.0-era packages — no 3.0.0 or 4.0.0 package has been published yet. The specification in this repository is 4.0.0 (twenty-one kinds, 137 vectors); each binding publishes 4.0.0 only after it passes the full 137-vector suite installed fresh from its registry, per docs/Causalontology_4_0_0_Release_Plan.txt; as of 2026-07-22 all nineteen bindings pass the full 137-vector suite locally in this repository (green code), but none is published — publication needs the owner's registry credentials and, for several languages, a standing human gate. The table records what is actually installable today.

Language	Command
Python	`pip install causalontology==2.0.0` (2.0.0 live on PyPI; 1.0.0 yanked)
JavaScript / TypeScript	`npm install causalontology` (typings included; 2.0.0 live on npm, 1.0.0 deprecated)
Rust	`cargo add causalontology` (2.0.0 live on crates.io; 1.0.0 yanked)
Java	`io.github.ai-university-aiu:causalontology:2.0.0` (Maven Central)
Kotlin/Native	`io.github.ai-university-aiu:causalontology-kotlin:2.0.0` (Maven Central, linuxX64 klib)
C# / .NET	`dotnet add package causalontology` (2.0.0 published, indexing; 1.0.0 unlisted)
Ruby	`gem install causalontology` (2.0.0 live on RubyGems; 1.0.0 yanked)
PHP	`composer require causalontology/causalontology` (2.0.0 live on Packagist; earlier tags remain)
Dart	`dart pub add causalontology` (2.0.0 live on pub.dev; 1.0.0 retracted)
Elixir / Erlang	`{:causalontology, "~> 2.0"}` (2.0.0 live on Hex; 1.0.0 retired)
Lua	`luarocks install causalontology` (2.0.0 live on LuaRocks; 1.0.0 remains listed)
Swift	`.package(url: "https://github.com/ai-university-aiu/causalontology", from: "2.0.0")` (2.0.0 via SwiftPM git tag; Swift Package Index listing submitted — PackageList PR #14440)
Go	`go get github.com/ai-university-aiu/causalontology/bindings/go/v2@v2.0.0` — 2.0.0 uses the `/v2` module-path suffix (Go's major-version rule); import `.../bindings/go/v2/causalontology` (the v1 module line is deprecated and retracted via `bindings/go/v1.0.1`)
Zig	`zig fetch --save https://github.com/ai-university-aiu/causalontology/archive/refs/tags/v2.0.1.tar.gz`, then `dep.module("causalontology")` and `@import("causalontology")` (the repo-root manifest lands at `v2.0.1`; Zig pins this patch tag)

Published at specification 1.0.0 (vectors frozen 2026-07-13), except PyPI, npm, crates.io, NuGet, RubyGems, Hex, LuaRocks, Packagist, pub.dev, and both the Java artifact and the Kotlin/Native klib on Maven Central, now republished at 2.0.0 (the whole-word re-mint; the superseded 1.0.0 releases yanked on PyPI, crates.io, and RubyGems, deprecated on npm and Hex, unlisted on NuGet, retracted on pub.dev; LuaRocks has no yank, Packagist mirrors git tags, and Maven Central is immutable, so the older releases remain listed on those three) — and SwiftPM, Go (the /v2 module; the v1 line deprecated and retracted), and Zig (root-manifest clean flow at v2.0.1) serve 2.0.x directly from their git tags (see PUBLISHING.md). Reach, stated precisely: Kotlin, Scala, Clojure, and Groovy consume the Java artifact from Maven Central as-is; Deno and Bun consume the npm package directly; and any WebAssembly host (browsers, edge workers, wasmtime embeddings) can use the WASM core attached to the latest release — so six direct installs serve ten-plus languages in practice. Of the nine follow-on implementations, C#, Ruby, PHP, Dart, Elixir, and Lua are now published at 2.0.0 (NuGet, RubyGems, Packagist, pub.dev, Hex, LuaRocks); Haskell, Perl, and R are conformant in the repository with their registrars still pending (Hackage, CPAN, CRAN; see PUBLISHING.md). In review or ripening: Julia (General#161292, auto-merges in ~3 days if checks pass), vcpkg (#52892) and Conan (#30612) for C++, plus Hackage (Haskell) and CPAN (Perl) awaiting their registrars, and CRAN (R) deferred to a quiet week — full status in PUBLISHING.md. Anything still missing (OCaml, Scala Native, Fortran, COBOL if you dare, ...) remains the open invitation: the 137 frozen vectors are the gate. Details and status: PUBLISHING.md.

Repository layout

causalontology/
  Causalontology_Standalone_Design_v27.txt   the canon (complete, lay-readable)
  spec/                    normative core, identity, semantics, provenance,
                           store, safety; schema/ = 21 JSON Schemas + JSON-LD
                           context + Protobuf + the OWL mapping (BFO/RO/PROV)
  conformance/             the 137 vectors (specification 4.0.0, whole-word
                           baseline) + the re-freeze tool; the meaning of "correct"
  bindings/                python · javascript (+ TypeScript typings) · rust
                           (+ the WebAssembly core) · java · swift · go —
                           all conformant; PrologAI is the reference
  store/server/            Tier A store (live), SPARQL subset, N-Triples
                           export, reputation, Tier B federation, Tier C
                           offline replication + the test suites
  store/stigmergy/         the contribution dashboard (served at /dashboard)
  examples/                the quickstart + the Mentova gardener (the first
                           synthetic mind contributing to the commons)
  .github/workflows/       22 Continuous Integration (CI) gates: every
                           implementation, every push
  archive/                 superseded editions of versioned documents
  GOVERNANCE.md · PUBLISHING.md · LICENSE · DATA_LICENSE · NOTICE

Conformance

An implementation is Causalontology-conformant if and only if it passes every vector in conformance/vectors/ for the specification version it declares. That single rule is how twenty implementations in twenty languages — Prolog, Python, JavaScript, Rust, Java, Swift, Go, C#, Ruby, PHP, Dart, Elixir, Haskell, Perl, R, Lua, C++, Zig, Julia, and Kotlin/Native — agree without sharing a line of code — down to the length of a month (2,629,746 seconds) and the ranking of a resolve().

Specification 4.0.0 status (the doxastic and predictive additions). The suite is now 137 vectors (V01–V38 re-frozen unaltered in meaning under the whole-word schemes of Principle P7, V39–V107 the 2.0.0 additions, V108–V119 the 3.0.0 additions, V120–V137 the 4.0.0 additions). The Python reference passes all 137 locally — and, honestly stated, is today the ONLY binding at that gate. The 38/38 milestones below record the completed 1.0.0 effort; all nineteen bindings carry the whole-word re-mint and the full 2.0.0 semantic port (nine new kinds, Algorithms A–E) and pass all 107 vectors of that baseline, and each takes up its folded 3.0.0-plus-4.0.0 delta per docs/Causalontology_4_0_0_Release_Plan.txt. Registry state: eleven package registries plus the SwiftPM, Go /v2, and Zig git-tag channels are live at 2.0.x, and stay there until the 4.0.0 release plan executes (see PUBLISHING.md).

The reference implementation is now gated, not merely asserted. PrologAI is listed first among the bindings and named the reference implementation, so it is now held to the same standard as the rest: it is checked in Continuous Integration (CI — the practice of automatically building and testing every change) by its own prolog job in conformance.yml. That job checks out PrologAI beside this standard, installs SWI-Prolog, and runs PrologAI's own canonical harness against this repository's canonical conformance/vectors/, passing only when all 137 (V01–V137) pass. Because the harness runs against the standard's own vectors, the reference implementation can no longer silently drift from the specification: it earns the label by passing the same vectors as every other binding, under its own CI gate — one of the 22 — rather than by prose alone. (PrologAI shipped its own 4.0.0 port — causal_core 1.1.0 — so this gate now covers the full V01–V137 at specification 4.0.0.)

Roadmap — built, proven, and shipped

Governance

Semantic Versioning; the conformance suite versioned in lock-step; extending any closed enumeration is a MAJOR change; releases gated in CI on the vectors; an open change process with conformance impact statements. See GOVERNANCE.md.

Contributing

Before the public launch, contributions land through the change process in GOVERNANCE.md. The contribution model of the commons itself is stigmergic: ask the store for the most valuable gaps, close one, sign your work. Vocabulary discipline: resolve before you mint — and, per Principle P7, whole words, never abbreviations.

License

"The attribution always; no profit, no problem license." — one license for everything in this repository and its commons: the code, the data, the specification, and the architecture. It is the friendly name for the Apache License 2.0 text, the same license carried by PrologAI and Mentova: attribution (the NOTICE file) is always required, and use without profit is never a problem. The data license (DATA_LICENSE) carries the same terms, by the owner's decision of 2026-07-13.

Citation

D. R. Dison. Causalontology: AGI's Missing Link — the Standalone Standard and the Shared Commons, Version 26 (the 4.0.0 Edition), specification 4.0.0. AI University (AIU), 2026. github.com/ai-university-aiu/causalontology

Author

D. R. Dison — Founder of AIU (Artificial Intelligence University), Creator and Owner of PrologAI and Mentova. ORCID 0009-0001-9246-5758 · linkedin.com/in/d-r-dison

Related projects

PrologAI — the glass-box cognitive architecture; Causalontology's reference implementation (ARC-AGI-1 public training set: 400/400, pure symbolic induction, no LLM)
Mentova — the first Synthetic Mind written in PrologAI; the flagship mind and, one day, the first synthetic gardener of the commons

"Causalontology will be the Wikipedia and Wikidata of AGI." — D. R. Dison

Name		Name	Last commit message	Last commit date
Latest commit History 154 Commits
.github		.github
archive		archive
assets		assets
bindings		bindings
conformance		conformance
docs		docs
dumps/example		dumps/example
examples		examples
spec		spec
store		store
.gitignore		.gitignore
BRANDING.md		BRANDING.md
CHANGELOG.md		CHANGELOG.md
CODE_OF_CONDUCT.md		CODE_OF_CONDUCT.md
CONTRIBUTING.md		CONTRIBUTING.md
Causalontology_AGIs_Missing_Link_Manuscript_v17.txt		Causalontology_AGIs_Missing_Link_Manuscript_v17.txt
Causalontology_AGIs_Missing_Link_Outline_v11.txt		Causalontology_AGIs_Missing_Link_Outline_v11.txt
Causalontology_Standalone_Design_v27.txt		Causalontology_Standalone_Design_v27.txt
DATA_LICENSE		DATA_LICENSE
GOVERNANCE.md		GOVERNANCE.md
LICENSE		LICENSE
NAMING.md		NAMING.md
NOTICE		NOTICE
PUBLISHING.md		PUBLISHING.md
Package.resolved		Package.resolved
Package.swift		Package.swift
README.md		README.md
SECURITY.md		SECURITY.md
SUPPORT.md		SUPPORT.md
build.zig		build.zig
build.zig.zon		build.zig.zon
composer.json		composer.json

Provide feedback

Saved searches

Use saved searches to filter your results more quickly

Repository files navigation

Causalontology

The World's First

What is Causalontology?

Now at 4.0.0 - three additions, all additive

The Twenty-One Kinds of Thing

Storage and federation — the commons is a network, not a server

Quickstart (30 seconds)

Install (one line, your language)

Repository layout

Conformance

Roadmap — built, proven, and shipped

Governance

Contributing

License

Citation

Author

Related projects

About

Releases

Packages

Contributors

Languages

Folders and files

Latest commit

History

Repository files navigation

Causalontology

The World's First

What is Causalontology?

Now at 4.0.0 - three additions, all additive

The Twenty-One Kinds of Thing

Storage and federation — the commons is a network, not a server

Quickstart (30 seconds)

Install (one line, your language)

Repository layout

Conformance

Roadmap — built, proven, and shipped

Governance

Contributing

License

Citation

Author

Related projects

About

Topics

Resources

Code of conduct

Contributing

Security policy

Stars

Watchers

Forks

Releases

Packages

Contributors

Languages