OpenSentience is the research layer of ComputeDriven live_deployed That rung covers one thing: the box-and-box kernel, published as [email protected] on npm and readable in full below. It does not cover anything else described on this domain — every other protocol here has its own status, and most are specifications.

Reference implementation·MIT·8 rungs·zero dependencies

box-and-box

The governance kernel — eight modal rungs, one bridge (feasible ▸ permitted ▸ best), and 109 enforced kernel laws at 2000 trials each. Pure arithmetic: no LLM, no network, no I/O. Read every line below in five languages — JavaScript is canonical, and the Python, Elixir, Rust and Go ports each pass the identical kernel suite. The algebra, not the syntax, carries the guarantee.

# the published package — read it, run it, port it
npm install -g box-and-box
box-and-box laws   # the kernel conformance harness
box-and-box compose-laws   # the CC2 compose layer
box-and-box govern decision.json # a real verdict → certificate JSON

Both harnesses derive their own printed totals from the suites they run — no count in this package, or on this page, is hand-typed.

Conformance — five languages, one kernel suite

Each result above was produced by running that language's own harness in this directory on 2026-08-22. A port is faithful exactly when it satisfies the same equations under the same randomized trials — not when it looks like the original.

Source browser — the real served code

/
value.mjs raw ↗

loading…

Files are fetched from this directory as you read them — nothing is inlined, so what renders is what the server holds. ↑/↓ move through the file list, / focuses the filter, and clicking a line number deep-links to it.

The ladder — twelve modules every language implements

Module Rung What it decides Laws

Above the kernel — JavaScript only, no ports yet

Module What it adds Laws
compose.mjs The CC2 lego layer — capability bricks snap together with & and |> over the shared floor. Carries its own suite, test/compose-laws.mjs. CA · CP · CX · CD
numerics.mjs The normative numeric domain — one rounding utility and one tolerance, so every rung agrees on what two numbers being equal means. —
index.mjs The barrel. Re-exports every rung plus the two modules above. —

These three are the reason the JavaScript file list is longer than the other four. The kernel suite is what all five languages share; the compose layer sits on top of it and exists in JavaScript alone, with its own suite and its own count. That count is still moving as the layer is built, so it is not repeated here — laws.html enumerates every law in both suites and is generated from the same manifest the harnesses derive.

What is still open

3 declared-open gaps — they print FALSIFIED by design

CP5 — the |> floor is association-invariant
isZero((a|>b)|>c) should equal isZero(a|>(b|>c)). It does not: one association floors to 0̲ while the other stays live.
CP6 — no backward execution step survives |>
A pipeline containing a backward phase step survives in one association and is refused in the other.
CP7 — &-operand order cannot change a downstream floor
a&b and b&a reach different verdicts downstream — so & is not commutative in the way its own law CA1 claims.

All three trace to one root cause — the Value.pi carrier — and all three are enforced as open: the suite fails the build if one of them starts passing, because a gap that closes silently is a gap nobody promotes. They are listed here for the same reason they are printed in red: a kernel that hides its open problems is not one you can check.

Status

Status
live_deployed — [email protected] is published on npm and installable. The kernel suite is green in all five languages, run in this directory today; the CC2 compose suite is green in JavaScript.
Last verified
2026-08-22
Source
npm run parity — one command that runs all five suites and refuses unless they agree family by family, not merely on the total. It compares the sixteen law families across every implementation, because two ports can both report 103 while testing different sets of 103; it treats an absent toolchain as unverified rather than passing; and it checks the agreed figure against LAW_MANIFEST.json. The individual suites are still node test/laws.mjs · python3 laws.py · mix run run_laws.exs · cargo run --release · go run ., each in its own port directory beneath this one. Counts are derived by the suites; nothing on this page was typed by hand.
Limit
This establishes that the stated equations hold under randomized trial. It does not establish that the equations are the right ones, that anyone has governed a real system with them, or that the ladder is complete. Two specific bounds: the ports are checked against the kernel suite only — none of the four has a compose layer, so & and |> are unproven outside JavaScript; and the source you read here is the working tree, which has moved ahead of the published 0.10.0. Eight of the twelve kernel modules are byte-identical to npm; the other four differ by 11 lines in total.
Next rung
external — someone other than the author running the suite and reporting the result, or a port this project did not write. A fifth language checked by a sixth party is worth more than a sixth language checked by this one.

The spec is the suite

Each rung is a small, self-contained module built on a single algebraic structure: a product of monoids (alethic), a diamond status lattice (deontic), tropical / probability / log semirings (axiological), LTL formula progression (temporal), AGM revision with entrenchment (reflexive), S5 / KD45 modal logic (epistemic), ATL controllable-predecessor fixpoints (strategic), and a linear-logic double-entry ledger (resource).

There is no prose specification that the code implements. The suite is the specification — a port is correct exactly when it satisfies the same equations under the same randomized trials, and every module above names the law family that pins it down. This is why five languages with nothing in common at the syntax level can be checked against one another at all.

Why laws rather than a pass rate

Runtime enforcement for agents is a crowded field in 2026, and most of it is rule engines: a policy DSL with triggers, predicates and enforcement hooks, evaluated outside the model. AgentSpec is the strongest of them and reports its safety empirically — over 90% of unsafe code executions prevented, all hazardous embodied actions eliminated. Those are good numbers and they are the right numbers for a rule engine.

A law is a different kind of claim. "Over 90% prevented" describes a sample; consume being associative describes every input that will ever exist. The cost is that an algebra can only govern what it can express, which is why this kernel is eight small rungs and not one large policy language — and why the three gaps above are published rather than rounded away. Every verdict the bridge returns ships a certificate saying which rung refused and why.