Every organization I work with is now using AI. Almost none of them own anything as a result.
That is not a complaint about the technology. It is an observation about where the value is settling. The model your team uses this quarter is the same model your competitor uses, rented from the same provider, replaced by a better one in six months. Whatever advantage it gives you, it gives everyone. What cannot be rented is what your organization knows: the decisions, the measurements, the failures, the corrections, the ten years of "we tried that and here is what happened."
And that knowledge is in worse shape than most managers believe.
The thing nobody checks
Pick any organization that has existed for four years and look at its documents.
A device manufacturer keeps a technical file: specifications through several revisions, risk analyses, verification reports, instructions for use, change notices. An automotive supplier keeps requirement stacks. An engineering firm keeps specification revisions and the correspondence around them. Everyone keeps a wiki that three people have edited since 2022.
Now ask a simple question of that material: does it agree with itself?
In my experience the answer is no, and the disagreements are not exotic. The instructions for use say the battery can be swapped during operation. The current specification says any power interruption requires re-initialization, because a change notice altered the power architecture and nobody updated the manual. The test report records a cold start at minus twenty five degrees. The specification requires minus thirty two. Two interface documents give different pinouts, neither referencing the other. A design review retired an option that the specification still lists.
Each of those is cheap to fix on the day it appears and expensive to discover during an audit, a recall, or a customer dispute. None of them is anyone's job to find. They are found by accident, or by an auditor.
Why the AI you already have does not catch this
Because it was not built to. Retrieval systems find, they do not reconcile. Ask an assistant about the battery and it returns whichever passage matched your phrasing best, with confidence, having never compared it to anything. The contradiction is invisible because comparison is not part of the architecture.
The obvious workaround, paste everything into a very large context window, does not survive contact with reality either. Models attend unevenly across long inputs, so you get some conflicts, different ones each run, with no record of what was compared and no way to reproduce the result. That is not an audit. That is a lottery.
What the job actually requires is unglamorous:
Break documents into individual claims, each anchored to the exact sentence that produced it. Check every claim against its own source before you store it, so that a model misreading does not become a permanent fact. Compare claims against each other systematically, across the whole corpus, with the comparison recorded rather than emergent. Do it deterministically where determinism is possible, because most real conflicts in technical documentation are numeric, and arithmetic is better at numbers than judgment is. Track when each statement was true, so that a superseded figure closes rather than lingering. And end every one of those operations in something a person can inspect.
None of that is clever. All of it is work.
What I built
Cogeto is that work, made into a system. It reads what an organization actually holds, including spreadsheets and scans, turns it into verified facts with their sources attached, checks the corpus against itself, tracks what was true and when, and produces a signed findings report that a quality lead can forward to an auditor.
Three design decisions carry most of the weight.
Verification happens before storage, not after retrieval. Every extracted claim is re-checked by an independent pass against its own cited sentence. A claim its source does not support never becomes something the system will assert later. Most systems check at generation time, which protects one answer. Checking at admission protects every future answer that would have rested on that fact.
Contradiction detection is a product, not a side effect. Subjects are resolved across aliases and languages, so "Adriatic Foods" and "Jadranska hrana" are one company. Quantities and units are compared arithmetically before any model is asked, so three point two millimetres against three point four is caught by subtraction rather than opinion. Every finding carries both claims, both verbatim sentences, both documents with their revisions, and the date it was detected.
Every trust claim ends in an artifact. A source span for provenance. A published accuracy score, per language and per model configuration, including the numbers that are not flattering. A signed report for findings. A hash-chained receipt for deletion, verified again every night, so that "we deleted it" is something a compliance officer can file rather than something a vendor says.
It runs as one instance per customer, on infrastructure you choose, in Europe, and it runs fully offline if your material cannot leave the building. The code is open, because every claim above is a claim about code, and a system whose entire thesis is inspectability has no business being a black box.
What it does not do
It does not out-reason a frontier model, and it is not trying to. It knows only what was written down, so it cannot recover the judgment your best engineer never documented. Its extraction quality is measured rather than asserted, and the measurements are published with the gaps visible, including the languages where it is weaker. And it does not decide which of two conflicting statements your organization will stand behind, because that is an authority question, not an evidence question, and no model should be answering it.
That last distinction is the one I would keep if I could keep only one. A system should resolve what it can measure and present what it cannot. Most AI products get this backwards: confident where they should defer, silent where they could have checked.
The paper
I wrote up the architecture, the mechanisms, the evaluation methodology, and the regulatory reasoning behind it in a whitepaper, including the published measurements and where the system currently falls short of its own targets.
Cogeto: A Verifiable, Sovereignty-First Memory Architecture for Large Language Model Assistants is available here:
It is written for engineers and for the people who have to answer for what an organization's documents say. If you work in regulated documentation, or you have a document set nobody has read end to end in three years, the sections on contradiction detection and on the findings report are the ones worth your time.
If you want to talk about any of it, or you would like to see what the findings look like on your own material, write to me.
