"The industry built AI that requires you to trust the model. AXIOM builds infrastructure that requires the model to earn trust — claim by claim, source by source, timestamp by timestamp."
AXIOM is not an AI product. It is the infrastructure that should have been built before AI was deployed into healthcare, legal, compliance, and enterprise environments.
Most organisations don't have an intelligence problem. They have a data trust problem. Their knowledge exists — fragmented, unvalidated, inconsistently versioned, impossible to trust at the point of need. Deploying a general LLM on top of that problem doesn't fix it. It amplifies it. The confident wrong answer looks exactly like the confident right one.
AXIOM fixes the data first.
Three components:
-
AXIOM Ingest — deterministic intake with three defined pathways: structured source parsing, Schema-Driven AST generation for semi-structured data, and a human-gated Augmented Review Interface for unstructured prose. Interpretation never happens inside the system.
-
AXIOM Justify — not a model. A deterministic, rule-based scoring engine that evaluates every ingested claim across six epistemic dimensions and assigns a Leighton Weight. Every decision is the result of explicit, auditable rules. It behaves identically every single time. You can read the code and know exactly why it made the decision it made.
-
AXIOM Present — an Extractive Semantic Translation Layer. A small, quantised language model operating under strict constrained decoding. Key domain values are selected from a validated token lookup map. Generative sampling applies only to connective prose. It cannot generate content outside the validated store. Architecturally incapable of hallucination.
Trust flows in one direction — from ingestion through justification to presentation. Nothing flows backwards. The presentation layer cannot contaminate the knowledge store.
Large language models generate fluent, authoritative output regardless of whether the underlying knowledge is sound, current, or grounded in anything verifiable. Confidence is not knowledge. Fluency is not truth. The foundations were poured without epistemic integrity built in — and no amount of patching fixes a foundation.
AXIOM does not patch the problem. It reframes the question entirely.
What regulated industries actually need is not artificial intelligence. They need trustworthy access to what they already know — validated at ingestion, weighted by source authority, versioned on update, and presented via a constrained interface that cannot invent what isn't there.
You don't give a new employee the entire company archive. You give them what they need to do their job today. AXIOM gives every role exactly that — nothing more, nothing less, nothing unverified.
Every claim evaluated across six independent dimensions:
- Source Grounding — lookup table, not inference
- Temporal Validity — date logic against domain-specific decay thresholds
- Domain Calibration — Deterministic Namespace Matching against Domain Taxonomy
- Internal Consistency — graph comparison against existing sub-graph
- Logical Coherence — formal parsing against precision rules
- Claim Granularity — vague language penalised, specific claims rewarded
A Linearly Scaled Epistemic Vector Calculation. An objective coordinate derived from the six scoring dimensions. Not a heuristic estimate — a reproducible mathematical result. Identical inputs always produce identical outputs.
Every validated claim stored as an immutable, cryptographically hashed SCP capsule — causally chained, append-only, human-readable. Independently converges with the Actors Model in distributed systems theory. The audit artefact that makes AXIOM regulator-ready by architecture, not by process overlay.
No cloud dependency. No external API. No data leaving the organisation. Runs on commodity hardware — validated on a Samsung S24 Ultra in Termux. INT4/INT8 quantised via GGML/ONNX Runtime for CPU-only execution on legacy and constrained devices. CRDT-based edge synchronisation for distributed deployments.
This is the part most READMEs skip.
I am a self-taught developer. My day job is facilities caretaker. I built AXIOM on a phone, around a full-time job, in Termux on a Samsung S24 Ultra. No server farm. No team. No funding.
I built it because I looked at how AI was being deployed — rushed to market, commercially packaged before the foundations were ready, handed to regulated industries without epistemic integrity built in — and I saw the problem clearly. Not from the outside looking in. From the inside, watching colleagues be told "we're happy with Excel" while the organisation quietly contracted an external company to build what I had already designed and pitched internally.
I didn't start with the architecture. I started with frustration. With the question: if you can't trust what the model says, what's the point?
The answer I arrived at — independently, from first principles, before I knew the academic terminology — was that the trust has to live in the data layer, not the model layer. The Semantic Capsule Protocol I designed independently converges with the Actors Model in distributed systems theory. The Leighton Weight framework I built independently converges with published epistemic weighting research. I didn't know those things existed. I just kept following the logic.
AXIOM is what happened when I stopped trying to make AI trustworthy and started building the infrastructure that makes trustworthiness possible.
This architecture was stress-tested across five rounds of deep technical review — including sessions with a general LLM acting as a Principal Systems Architect. Every objection was answered. Every gap was closed. The LLM was not in the pipeline. It never is.
I am publishing this because the work deserves to be visible.
Not to sell a product. Not to raise funding. To demonstrate that the thinking is real, the architecture is sound, and the problem is urgent. To find the room where this conversation belongs — with technical founders, compliance officers, healthcare technologists, and AI safety researchers who understand why epistemic integrity matters and are frustrated by the absence of it.
I am a self-taught builder who thinks at a level that my job title does not reflect. This repository is the evidence. The architecture has survived everything thrown at it. The components are built and operational. What it needs now is the right context — inside a technically ambitious organisation that has hard problems and values someone who solves them properly.
If that is your organisation — the commercial page has the details.
Axiom/
├── index.html # The Argument — homepage and architecture overview
├── distinction.html # AXIOM vs Standard LLM — the CISO conversation
├── documentation.html # Technical reference index (full docs under NDA)
├── commercial.html # Engagement paths and contact
└── applications/
├── healthcare.html # Clinical compliance, medical communications, Justitia
├── legal.html # Regulatory versioning, jurisdictional handling
├── enterprise.html # Onboarding, policy management, institutional memory
└── field.html # Offline-first, air-gapped, mobile deployment
AXIOM draws on and unifies several independently built components:
- SCRIBE — PM2-managed audit proxy daemon intercepting model API calls
- LENS — Live capsule store presenter, HUD and timeline views
- ChronoSCRIBE — Causal DAG ordering layer
- DataCube — Six-lens epistemic knowledge graph
- Leighton Weight — Trust weighting framework
- SCP — Semantic Capsule Protocol
These components are operational as part of the broader Explorer-d334 / Giblets Forge OS sovereign AI ecosystem.
Proof of concept. Working components. Architecture validated to enterprise depth. Not yet a packaged product. The right next step is an NDA conversation with the right organisation.
Full technical brief available under NDA. Reference implementations available for demonstration.
James Gilbert — JamesTheGiblet
Giblets Forge Ltd · Giblets Creations
Upper Heyford, Oxfordshire, UK
Self-taught. Neurodivergent. Built on a phone.
I wanted it. So I forged it. Now forge yours.
This architecture was stress-tested using a general LLM as an external review tool. The LLM was not in the pipeline. It never is.