GENOME SDK

The GENOME SDK is the reference implementation of the AIEP constitutional stack. It is a production-ready execution environment that enforces the constitutional substrate at runtime — not as a guideline but as a hard constraint on processor execution.

The key claim: a GENOME-compliant agent cannot execute a reasoning operation that violates its constitutional constraints. Not “should not” — cannot. The enforcement is invariant-gated, not advisory.

What GENOME enforces

GENOME’s enforcement derives from the dual-ledger memory substrate (P80). Every artefact and every reasoning state entry is recorded in one of two ledgers:

Before any reasoning state entry can be executed, GENOME evaluates four invariant conditions:

If any invariant is not satisfied, execution is suppressed in a fail-closed manner. The system does not attempt to proceed with degraded integrity. It halts and generates a suppression record — a signed, hash-bound record of what was suppressed and why.

The frozen kernel

At the core of the GENOME SDK is a frozen kernel of eight canonical primitives (R1–R8). These primitives are declared in GENOME_LOCKFILE.json at build time and cannot be altered at runtime.

See /constitutional-substrate for the full R1–R8 specification.

The frozen kernel means that:

• Every GENOME-compliant deployment starts from the same foundation
• Artefacts produced under the same kernel version are interoperable
• Version changes in the kernel are explicit, declared, and detectable
• No runtime configuration can alter the canonical primitives in force

GENOME_LOCKFILE.json

Every deployment commits to a specific kernel and schema state at build time:

{
  "kernelVersion": "1.2.0",
  "primitiveSet": "R1-R8",
  "schemaVersions": {
    "artefact": "1.4.2",
    "reasoning": "1.2.0",
    "divergence": "1.1.0"
  },
  "lockfileHash": "sha256:...",
  "issuerSignature": "..."
}

The lockfile hash is computed over the lockfile contents and signed by the deployer. Any post-build modification to the lockfile produces a different hash — and all artefacts produced after that modification carry evidence of the changed state.

The Flexibility Contract

GENOME’s flexibility is explicit. The Flexibility Contract (AIEP-FC-001) declares precisely which parameters may be configured by a deployment and which are immutable:

Anything not listed in the Flexibility Contract is not configurable. The contract is itself a schema-validated artefact — a deployment cannot silently extend it.

Execution model

A GENOME-compliant agent executing a task follows this sequence:

1. Load GoalVector — retrieve and validate the current GoalVector commitment (see /goal-generation)
2. Retrieve evidence — query the Mirror endpoint for relevant artefacts
3. Normalise evidence — run all retrieved artefacts through the normalisation engine (see /evidence-normalisation)
4. Evaluate invariants — check all four invariant conditions before proceeding
5. Execute — run the reasoning operation within the frontier bounds
6. Record — append the reasoning state entry and all produced artefacts to the ledgers
7. Detect divergence — run divergence detection on newly produced artefacts (see /divergence)
8. Update GoalVector — commit to any goal state changes with signed re-commitment records

Every step produces signed, hash-bound records. The complete execution is auditable end-to-end from a cold start.

What GENOME does not do

GENOME does not make AI smarter. It does not improve inference quality. It does not guarantee correct conclusions.

What it does: it makes the execution process investigable. If a GENOME-compliant agent produces an incorrect or harmful output, the full execution trace — what evidence was retrieved, what invariants were checked, what goal was active, what divergences were detected — is available for inspection. Responsibility can be assigned. Corrections can be made against a known state.

This is the difference between a system that can go wrong in untraceable ways and one that can go wrong in ways that can be found, understood, and fixed.

Access

The GENOME SDK is available at two tiers:

Downloads · Builders programme · Licensing

Constitutional substrate · Goal generation · Evidence normalisation · Divergence · Patents — P37–P94