There is a quiet difference between a system that generates an answer and a system that is accountable for it. The first produces plausible text. The second shows the origin of every claim it makes.
Hallucination is not an occasional defect you fix by swapping in a larger model. It is the natural consequence of a system trained to produce the most probable continuation of a text — not the most verifiable one. Fluency and truthfulness are different properties, and optimizing one does not guarantee the other.
For someone asking a casual question, a convincing answer with no source is enough. For an institution deciding on a case, a report, a public tender or a right, it is unusable — because a decision that cannot be justified back to its origin is not a defensible decision.
An answer you cannot audit back to its source is not an answer — it is an opinion wearing the appearance of a fact.
The question that separates a decision-support tool from a convincing text generator is not “is the answer right?”. It is: “can I check where it came from, on my own, without having to trust whoever answered?”
Verifiability is not a personality trait of the model. It is a property of the architecture around it.
In a retrieval-augmented pipeline, the answer does not come from nowhere: it is assembled from concrete passages retrieved from the organization’s own corpus. The decisive point is what the system does with those passages after using them. Discarding them returns only the final text — and with it, the obligation to trust. Returning them alongside the answer makes every claim traceable.
In Orion Core, the answer and its sources are a single data contract, not two separate steps. Each answer from the pipeline returns, besides the text, the exact set of passages that grounded it — and each passage carries its provenance: the source file, the page, the document and fragment identifiers, and the relevance score with which it was retrieved. Returning the sources is the default behavior, not an option someone has to remember to switch on.
Concretely: each retrieved passage arrives with its content, its score and its origin metadata — filename, page_number, doc_id, chunk_id — and the answer returns them bound to the generated text. Verification stops depending on trusting the model and starts depending on opening the cited document and checking.
The difference between trusting and verifying is the difference between a citation and a promise.
This reverses the burden. In an opaque system, it falls on the user to prove the answer is wrong. In a system that cites its source, the answer already carries the means to be checked — and a claim with no basis in the corpus becomes immediately visible as such.
Citing the source is not a comfort feature. It is what makes AI usable where the decision has consequences.
In an organization handling sensitive documents — a public agency, a legal department, a healthcare area — the question “why did the system answer this?” is not rhetorical. It shows up in an audit, a challenge, a case review. A system that only returns text forces the operator to defend by inference something they cannot reconstruct. A system that returns provenance answers with evidence: this claim comes from this paragraph, on page X of document Y.
It also changes what happens when the source itself is wrong. If the answer points to the document that produced it, an error stops being a mystery of the model and becomes a locatable problem in the corpus — fixable at the origin, for every future answer. Without traceability, the same error is indistinguishable from a hallucination, and nothing guarantees it will not recur.
It is the same discipline as the previous Insight, one level down. Observability answers “what did the system do”. Source citation answers “why should I trust this specific answer”. Both refuse the same idea: that a system influencing decisions may ask to be trusted without offering any way to be verified.