Sovereign Knowledge Intelligence

Sovereign, auditable, neuro-symbolic AI compliance

SKI is an open framework for compliance monitoring in regulated industries. Every verdict carries verifiable provenance: a signed LLM transcript, Knowledge Graph citations, and an independent symbolic verifier's per-assertion result — runnable today.

What SKI is

v3.0.0 is the first production-target release of the SKI Framework. It ships the complete neuro-symbolic evaluation pipeline: a KG-grounded LLM Evaluator paired with an independent Symbolic Verifier, with every verdict sealed into a signed V3VerdictEnvelope carrying the full provenance chain.

SKI is built on three governing axioms, three structural pillars, and a closed taxonomy of five categorical verdicts — all evaluated inside a single sovereign boundary. The pages in this documentation walk through each of those building blocks, the architecture that connects them, and how to run the reference implementation yourself.

Specification v3.0 — neuro-symbolic pivot, verifiable provenance model, RFC 0002 accepted.
Reference implementation v3.0.2 — runs entirely on-premise on Ollama, no cloud API key required.
60 runnable conformance tests (30 provenance + 30 durability), plus 6 scaffolded sovereignty stubs, you can run in minutes.
Dual-licensed: Apache 2.0 for software, CC BY 4.0 for the specification.

The problem SKI solves

These are not hesitations. They are the reasons AI adoption has stalled in core compliance functions across critical infrastructure. SKI was designed from first principles to address each one.

01

Loss of Sovereignty

If our operational data flows through a third-party cloud AI, we lose control of our most sensitive asset.

SKI resolves this The inference engine runs entirely within the organisation's sovereign boundary. No operational data leaves at runtime. Air-gap capable by design.

02

Non-Determinism

AI gives different answers to the same question. That's fundamentally incompatible with audit and regulatory compliance.

SKI resolves this Every verdict carries verifiable provenance: a signed LLM transcript, KG citations, model-weight and KG-version hashes, and an independent Symbolic Verifier's per-assertion result. An auditor can replay any verdict from the recorded transcript and reach the same envelope — defensibility is reconstructible, not bit-identical.

03

Liability Opacity

When an AI flags a compliance issue (or misses one), we can't explain the basis of the decision to a regulator.

SKI resolves this Every verdict traces to a specific Knowledge Graph node and a named policy clause in a source regulatory document. Every verdict also carries a signed LLM transcript so an auditor can reconstruct the model's reasoning step by step. No black boxes — ever.

04

Unsafe Intervention

An AI that can control or modify operational systems introduces catastrophic risk. We cannot put AI in the loop on safety-critical infrastructure.

SKI resolves this SKI is a passive read-only observer. It monitors and reports. It has zero control path to operational systems. Primary operations continue uninterrupted if SKI goes offline.

05

Rule Drift

Regulations change. We can't guarantee the AI is evaluating against the current rules, not last year's.

SKI resolves this The Knowledge Graph is a living, versioned artefact with a governed update pipeline. Every change requires extraction, human validation, cryptographic signing, and deployment. The ledger records which graph version produced each verdict.

06

Accountability Gap

If the AI is making compliance decisions, who is accountable? The regulator will ask, and we won't have an answer.

SKI resolves this Human reviewers validate every Knowledge Graph rule before production. Human authority is preserved on all escalations. The AI augments judgement — it does not replace it.

SKI at a glance

Three governing axioms. Three structural pillars. Five categorical verdicts. One sovereign boundary. Click any element to jump to its full specification.

3 Governing Axioms

A1ProximityInference at or near the data source. No remote endpoints. A2Verifiable ProvenanceEvery verdict carries a signed LLM transcript, KG citations, and the Symbolic Verifier's per-assertion result. Replayable by any auditor. A3Passive OversightRead-only sidecar. Zero control path to operations.

govern

3 Structural Pillars

S

Sovereignty

On-premise edge computeAir-gap capableHardened environmentNo cloud dependency

K

Knowledge Maps

LLM extraction (kg-extractor)Schema validation (kg-validator)Ed25519 signingTyped v3 obligation graph

I

Intelligence

KG-grounded local LLMSymbolic VerifierSigned LLM transcriptsAgreement monitor

produces

5 Verdict Types

