P245 — AIEP — Replay-Verifiable Execution Kernel

Applicant: Neil Grassby Classification: Patent Application — Confidential Priority: Claims priority from GB2519711.2 filed 20 November 2025 Architecture Layer: AIEP Phase 2 Hardware Execution Layer

Framework Context

[0001] This specification operates within an AIEP environment as defined in GB2519711.2 and GB2519798.9. The present specification defines a hardware execution kernel that records sufficient state to enable complete deterministic replay of any AIEP reasoning session from a stored checkpoint.

Field of the Invention

[0002] The present invention relates to replay-verifiable execution for evidence-bound AI reasoning session auditability.

Background

[0003] Auditability of AI reasoning decisions requires the ability to reproduce exact reasoning outcomes from stored inputs. Software-only replay is vulnerable to non-determinism introduced by floating-point rounding, memory allocation order, and operating system scheduling. A hardware execution kernel with enforced determinism and continuous session state recording provides audit-grade replay capability.

Summary of the Invention

[0004] The invention provides a Replay-Verifiable Execution Kernel (RVEK) that: enforces deterministic execution of the AIEP reasoning runtime by suppressing all sources of non-determinism below the hardware abstraction layer; records complete session state snapshots at configurable checkpoint intervals using the Evidence Hash Memory Bus Primitive (P243); stores checkpoint records in the evidence ledger with hash-linked continuity; and provides a replay API enabling any authorised auditor to reproduce the exact session state at any checkpoint.

ASCII Architecture

AIEP Reasoning Session
         |
         v
+-------------------------------------------+
| Replay-Verifiable Execution Kernel (RVEK) |
|                                           |
|  Non-determinism suppression layer       |
|  Checkpoint scheduler                    |
|  State snapshot capture (via P243)       |
|  Checkpoint hash linking                 |
|  Ledger admission (P243/Evidence Ledger) |
+-------------------+-----------------------+
                    |
            Replay API
            → Auditor resumes session from any checkpoint
            → Identical outputs on identical replay inputs

Detailed Description

[0005] Non-determinism Suppression. The RVEK patches the hardware abstraction layer to: fix floating-point rounding modes; serialise all memory allocations through a deterministic allocator; suppress OS scheduler non-determinism by using round-robin thread scheduling with deterministic quantum assignment.

[0006] Checkpoint Scheduling. Checkpoints are recorded at configurable intervals: time-based (every N seconds), event-based (at each reasoning conclusion), or budget-based (at each compute budget boundary). A checkpoint captures the full AIEP runtime state vector.

[0007] Hash-Linked Continuity. Each checkpoint record includes the hash of the previous checkpoint, forming a hash-linked chain. Any gap or modification in the chain is detectable by a verifier.

[0008] Replay API. An authorised auditor submits a replay request specifying the target checkpoint hash. The RVEK loads the checkpoint state into the execution environment and resumes the session from that point. Given identical subsequent inputs, the session produces identical outputs.

Technical Effect

[0009] The invention enables post-hoc cryptographically verifiable deterministic replay of AIEP reasoning sessions for audit and accountability purposes. By patching non-determinism at the hardware abstraction layer rather than at reasoning logic, the engine provides determinism guarantees across all components without requiring reasoning engine modifications. The hash-linked checkpoint chain enables auditors to verify session integrity and identify any tampering before initiating replay. The authenticated replay API confines replay capability to authorised auditors, preventing adversarial use of session replay.

Claims

1. A method of enabling replay-verifiable execution in an evidence-bound artificial intelligence reasoning system, comprising the steps of: (a) suppressing non-determinism at the hardware abstraction layer by fixing floating-point rounding modes, serialising memory allocations through a deterministic allocator, and enforcing round-robin thread scheduling with deterministic quantum assignments; (b) recording checkpoints at configured intervals—time-based, event-based, or compute-budget-based—each checkpoint capturing the full AIEP runtime state vector; (c) constructing each checkpoint record to include the hash of the immediately preceding checkpoint, forming a hash-linked continuity chain; (d) admitting each checkpoint record to the evidence ledger; (e) in response to an authenticated replay request specifying a target checkpoint hash, loading the corresponding checkpoint state and resuming session execution such that identical subsequent inputs produce identical outputs.

2. The method of claim 1, wherein the deterministic allocator enforces fixed-order allocation sequencing, recording the allocation sequence in the checkpoint record.

3. The method of claim 1, wherein a gap or hash mismatch in the checkpoint chain is detected and reported as a session integrity violation before replay is initiated.

4. The method of claim 1, wherein replay requests are authenticated against the authorised auditor registry and replay events are themselves admitted to the evidence ledger.

5. The method of claim 1, wherein the system supports partial replay from any checkpoint in the chain, not only from session start.

6. A replay-verifiable execution kernel for an evidence-bound artificial intelligence system, comprising: a hardware abstraction layer patch suppressing floating-point, allocation, and scheduling non-determinism; a checkpoint engine recording full runtime state vectors at configurable intervals; a hash-linking module constructing hash chains over sequential checkpoint records; and an authenticated replay API enabling authorised resumption of sessions from stored checkpoints.

7. A computer-readable medium carrying instructions for implementing the method of any preceding method claim.

Abstract

A replay-verifiable execution kernel for evidence-bound artificial intelligence suppresses execution non-determinism at the hardware abstraction layer—fixing floating-point rounding, serialising memory allocation, and enforcing deterministic thread scheduling—and records hash-linked runtime state checkpoints at configurable intervals. Checkpoint records are admitted to the evidence ledger. An authenticated replay API enables authorised auditors to load any checkpoint from the chain and resume session execution from that state, producing identical outputs from identical subsequent inputs for independent verification.