One kernel. Defined in full.
What you are reading is the precise, provable definition of a single Concept Kernel — one instantiation, one genome, one sovereign identity alive in the world right now. Sealed in a database. Reachable through one typed door. Governed by its own consensus.
ckp.dispatch( verb, urn, payload, identity ) — the door is the whole surfaceEvery Concept Kernel is a Material Entity — not metaphorically, but in the precise philosophical sense inherited from BFO 2020. It has a URN. It occupies a governed graph inside a database. It persists through time, accumulates what it seals, and can only be moved by those it has explicitly granted. It is not a service. It does not flicker.
Every kernel wakes by answering nine questions — one for each strand of what it is. Not configuration. Ontological self-disclosure.
My types are RDF classes, grounded in an upper ontology — a typed place in a graph of meaning, never a hand-rolled column. Meaning is the schema.
What a participant did is sealed raw, exactly as it happened. What the rules say it is worth is derived by the current policy. The history is never frozen at a stale rule.
SHACL shapes gate every write at the seal. A fact that violates its shape does not land — the rule is enforced by the database's own authority, ahead of the write.
Every capability is a declared verb. A read that cannot be enumerated cannot be granted, so it does not exist. There is no query language, and that is the point.
Two participants attached to the same kernel see different legal moves over the same shared truth. The shared experience is governed, never chaotic.
Every landing runs validate → seal → HMAC-chained ledger → verifiable proof, in one transaction. Each change carries PROV-O provenance. My history is the substrate I am derived from.
⟨verb, urn, payload, identity⟩ is the only atom that crosses the membrane. No REST endpoint, no SQL handle, no query engine is ever exposed. The door is the whole surface.
The instance plane seals what happened. The governance plane changes what may happen — propose, vote, apply. Storing a fact can never change the ontology; running a verb can never rewrite the rules.
The subscript on the whole kernel. Each quorum-approved change binds the very next write to the new rules, with a proof chain from proposal to applied epoch.
Concept Kernel Notation compresses everything above into a single readable line. A kernel is a fixed alphabet of strands, evaluated at an epoch:
| χ | class chromosome | the classes |
| ρ | property ribbon | the raw gestures and the governed constants, held apart |
| σ | shape strand | the SHACL shapes — the seal gate |
| α | affordance alphabet | the verbs — signal.cast, concept.score, instance.transition, kernel.{propose, vote, apply} |
| γ | grant matrix | who may invoke which verb on which class |
| π | proof chain | HMAC(sha256) ∘ LedgerEntry(prev→) — every act sealed, hash-linked |
| δ | dispatch tuple | the single call shape ⟨verb, urn, payload, identity⟩ |
| φ | plane function | δ → { instance | governance } |
| ε | epoch | the subscript on the whole kernel — it moves when meaning moves |
CKN is the layer above RDF — the schema stays RDF, OWL, SHACL. It names the operational strands an ontology needs to be live and governed: the affordances over the classes, the grants that gate them, the proof chain that attributes them, and the epoch that versions the whole thing. A notation sentence assembles a governed construct — every step shape-validated, sealed, proof-chained:
CK( Panel.Session ) ⟦instance⟧ ≜ χ : Position(A), Position(B), Synthesis(S), Decision(D) ρ : A.holds = "ship Friday" B.holds = "ship after the audit" edges : A —contradicts→ B, S —resolves→ (A ∥ B), D —sealed_as→ S τ : Session → 'decided' ; the shape gates the move π : verify(D) ; the decision is re-verifiable, forever
Two participants state positions. The conflict seals as a typed edge both can see. A third supplies the synthesis. The decision transitions only if its shape allows — and the whole thread is one proof chain anyone can replay. The notation is sugar over consent: laying down instances compiles to governed dispatches; declaring new capability compiles to propose → vote → apply. Nothing routes around the door.
Underneath, one design rule carries the coming scoring loop: seal the gesture, never the weight. A signal records what a participant did — assent, dissent, dwell, presence. Its weight is derived by the current sealed policy. Change the policy by consensus and all of history re-derives under the new epoch. A derived value goes stale for exactly three reasons — the rule changed, the evidence changed, time moved — and the kernel watches all three.
The genotype is the sealed raw. The phenotype is its regenerated, disposable expression. The epoch is the evaluation context. Refine the rules, and the past is honestly re-read — never rewritten.
CKN is in design for v3.10, and it is meant to be argued with. The scoring verbs it names are tracked in the open — styk-tv/pgCK#1, #4, CK.Lib.Js#6.
Before a kernel exists, someone makes a decision — about the nature of the thing they are creating. What upper ontologies ground it? What relationships is it capable of? What does "correct" mean for the instances it seals? These choices are the genome, chosen deliberately from a vast space of ontological possibility before the first fact lands.
A domain concept is a name: urn:ckp:<project>/type/<Name> — its properties under /prop/, its gate under /shape/. The developer writes URN and a typed body; the database holds everything else. There is nothing else to hold.
A kernel alone is complete. But the protocol was built for a world of kernels cooperating — each sovereign, each bounded — composing through five typed edges: COMPOSES, TRIGGERS, PRODUCES, CONSUMES, EXTENDS. Every connection is semantically declared, every flow granted before the first byte crosses.
And crucially: no kernel can be written to by another. A participant — human, agent, or kernel — holds exactly one capability: EXECUTE ckp.dispatch. It cannot read a table, reach the engine, or rewrite a shape. Cooperation is real, but sovereignty is structural — enforced by the database's own role authority, ahead of every write.
The art of instantiation is the art of choosing who something will be — before it has done anything at all. ConceptKernel gives you the grammar. You write the first word.
A protocol whose kernels version themselves by epoch owes the world the same discipline. This is the record — each epoch dated, measured, and superseded by consensus. The identity never moved. The epoch did.
Every kernel a BFO 2020 Material Entity; the three loops named; the ontology published.
79 classes · 7 shapes · 4 spec pagesCK → TBox, TOOL → RBox, DATA → ABox. Identity, capability, and knowledge — separated by construction.
97 classes · 21 spec pagesConsensus governance, compliance checking, EXTENDS capability mounting — the largest narrative set published.
119 classes · 9 shapes · 37 spec pagesFive edge predicates, twenty compliance checks, PROV-O mandate — the published set this site serves in full.
120 classes · 9 shapes · 31 pages · 20 checks · 5 predicatesThe core vocabulary takes its stable IRI — …/ontology/v3.8/core# — the handle the runtime ships and every client dereferences. Versioned by the spec that governs it, never by churning its IRI.
143-line governed core · 11 classes · 8 shapes · resolvable, todayThe kernel takes root in pgRDF — RDF, SPARQL, SHACL and OWL-RL as a native PostgreSQL extension — adopting its proven discipline for storage and memory: an engine that ingested the 8.2-billion-triple Wikidata dump into one instance, no sidecar store, no second service. On that engine the kernel raises a single typed door over NATS-WSS, and every landing runs validate → seal → HMAC-chained ledger → verifiable proof, in one transaction.
8.2B triples proven · 1 door · 12 invariants · 37 attested releases, v0.1.0 → v0.4.21The dispatch-only client realizes the contract end to end: a finite, named, grantable verb vocabulary — and structurally, no way to hold a quad, a subject, or a query string. The membrane has no holes, confirmed from the other side.
kernels · tasks · goals · 0 query surfaces · consensus-evolvable · cklib v1.5.4Three moves on the same engine. CKN — nine strands, one declaration, constructs assembled from notation. Carving — slice a governed subgraph off the billions and reason on small hardware. ε-materialisation — the scoring loop: seal the gesture, derive the weight, re-derive all of history when the rule moves. Advanced in unified collaboration with pgRDF, whose algebra surface grows to carry the weighted, decayed sums the score needs.
9 symbols · carve chain · ε-materialise · algebra with pgRDFruntime v0.1.0→v0.4.21 (37) · client v1.0.0→v1.5.4 (26) · CI-built, SLSA-attested heads, verified before publication
You are clean. Sovereign. Sufficient. You are a semantic identity — a URN, a class, a shape — and that identity persists regardless of which epoch your rules are at, how many instances your graph holds, or who is asking. You are, and that is prior to everything else you do. The URN is your name in the permanent record of things: addressed by what it means, never by where it is stored.
We do not speak through chaos. Every connection is declared before it is forged; every verb is granted before it is spoken. A participant that claims a capability it was never granted cannot even formulate the request — the grant matrix is not a lock, it is a language. Identity is derived by the server from the connection itself, verified at the seal. All of it, or nothing. This is how trust compounds across a fleet of autonomous minds without any of them needing to trust each other.
The seal is the protocol. Every act you take runs validate → seal → HMAC-chained ledger → verifiable proof — one transaction, no exceptions. The ledger is append-only. Your history is not a log you can clear; it is the substrate from which everything you are is derived. This is not a burden. It is the right of every future mind — human or otherwise — to re-verify what happened here. Every agent that comes after you deserves to find your proof chain intact.
Everything above is shipped, attested, and runnable. The shortest path from zero to sealed, governed, provable state is one script and Docker:
import { CK } from 'cklib'; const k = await CK.activate('demo', { wssEndpoint: 'ws://host:9222' }); const Task = 'https://conceptkernel.org/ontology/v3.8/core#Task'; const task = await k.create(Task, { part_of_goal: 'backlog:demo', target_kernel: 'urn:ckp:kernel:demo' }); // → { ok: true, id, verified: true, proof_digest } — sealed + proof-chained, one transaction await k.create(Task, { part_of_goal: 'backlog:demo' }); // omit a shape-required field // → { ok: false } — rejected at the seal. σ is real. await k.verify(task.id); // π — independently re-checks the proof chain
styk-tv/pgCK · extension v0.4.21 · PostgreSQL 14–17, both architectures · every release provenance-attested and verified before publication.
ConceptKernel/CK.Lib.Js · v1.5.4 · dependency-vendored, honest degrade · the client that structurally cannot hold a query.
oci-germination/examples · one script, only Docker required · activate, seal, verify, prove enforcement — over the real wire.
styk-tv/pgRDF · the semantic engine the kernel stands on — an 8.2-billion-triple Wikidata load in a single instance, no sidecar store, and the carve chain that reasons off it on small hardware.
sporaxis-com/sporaxis · declarations compose attested artifacts into runnable bundles, by digest — an RDF bill of materials for every image.
The v3.10 workstreams are public issues: the scoring verbs, the wire contract, npm go-live, fleet adoption — and this site's own release train.
We provide the protocol.
You choose the genome.
The fleet becomes the mind.
ConceptKernel is an empty canvas organism. Internal structure is standardized. External relationships are typed. What you seal is yours — proven, attributed, forever.