CLEARAll rules pass — logged silently FLAGRule breached — operational owner alerted NULL_UNMAPPEDNo graph node — KG coverage gap NULL_STALESilent sensor — infrastructure failure DISCRETIONARYAmbiguous language — human reviewer

v3.0.2 — Runnable today

Quick Start

The SKI reference implementation runs entirely on-premise using Ollama. No cloud API key required. Clone the repo, install prerequisites, and run all 60+ conformance tests in minutes.

Install & run

1Clone & install

Pull the reference implementation and install the dev and test dependencies. No cloud credentials required.

$ git clone https://github.com/kpifinity/ski-framework.git
Cloning into 'ski-framework'...
remote: Enumerating objects: 4231, done.
Receiving objects: 100% (4231/4231), 1.84 MiB | 12.18 MiB/s, done.
Resolving deltas: 100% (2914/2914), done.

$ cd ski-framework
$ pip install -r requirements-dev.txt
Successfully installed pytest-8.3.3 pytest-asyncio-0.24.0 pytest-httpx-0.32.0 …

2Start the sovereign runtime (Ollama)

Ollama is the conformant sovereign backend. The v3 runtime requires a model that supports structured generation (JSON grammar). qwen2.5:7b-instruct is the tested default.

$ ollama pull qwen2.5:7b-instruct
pulling manifest...
pulling 2c89d7d5d2d0... 100% ▕████████████████████▏ 4.7 GB
pulling 8a0c5d0e... 100% ▕████████████████████▏ 1.5 KB
verifying sha256 digest
writing manifest
success

$ docker compose up -d
✓ Container ski-ledger-db    Started
✓ Container ski-ollama       Started
✓ Container ski-model        Started
INFO  Ledger schema is at v3; no migration required.
INFO  SKI Model starting (v3.0.2, runtime=v3)

3Run the conformance suite

60 runnable tests across two marks (30 provenance + 30 durability), each citing the spec section it validates, plus 6 scaffolded sovereignty stubs. All runnable tests must pass on a conformant v3 deployment.

$ pytest conformance/ -m "provenance or durability" -v
============================= test session starts =============================
platform linux -- Python 3.11.6, pytest-8.3.3, pluggy-1.5.0
collected 60 items / 0 errors

conformance/provenance/test_v3_envelope_shape.py::test_envelope_has_all_required_fields PASSED
conformance/provenance/test_v3_envelope_shape.py::test_envelope_forbids_extra_fields PASSED
…
conformance/durability/test_ledger_schema_v3_columns.py::test_schema_declares_all_v3_audit_trail_columns PASSED
conformance/durability/test_ledger_migrations_runner.py::test_server_lifespan_calls_the_runner PASSED

============================= 60 passed in 4.83s ==============================

Demo KGs. The repo ships sector-specific demo KGs under examples/. The energy v3-shaped demo is at examples/energy/knowledge-graphs/kg-energy-v3-demo.json — this is the one that matches the v3 typed-obligation runtime. The v0.1 kg-energy-demo.json is the older flat-rule shape and exists for backward-compat smoke tests; the runtime correctly emits NULL_UNMAPPED against it because the metric paths don't align with v3 obligations. This is expected — not a runtime bug.

ski-framework — step 1 of 3

$ git clone https://github.com/kpifinity/ski-framework.git
Cloning into 'ski-framework'...
remote: Enumerating objects: 4231, done.
Receiving objects: 100% (4231/4231), 1.84 MiB | 12.18 MiB/s, done.
Resolving deltas: 100% (2914/2914), done.

$ cd ski-framework
$ pip install -r requirements-dev.txt
Successfully installed pytest-8.3.3 pytest-asyncio-0.24.0 pytest-httpx-0.32.0 …

View repository → v3.0.2 release notes

v3.0.0 — first production-target release. The neuro-symbolic pipeline (LLM Evaluator + Symbolic Verifier), signed LLM transcripts, V3VerdictEnvelope, and agreement monitor are all implemented and tested. See CHANGELOG.md for the full history.

Where to go next

Read the three axioms — the non-negotiable constraints that make SKI legally defensible.
Understand the verdict taxonomy — the five categorical outputs the system can produce.
Study the evaluation architecture — how the neuro-symbolic pipeline works end to end.
Verify your build against the conformance levels.

Spec Part D — Conformance

Conformance

