Qriton

Not search. A governed knowledge pipeline.

Anyone can retrieve a document. What makes Qriton KB different is everything around the answer: where knowledge comes from, how it stays current without retraining, how corrections are reviewed by a named person, and how every step is certified. Here is the whole pipeline.

The pipeline, stage by stage

1

Sources

Official EU digital law: the AI Act, GDPR, DSA, DORA and a dozen more acts, fetched from the EUR-Lex / CELLAR publications office, article by article, each file carrying its rights basis. You always know where an answer can come from.

2

Ingest & prepare

Automated and repeatable: fetch, strip any stray markup, split by article, embed, and calibrate the answer threshold to this specific corpus. Point it at your own documents and the same pipeline runs with no model training; deny-policy deployments keep processing on this machine.

3

Answer, or refuse

A question retrieves the passage that supports it and quotes it, cited. Below the evidence bar there is no answer. It refuses and shows the nearest sections it considered. Refusing is a feature, not a failure.

4

Feedback

Anyone using it can propose a correction: the right answer plus the evidence it rests on. Nothing changes yet: the proposal enters a review queue. The people closest to the work improve the system without being able to silently rewrite it.

5

Govern the edit

A named reviewer approves or rejects. An approved correction applies as a certified fact, receipted and reversible, and can be forgotten byte-for-byte later. Knowledge changes through an audit trail, with no retraining and no redeploy.

6

Audit

Every answer, every refusal, and every edit is sealed into a tamper-evident hash chain. Anyone, including your auditor or your regulator, can verify the whole history has not been altered, without trusting us.

Runs entirely on your premises

Qriton KB installs on your own servers and answers from your own documents. Nothing is sent to an outside service, so your data stays inside your building, which is what makes it usable on regulated and confidential material.

LOCAL-ONLY DEPLOYMENT · YOUR PREMISES egress_policy=deny · external processing disabled Your documents EU law, or your own Qriton KB retrieve · cite · refuse deny-policy processing Cited answer + receipt Your team asks in plain language Governed memory review · receipt · reversible Tamper-evident audit chain every answer, refusal & edit sealed, verifiable by anyone Public internet / cloud blocked by deny policy

Why this isn't the search box you already have

vs. keyword or semantic search
Search returns documents and leaves the judgement to you. Qriton KB answers the question, cites the exact article, and refuses when nothing supports it.
vs. a fine-tuned language model
A fine-tuned model bakes knowledge into weights, so every change means retraining, and you can't point to why it answered. Qriton KB keeps knowledge as data under governance: edit it, receipt it, reverse it, forget it, with no retraining.
vs. an off-the-shelf RAG assistant
The usual "search + an assistant" has none of the guarantees. Qriton KB adds fail-closed refusal, named-reviewer edit governance, byte-exact forget, and a tamper-evident certificate on every transaction you can verify yourself.

Questions before you try it

We already have a chatbot. What would change?
Probably not your chatbot. Qriton KB is self-contained, with its own retrieval and its own governance, so most teams point it at the narrow slice of questions they would actually have to defend and leave the rest where it is. Nothing about your current setup has to change to trial it: no account, no install, nothing to connect.
Which AI models can it use? OpenAI, Anthropic, open source?
The model that writes the answer is a configuration choice: OpenAI, Azure OpenAI, a local open-source model (Qwen and other Hugging Face chat models run on your own hardware), or no model at all. That last option quotes the source passage verbatim, and it is the most defensible setting because nothing is paraphrased. Embeddings are likewise either local (sentence-transformers) or OpenAI. Anthropic is not a built-in provider today and we would rather say so than imply otherwise; the generator is a single interface, so adding one is small work. On-premises deployments normally use the local open-source path, since that is what keeps data inside the building.
Can we connect it to our own systems and pull knowledge in automatically?
Yes. Documents arrive through a connector: a local directory, a network share, or a blob manifest for object storage. Watch mode polls on an interval and re-ingests changes on its own, and re-indexing is incremental, so only new or changed sections are re-embedded. Everything the interface does is also a plain HTTP API on the same service, including asking a question, triggering and checking an ingest, submitting a correction, fetching a receipt by hash, verifying the chain, and reading metrics. Integration is ordinary HTTP against your own host.
Can different teams be limited to different parts of the knowledge base?
Straight answer: not by user or group yet. Today the boundary is the deployment. Each instance carries its own corpus and its own audit chain, so the normal pattern for genuinely separate audiences is a separate instance, which also keeps their records separate. The retrieval layer already accepts a source restriction, and answers are already scoped to a subset of documents when a question calls for it, so that is the hook per-group access would be built on. What does not exist is the account and group model to attach it to. If per-group access is a requirement rather than a nice-to-have, say so early in a pilot: it is a real piece of work, not a config flag.
Can we test and tune how well it performs?
Yes, and you should before trusting it. There is a scorecard you can run locally against your own corpus, the answerability threshold is calibrated to your documents at ingest rather than shipped as a guess, and live metrics are exposed. Because every answer and every refusal is recorded, you can also audit real usage after the fact instead of relying on a benchmark: the log is the evaluation set.
Where does our data go?
Nowhere outside your building. Qriton KB installs on your own servers and answers only from documents you provide. Nothing is sent to an outside service.
How accurate is it?
As accurate as an ordinary AI assistant on the same questions. We measured it, and it's a tie. The difference isn't the answer; it's what you can prove about it afterward.
What happens when it doesn't know something?
It refuses, and shows you the nearest sections it considered instead of guessing. No supporting source, no answer.
How does its knowledge stay current, and do you retrain the model?
No retraining, ever. Knowledge is data under governance, not weights baked into a model. Add, correct, or delete a fact directly, reversible, receipted, no redeploy.
Who can actually change what it knows?
Anyone can propose a correction with evidence. Only a named reviewer can approve it, and every change is on the record and reversible.
Do we need to sign up or create an account to try it?
No. The live proof, the chat product, and the receipt checker all work with no login and no account.
Is this legal advice?
No. It's informational and cited to source, not a substitute for legal counsel.
How long does it take to get running?
Ingestion is automated: point it at your documents and it indexes them and there's no model-training step, which is what a fine-tuned approach would require. A specific timeline for your own document set is part of the pilot conversation.
What does it cost?
It depends on deployment scope: self-hosted, with no external API calls to price in. Request a private pilot and we'll work it out together.
Try it yourself › See the 30-second proof › Check a receipt Request a private pilot ›

Straight talk: Qriton KB does not train a model, and it is not a legal adviser. It retrieves, cites, refuses, and keeps an auditable record, and the governance around that is the product.