Skip to main content

The MI Kernel

The Mathematically Intelligent (MI) Kernel is the contract every Zeq node computes under. It is the single source of truth for four things:

  • the timing constants — 1 Zeqond = 0.777 s, the 1.287 Hz HulyaPulse, the α modulation bound
  • the core equations — the synchronisation equation, the proper-time modulation, the metric tensioner (KO42), the master equation, the functional equation
  • the operator catalogue — 1,500+ catalogued operators, each a named equation with an id
  • the computation mandate — the seven-step protocol every query must pass through

Its canonical implementation is zeqKernel.ts in shared/api-core/src/lib/. Crucially, the kernel is not a settings file you have to trust the operator to honour. It is served, and it is announced.

It is served​

curl https://zeqsdk.com/api/kernel          # full structured JSON: constants, equations, operators, mandate
curl https://zeqsdk.com/api/kernel/prompt    # the computation-mandate text, for AI agents
curl https://zeqsdk.com/.well-known/zeq-os-kernel.md   # raw markdown, for crawlers

Anyone can read the exact rules a node runs under, in machine-readable form, without an account. The constants are not hidden; the operator equations are not hidden; the mandate is not hidden. Reading the kernel is reading the node's physics.

It is announced on every response​

Every API response a node sends carries a header:

X-Zeq-Kernel: https://zeqsdk.com/api/kernel
X-Zeq-Kernel-Prompt: https://zeqsdk.com/api/kernel/prompt

This is the self-referential part of "self-referential kernel." A response doesn't just hand you a result — it tells you, on the wire, which kernel produced it and where to read that kernel's rules. If a fork changes a constant, its kernel document changes, and the X-Zeq-Kernel header points at the changed document. You never have to ask a node what rules it is running. It declares them on every response.

Why a served kernel matters​

This is what makes the framework forkable without forking trust. The kernel is fork-portable: a fork serves its own kernel from its own origin, substituting its own public base URL wherever an absolute URL is needed, while the DOIs (content-addressed publication identifiers) stay invariant. Two nodes running the same kernel will compute the same physics — and because the kernel is on the wire, you can prove they're running the same kernel before you ever compare a result.

The kernel is also what an AI agent loads to become a Zeq compute client: GET /api/kernel/prompt returns the computation mandate as a prompt, so a model can adopt the seven-step protocol directly. That is the kernel skill and the MCP surface.

What the kernel is not​

It is not an operating system, and it is not a runtime you install. The word "kernel" here means the irreducible core contract — the constants, equations, and mandate that every computation is bound by — in the same sense a mathematical theory has a kernel of axioms. You don't boot it; you compute under it.

Kernel on the 1.287 Hz HulyaPulse. Announced on every response.