The SKI conformance model defines three maturity levels — Provenance, Durability, and Sovereignty. Any implementation — including third-party implementations — can self-verify the Provenance level using the open test suite. Higher levels add governance controls and third-party audit requirements.

Conformance levels

Provenance · 30 tests

Runnable today

Provenance conformance

Thirty runnable tests across seven files verify the complete provenance chain: LLMTranscript ed25519 signature, V3VerdictEnvelope structure, model-weight and KG-version hash anchors, prompt-template and structured-grammar hash anchors, Symbolic Verifier per-assertion result present, agreement-monitor rolling agreement-rate behaviour, and audit ledger hash-chain integrity.

pytest conformance/ -m provenance -v

LLMTranscript signed with ed25519 (runtime key) and verified on every verdict
V3VerdictEnvelope carries model-weight hash, KG-version hash, prompt-template hash, decoder seed
Symbolic Verifier per-assertion result (AGREED / LLM_CONTRADICTION / NEURO_SYMBOLIC_DIVERGENCE / UNVERIFIABLE) present in every envelope
Agreement monitor reports a rolling agreement_rate (AGREED / total, default last 1000 evaluations) and fails is_healthy() below the 0.95 threshold
Audit ledger hash-chain integrity maintained across restarts

Full conformance specification →

Durability · 30 tests

Runnable today

Durability conformance

Thirty tests across nine files covering the durable properties of the v3 pipeline: sovereign boundary enforcement (no outbound runtime network), Knowledge Graph Ed25519 signature verified on load, append-only audit ledger with no delete or modify paths, Tag Registry compile-time with no runtime inference, five-verdict taxonomy (closed set), and NULL_UNMAPPED on out-of-scope inputs.

pytest conformance/ -m durability -v

All three axioms (Proximity, Verifiable Provenance, Passive Oversight) architecturally enforced
KG Ed25519 signature verified on load; reject on bad signature
Append-only ledger — no delete or modify paths exist in the code
Five-verdict taxonomy closed — no additional verdict codes possible
NULL_UNMAPPED produced for out-of-scope inputs, never a speculative verdict

Full conformance specification →

Sovereignty · 6 stubs

Scaffolded · harness in v3.1

Sovereignty conformance

The v3 Sovereignty mark verifies that the runtime is operable air-gapped, tamper-evident, and end-to-end signed. The six tests are scaffolded today (pytest.skip() stubs with spec citations); the harness lands in v3.1. For attested conformance — operations governed by an external audit plus a signed attestation letter on KpiFinity letterhead — engage KpiFinity for a paid Sovereignty audit.

No outbound HTTP during CLEAR-path evaluation (local LLM)
Runtime boots and serves with --network=none
Modified ledger row fails verify_integrity even after the chain is recomputed forward
Runtime refuses to start with SKI_MODEL_WORKERS != 1
Recorded transcript carries the snapshot's scope block (jurisdiction + as_of + n_in/n_out)
Recorded LLMTranscript ed25519 signature verifies against the recorded signing_key_id

Engage KpiFinity for a paid Sovereignty audit →

Conformance is defined in docs/CONFORMANCE.md. Run pytest conformance/ -m "provenance or durability" -v to execute all 60 runnable tests. An implementation claiming SKI v3 conformance should publish test output for both marks. Governance conformance requires a current Residual Risk Register as defined in Spec Part D.

Spec A4 — Core Axioms

The Three Axioms

The three axioms are non-negotiable architectural constraints. A deployment that violates any axiom is not an SKI deployment — it is an ordinary AI system with no special compliance properties.

The foundational constraints

1

A1 — Proximity

Intelligence evaluation shall occur at or near the monitored data source

The inference engine runs on a dedicated on-premise edge node co-located with the operational historian or SCADA system. Round-trip latency to any remote inference endpoint is not permitted. The edge node communicates only with local data buses — not with any external network at runtime.

Physical proximity eliminates latency, enforces data sovereignty, and makes remote data exfiltration architecturally impossible — not just policy-prohibited. An external auditor can verify compliance by physically inspecting the network topology; no policy document is required.

2

A2 — Verifiable Provenance

Every verdict can be independently reconstructed from its recorded provenance

Every produced V3VerdictEnvelope carries: a signed LLMTranscript (ed25519, the runtime's own key), the model-weight hash, the KG-version hash, the prompt-template hash, the decoder seed, the structured-grammar hash, the KG citations the LLM relied on, and the Symbolic Verifier's per-assertion result. An auditor with the public key, the recorded transcript, and the KG version can reconstruct the evaluation step by step and reach the same envelope. The framework does not claim the underlying LLM is bit-deterministic — floating-point non-associativity makes that infeasible at scale. What is guaranteed is that the provenance of any verdict is complete, signed, and replayable. The audit ledger's hash chain plus the per-row transcript signature is the contract that makes v3 verdicts legally defensible.

The shift from bounded determinism to verifiable provenance is the architectural core of the v3 neuro-symbolic pivot. A regulator or auditor cannot inspect inside an LLM — but they can verify a signed transcript, replay it against the recorded KG version, and confirm the Symbolic Verifier's per-assertion cross-check. Provenance is architecturally enforced, not behaviourally expected.

3

A3 — Passive Oversight

The SKI evaluation layer shall not sit in-line with primary operational systems

SKI operates as a read-only sidecar, consuming telemetry from data buses without the primary operational system being aware of its presence. If the SKI engine fails, is taken offline for maintenance, or is deliberately isolated, primary operations continue without any interruption. SKI has no write path, no control path, and no alert path that can interrupt primary operations.

Monitoring systems that become operational dependencies introduce unacceptable risk in safety-critical environments. Passive oversight preserves all existing safety margins while adding a compliance intelligence layer. No safety case or risk assessment needs to account for SKI failure modes affecting operations.

Spec A5 — The Three Pillars

The Three Pillars

Each pillar translates one or more axioms into concrete implementation requirements. Meeting the axioms without meeting the pillar requirements is insufficient — the pillars define what "compliance" means in practice.

Structural pillars

S

Pillar S · Spec A5

Sovereignty

The asset owner retains full control over inference logic, operational data, and all update pathways. The SKI engine is physically and logically inseparable from the asset owner's infrastructure. No inference, data transfer, or model update path exists that does not require explicit, physically verified action by the organisation. The sovereign boundary is not a network policy — it is an architectural constraint enforced by physical separation.

Implementation requirements

On-premise edge compute node Hardened operating environment Air-gap capability One-way Knowledge Graph transfer mechanism No outbound runtime network path Physical access log for all sovereign boundary crossings

K

Pillar K · Spec A5 / B2

Knowledge Maps

All compliance evaluation is performed against a verifiable, auditable v3 Knowledge Graph: a typed graph of Subjects, Rules, Obligations (twelve typed obligation types per spec §3.3), Definitions, Exemptions, Precedents, Jurisdictions, and Citations, connected by eight typed edges (applies_to, consists_of, defined_by, exempted_by, amended_by, interpreted_by, scoped_to, cited_by). Every obligation is scoped by jurisdiction and effective date. Every verdict is traceable to a specific node and a verbatim source-document citation. The Knowledge Graph is the complete, explicit, human-approved encoding of the compliance rules in scope.

Implementation requirements

Typed v3 obligation graph (12 obligation types, 8 edges) LLM extraction (kg-extractor) Schema validation (kg-validator) Ed25519 signing (ski-model-deploy) Jurisdiction + effective-date scoping Typed-obligation grammar Source-clause citation per obligation

I

Pillar I · Spec A5 / B3

Intelligence

The Intelligence pillar is a neuro-symbolic pairing: a KG-grounded local LLM (temperature 0, structured generation) and an independent Symbolic Verifier that cross-checks every formalizable assertion. The LLM reasons over KG nodes and emits a structured verdict; the Symbolic Verifier mechanically checks the formalizable assertions in that verdict against the KG and records its per-assertion result. Both outputs, plus the signed LLM transcript, are sealed into the V3VerdictEnvelope. An agreement monitor tracks the rolling agreement rate between the LLM verdict and the Symbolic Verifier (default last 1000 evaluations); a sustained drop below the configured threshold pages the on-call rather than silently accepting either view.

Implementation requirements

Local LLM, temperature 0, structured generation (llm-evaluator) Signed LLM transcript per verdict (ed25519, runtime key) Symbolic Verifier per-assertion cross-check (symbolic-verifier) Agreement monitor — rolling agreement-rate (agreement-monitor) Model-weight hash, KG-version hash, decoder-seed in envelope Read-only sidecar architecture — zero write-path to operations

Spec A6 — Verdict Taxonomy

Verdict Taxonomy

Every evaluation produces exactly one of five categorical verdicts. The taxonomy is closed — there is no mechanism for the system to produce a verdict outside this set, emit a confidence score, or return a free-form response.

The five verdicts

CLEAR

→ Audit ledger (silent)

All applicable Knowledge Graph rules have been evaluated against the incoming telemetry. No compliance issue has been detected. The verdict is logged to the immutable audit ledger with a timestamp, the Knowledge Graph version hash, and the evaluated rule set.

CLEAR verdicts are silent — no notification is sent to any operational owner. They form the continuous audit evidence that the system is operating within compliance boundaries.

FLAG

→ Designated operational owner (urgent)

A compliance rule encoded in the Knowledge Graph has been breached by the incoming telemetry. The verdict includes the specific graph node, the policy clause it encodes, the operational tag that triggered it, and the evaluated value. The designated operational owner is notified immediately.

FLAG verdicts carry the full traceability chain — from telemetry value through tag registry through graph node through source document. This chain is what makes the verdict defensible in a regulatory examination.

NULL_UNMAPPED

→ Knowledge Graph Owner (coverage gap)

Telemetry has been received from a recognised operational tag, but no Knowledge Graph node exists that covers the compliance evaluation of this tag. This is a Knowledge Graph coverage gap — the system is receiving data it has no rules to evaluate. The Knowledge Graph Owner is alerted to expand the graph.

NULL_UNMAPPED is not an error — it is a signal. It means the system is seeing something real that the Knowledge Graph has not yet been extended to cover. The appropriate response is a Knowledge Graph update cycle, not an infrastructure investigation.

NULL_STALE

→ Operations team (infrastructure failure)

An expected telemetry stream — one that the Knowledge Graph has rules to evaluate and the Tag Registry is configured to receive — has gone silent. No data has arrived within the configured staleness window. This indicates a sensor failure, a pipeline interruption, or a network connectivity issue. Operations are alerted immediately.

NULL_STALE and NULL_UNMAPPED route to different owners and require different remediation. Conflating them leads to incorrect prioritisation — a NULL_STALE requires an infrastructure investigation, not a Knowledge Graph update.

DISCRETIONARY

→ Qualified human reviewer

The applicable Knowledge Graph rule has been evaluated, but the regulatory language encoded in the rule is genuinely ambiguous in context. The SKI Model has determined that the situation falls within the rule's scope, but that a categorical CLEAR or FLAG verdict cannot be issued without human interpretation. The verdict and full context are routed to a qualified reviewer.

DISCRETIONARY is produced when the KG-grounded LLM Evaluator determines a categorical CLEAR or FLAG verdict cannot be issued without human interpretation. The Symbolic Verifier will still record its per-assertion result for any formalizable assertions within the verdict. A high rate of DISCRETIONARY verdicts for a specific rule is a signal that the rule should be restructured in the Knowledge Graph to reduce ambiguity.

Spec Part B — Technical Architecture

Evaluation Architecture

Two phases. One sovereign boundary crossing. One v3 evaluation path. The probabilistic work of policy interpretation happens once, offline. The neuro-symbolic evaluation happens continuously, inside your sovereign boundary. Every component is designed so that its failure mode is safe.

Neuro-symbolic evaluation

Every verdict is produced by a neuro-symbolic pairing. Both components run on every evaluation — neither is optional. The signed V3VerdictEnvelope seals both outputs together with the full provenance chain.

LLM EvaluatorKG-Grounded Local LLM

Role

Reasons over KG nodes and obligation graph using natural-language understanding. Emits a structured categorical verdict (CLEAR / FLAG / DISCRETIONARY / NULL_UNMAPPED / NULL_STALE).

Provenance guarantee

Produces a signed LLMTranscript (ed25519, runtime key) containing the full prompt, structured output, model-weight hash, KG-version hash, prompt-template hash, decoder seed, and structured-grammar hash.

Runtime constraints

Temperature 0 · Structured generation only · Read-only KG access · No outbound network

+

Symbolic VerifierIndependent Cross-Checker

Role

Mechanically checks every formalizable assertion in the LLM's verdict against the KG. Runs independently — does not see the LLM's reasoning, only the KG and the assertions to check.

Output

Per-assertion result (AGREED / LLM_CONTRADICTION / NEURO_SYMBOLIC_DIVERGENCE / UNVERIFIABLE) sealed into the V3VerdictEnvelope alongside the LLM transcript.

Statuses

AGREED — the verifier independently reached the same outcome as the LLM for this formalizable assertion. LLM_CONTRADICTION — the LLM's structured assertion contradicts the verifier's mechanical check on the same telemetry; the strongest signal that the LLM hallucinated. NEURO_SYMBOLIC_DIVERGENCE — both reached a categorical answer but on different bases (e.g. different rules in scope), recorded for human review. UNVERIFIABLE — the verifier couldn't check the assertion (telemetry missing, predicate not yet implemented, or KG citation invalid); not silent acceptance — the envelope still records the LLM's claim and the verifier's "couldn't verify" status.

Agreement monitor

Tracks the rolling window of verifier statuses (default last 1000 evaluations). Reports agreement_rate = AGREED / total and exposes is_healthy(), which returns False when the rate drops below the configured threshold (default 0.95). A sustained drop pages the on-call — the runtime never silently accepts persistent divergence.

Both components run on every verdict. An auditor receives the complete V3VerdictEnvelope: signed LLM transcript, KG citations, Symbolic Verifier per-assertion result, and all hash anchors. Defensibility is reconstructible from the recorded provenance — it is not contingent on the LLM producing bit-identical output across runs.

Two-phase pipeline

The pipeline separates the probabilistic work (LLM extraction, offline) from the deterministic work (runtime evaluation, on-premise). Once the signed Knowledge Graph crosses the sovereign boundary, no further probabilistic processing occurs inside it.

Phase 1

Offline Compilation

Outside sovereign boundary

01

Source documents. Regulatory texts, permits, and policy documents are ingested by the extraction pipeline.

02

LLM extraction. A large language model converts natural-language policy into a v3 Knowledge Graph: typed Subjects, Rules, Obligations (twelve types), Definitions, Exemptions, Precedents, Jurisdictions, and Citations — all scoped by jurisdiction and effective date.

03

Human validation gate. A qualified Domain Expert reviews every extracted rule against the source document. No rule enters the graph without sign-off.

04

Cryptographic signing. The Knowledge Graph Owner signs the completed graph. The signature is the organisation's attestation that the graph has been reviewed and approved.

▶

One-way transfer
No data leaves

Phase 2

On-Premise Runtime

Inside sovereign boundary — no outbound network

05

Read-only sidecar. A passive listener connects to existing operational data buses (MQTT, Kafka, OPC-UA, or equivalent) without modifying them or alerting the primary system.

06

Tag Registry. Raw operational tags are resolved to Knowledge Graph entities before reaching the evaluation engine — no runtime inference of tag identity.

07

Neuro-symbolic evaluation. The KG-grounded LLM Evaluator (temperature 0, structured generation) reasons over obligation nodes and emits a structured categorical verdict. It signs the full LLM transcript with the runtime's ed25519 key.

07b

Symbolic Verifier cross-check. The independent Symbolic Verifier mechanically checks every formalizable assertion against the KG and records its per-assertion result. Its per-assertion result (AGREED / LLM_CONTRADICTION / NEURO_SYMBOLIC_DIVERGENCE / UNVERIFIABLE) is recorded; the agreement monitor tracks the rolling agreement rate across evaluations, and a sustained drop below threshold pages the on-call rather than silently accepting divergence.

08

Immutable audit ledger. Every V3VerdictEnvelope (signed transcript + KG citations + Symbolic Verifier result + all hash anchors) is written to an append-only, hash-chained local ledger. No verdict is ever deleted or modified.

Spec Part D — Governance & Conformance

Governance

SKI is not autonomous. The governance model ensures that human judgement — not AI inference — has final authority over every rule, every verdict pathway, and every Knowledge Graph update. Every accountable decision traces to a named individual.

Named accountable roles

D1.1 · Role 1

Knowledge Graph Owner

Cryptographically signs every approved Knowledge Graph version — the signature is the organisation's attestation that the graph has been reviewed and approved
Authorises the update pipeline to proceed to production deployment
Reviews and approves all changes to the sovereign boundary perimeter specification
Named in every audit verdict as the signing authority at time of evaluation
Also custodian of the per-tenant transcript-signing key (ed25519); the key signs every LLM transcript the runtime emits

D1.1 · Role 2

Domain Expert

Reviews every LLM-extracted rule against the original regulatory source document before it enters the Knowledge Graph
Validates the routing intent for each rule and confirms the obligation type and edge type assignments are correct — misclassification is a silent correctness failure
Approves or rejects rule candidates — no rule enters the graph without human sign-off
Documents the basis for any DISCRETIONARY routing decisions

D1.1 · Role 3

Operational Owner

Designated recipient of FLAG verdicts — initiates remediation within defined response SLAs
Investigates NULL_STALE alerts (sensor or pipeline failures) and coordinates infrastructure response
Documents all remediation actions with timestamps in the audit record — documentation is additive only, the ledger is never modified
Responsible for confirming the Tag Registry mapping is accurate for their operational domain

D1.1 · Role 4

Compliance Reviewer

Reviews DISCRETIONARY verdicts where regulatory language is genuinely ambiguous
Documents the interpretation rationale and the regulatory basis for the human decision
May escalate to the Knowledge Graph Owner to add an explicit rule resolving the ambiguity for future evaluations
All decisions are logged alongside the verdict in the immutable audit ledger with the reviewer's identity

Knowledge Graph update protocol

D4 — Knowledge Graph Update Protocol

Every change to the Knowledge Graph — however minor — follows this governed sequence without exception. Emergency security patches to the runtime environment are permitted but require a post-patch agreement-monitor verification run before evaluation resumes.

1

Regulatory change identified — formal update cycle triggered

→

2

LLM extraction of new or changed rules from source documents

→

3

Domain Expert validation gate — rule-by-rule review against source

→

4

Knowledge Graph Owner signs new version with updated hash

→

5

One-way transfer into sovereign boundary — no reverse path

→

6

Audit ledger records the graph version transition with timestamp

Every verdict in the audit ledger records the exact Knowledge Graph version hash that produced it. A regulatory audit can reconstruct the precise rule set active at any point in time — including the name of the Domain Expert and Knowledge Graph Owner who approved it.

Spec Part C — Implementation

Implementation Roadmap

From regulatory text to live compliance monitoring in five structured phases. Each phase produces a concrete artefact that bounds the phases that follow it.

The five phases

01

Assess & Scope

Map the regulatory landscape to your operational environment. Identify which regulations apply, which systems produce the relevant telemetry, and define the sovereign boundary perimeter. This phase produces the scope document that all subsequent phases are bounded by.

Output: Scope document · Regulatory inventory · Sovereign boundary specification

02

Extract & Structure

Run the kg-extractor pipeline over source regulatory documents. Convert natural-language policy obligations into v3 KG shape: typed Subjects, Rules, Obligations (twelve obligation types), Definitions, Exemptions, Precedents, Jurisdictions, and Citations — all scoped by jurisdiction and effective date. Map each obligation to an operational tag in the Tag Registry.

Output: Draft Knowledge Graph · Track assignments · Coverage map · Tag Registry draft

03

Validate & Sign

Every extracted rule is reviewed by a qualified Domain Expert against the source regulatory document. Rules that pass validation are compiled into the signed Knowledge Graph artefact. The Knowledge Graph Owner's cryptographic signature is the organisation's legal attestation of review and approval.

Output: Signed Knowledge Graph v1.0 · Validation report · Signed artefact hash · Owner attestation record

04

Deploy On-Premise

Install the SKI edge node within your sovereign boundary. Connect the read-only sidecar to existing data buses (MQTT, Kafka, OPC-UA). Configure the Tag Registry to resolve operational tags to Knowledge Graph entities. Verify the network topology to confirm no outbound runtime paths exist.

Output: Live edge node · Connected data streams · Operational tag registry · Network topology verification

05

Monitor & Govern

Continuous compliance intelligence from day one. Manage Knowledge Graph updates through the governed update pipeline as regulations change. Every new version is validated, signed, and logged — maintaining a complete regulatory provenance chain that can survive a full regulatory audit.

Output: Continuous compliance stream · Immutable audit ledger · Regulatory provenance chain · Update cycle records

Sector Applications

SKI was architected for environments where regulators audit every decision, data sovereignty is non-negotiable, and system failure is not an option.