Curio AI logo Curio AI
A verified knowledge layer for documents and agents

Your documents disagree with each other. So do your AI's answers.

Someone makes a decision on a page that another page contradicts, and nothing in your stack was looking. Curio gives you one entry per thing your documents describe, with its disagreements listed, both sentences quoted and both sources named. That is possible because the layer holds rules about what can be true at the same time, instead of ranking which passage looks most like the question.

One canonical answer Contradictions surfaced with sources Findings no single document states Check what your AI claims

Your knowledge base gets less reliable the longer it lives — and now your AI reads it.

Most documentation starts clean. Then it spreads across pages, branches, translations and copied runbooks. Search gets noisy, answers disagree, and the assistant you put in front of it inherits every disagreement without knowing it.

×

Duplicate knowledge everywhere

The same process gets rewritten in several places, and each copy drifts. Teams end up comparing pages instead of getting an answer.

“Customer refund flow” appears in 4 pages
2 pages disagree on approval thresholds
!

Outdated information still ranks

Search returns old material because it is popular, not because it is correct. Decisions that were reversed still read as current.

Old policy still appears in top results
Recent change never propagated across docs
?

People stop trusting the docs

Once trust drops, people ask in chat instead. The answer lands in a DM, and the documentation gets worse.

Answers move from docs to private chats
Contributors hesitate to update pages they're unsure about
AI

Your AI inherits every contradiction

Retrieval over a corpus that disagrees with itself still produces a confident answer — built from whichever chunk scored highest. The model can't tell that the passage it found describes a different version, a different distribution or a different population, and it has no way to tell you the sources disagree.

Assistant cites a superseded policy as current
Answer correct for one product variant, served for another
Why search can't do this

Search finds what looks like your question. It was never asked to decide what can be true.

Three approaches to the same pile of documents, on the questions a buyer actually has. These are approaches, not products.

Your question Search over documentsRAG Search over a graph of factsGraphRAG A checked knowledge layerCurio
What happens when two sources disagree? Returns the passage that scores highest and answers from it. The disagreement never surfaces, because nothing compared them. Stores both. Two facts about the same thing are two entries; nothing decides they cannot both hold. A thing is removed once, and one deadline is one deadline. Two different answers in the same slot are a contradiction the layer derives, and it shows both sentences with their sources.
Do I have to already suspect the problem to find it? Yes. It answers questions. A contradiction nobody asked about stays invisible. Largely yes. Traversal follows the question you ask. No. Everything comparable is compared, so findings arrive without anyone suspecting them first.
What decides that something is a finding? A similarity score, which moves with the query, the chunking and the phrasing. A judgement made at answer time about two stored facts. A rule written down before the run. That is what lets a finding sit in a release gate or a review record rather than in a chat window.
When is it finished? Never. A ranked list has no bottom. Never, for the same reason. A finite, triaged queue. You can work through it and say so.
What about an answer that is right for a different version, region or population? Passes every check. The text matches; the scope is invisible. Only if scope was modelled as data, and only if the query asked about it. Scope is a field on every claim. “Right answer, wrong version” is its own verdict.
What does a finding come with? A passage and a confidence score. A path through the graph. Both sentences, both sources, the byte range in each, and the rule that made them incompatible.

Contradictions are the hardest case for similarity, not the easiest. Changing a number, a date or a “not” is the smallest possible edit to a sentence, so the contradicting version looks more like the original than a harmless rewording does. That is a property of how similarity works, not a gap that a better model closes.

Curio does not replace your search or your assistant. It sits underneath them, so that what they retrieve has already been checked.

What you get

Six things land in your hands.

One layer produces all of them.

1

A canonical entry per thing

One entry for every thing your documents describe, with every source it came from listed.

2

A finite conflict queue

Pre-sorted into genuine disagreement, extraction artifact, and needs-a-human.

3

Cross-document findings

Constraints that hold across your sources and are written down in none of them.

4

A verdict on any AI answer

Supported, contradicted, unsupported, or out of scope — each with the sentence behind it.

5

Scoped, cited context for your agents

Filtered to your version, your variant, your jurisdiction.

6

An ontology pack for your domain

The description of what can be true in your field, which stays yours and keeps working as your documents change.

The layer

Curio doesn't index your documents. It works out what they're about.

Indexing finds passages that look like your question. Curio does something different: it works out the things your documents describe, records what each source says about each one, and checks those statements against each other.

1

It reads everything, in every version.

All your sources, including the ones in other languages and the old branches nobody ever deleted. Nothing is excluded for being out of date — being out of date is a fact worth knowing.

2

It works out what the documents are actually about.

Not keywords — the real things: a setting, a process, a component, a threshold. Every way each one gets written is pulled together into a single entry, so four spellings of the same version number stop being four different facts.

3

It records what each source says, and what that's true for.

Every statement is attached to the thing it describes, tagged with the version, product variant, region or population it applies to, and linked back to the exact sentence it came from.

4

It compares them under rules fixed in advance.

The rules are written down before the run: a thing is removed exactly once, one deadline is one deadline. Whether two statements can both hold is decided by those rules, not by a score that moves with the query, the chunking or the phrasing — so every finding arrives with the rule that produced it.

Source documents
Upstream docscurrent
“…removed in v1.25.”
Vendor documentationconflict
“…removed in v1.24.”
Translated guidestale
Never updated after the rewrite
The layer
Resolve every name for the same thing into one entry
Attach each claim to its scope and its source sentence
Derive contradictions from the structure
Sort genuine disagreement from extraction noise
What you get
Canonical entry: PodSecurityPolicy
Deprecated v1.21 · replaced by Pod Security Admission
Removal release disagrees
“PodSecurityPolicy was removed in v1.25.”upstream · k8s/website
“PodSecurityPolicy was removed in v1.24.”vendor · distribution docs
scope: upstream vs vendor
Illustrative
Under the hood

The layer is an OWL ontology. Extraction produces entities, relationships and claims; contradictions are entailed by rules stated in advance, not inferred from similarity. Properties that can only hold one value — the release something was removed in, for example — turn two different canonical answers into a logical contradiction. Obligations that do not contradict but bind at the same time are surfaced as a co-applicability cluster, with the tightest value identified. Every claim carries its source document, byte span and content hash, so any statement is citable down to the sentence. Scope is explicit and typed: release, distribution, language, population, region, jurisdiction, notification stage.

Curio's own reference corpora: 228 documents and 7,349 claims across 27 entity classes in software; 145 documents and 6,916 claims in medicine; 4 instruments and 445 claims in EU law. These are public documents we selected, not customer results.

Narrowing is what makes a finding list finite. In software, 491 restatements were collapsed, 13 duplicate claims removed, 3 candidates adjudicated and cleared and 1 deduplicated, leaving 13 findings: 6 version drift, 4 numeric divergence, 3 logical inconsistency — 10 of them spanning more than one source and 4 more than one language. In medicine, 28 false positives were quarantined, 10 candidates adjudicated and all 10 cleared, 7 polarity candidates cleared and 9 deduplicated, leaving 24 findings — 15 numeric divergence, 6 temporal drift, 3 polarity — alongside 13 observations, of which 9 are projections and 4 are stated trends; 20 of the findings span more than one source and 13 more than one language.

What you do with it

Once the layer exists, three things get easier.

The same layer serves all three. It is not three products.

One

Cleanup becomes a queue you can finish

Cleanup stops being an endless manual audit and becomes a reviewable queue.

  • Duplicates arrive already merged into one canonical entry, with every source it came from listed
  • Real contradictions are shown side by side — both sentences quoted, both sources cited. You decide; you're not guessing.
  • Content that is stale rather than wrong is separated out: a version drift, an old branch, a translation that never caught up
  • Findings are pre-sorted into genuine disagreement, extraction artifact, and needs-a-human, so review time goes to the ones that matter
  • New content is checked on arrival: is this new, is this a restatement, or does it contradict something you already published?
Review queuesoftware reference corpus
Default flips between release branchesgenuine
TopologyManagerPolicyBetaOptions — default disabledv1.27 docs
TopologyManagerPolicyBetaOptions — default enabledv1.30 docs
both pages current for their branch
Hidden metrics: the two states cannot both holdgenuine
deleted after one releaseone page
remain available for useanother page
derived, not noticed
491 restatements collapsed before reviewartifact
Two

Wrong answers get caught before anyone acts on them

An answer is only trustworthy if something can verify it. The layer is that something.

  • An answer is broken into its individual factual statements, and each one is checked against the layer
  • Four verdicts, not a confidence score: supported (with the sentence it came from), contradicted (a source says otherwise), unsupported (nothing in your corpus backs it — the model made it up), and out of scope (true, but for a different version, product or population than the one asked about)
  • The scope check is the one nothing else catches. An answer that is perfectly correct for one release and wrong for yours passes every similarity check ever built.
  • Contradictions here are derived from rules fixed before the run, so a verdict comes with the rule and a citation, not a probability
  • Works as a gate before publishing, or as a review pass over what an assistant already told people
Three

Agents answer in your scope, or say they can't

Retrieval hands a model whatever text scored highest. The layer hands it the answer, its scope and its caveats.

  • The agent asks about a thing, not a string — so every way that thing is written in your docs resolves to the same entry, instead of fragmenting retrieval
  • Context is filtered to what applies: your version, your product variant, your region, your jurisdiction. Passages about everything else never enter the prompt.
  • Where sources genuinely disagree, the disagreement is passed through explicitly, so the agent reports it instead of silently picking one
  • Related facts come along: what replaced this, what depends on it, what it was deprecated in — so the agent offers the successor rather than confidently explaining something that's gone
  • Everything arrives with its source attached, so citations are real and checkable
  • Scoped context also costs less: fewer tokens spent on near-duplicate passages saying the same thing five ways
Under the hood

Verification decomposes an answer into atomic claims and resolves each one against the ontology. Support and contradiction are entailment results, not scores; scope mismatch is a separate verdict because a claim can be entailed and still be about the wrong release, distribution, population or jurisdiction. Retrieval is entity-first: resolve the mention to an entry, then select claims whose scope satisfies the query context, then return them with their provenance spans.

It's one layer. Curating your knowledge is the same work that makes your agents reliable — you do it once.

Proof it generalizes

The same engine, on three fields that have nothing in common.

Curio runs today on medical literature with a metabolic-health focus, on Kubernetes ecosystem documentation — kubernetes/website, k3s, minikube and OpenShift, across several release branches and several languages — and on EU regulatory instruments: GDPR, NIS2, DORA and the DORA delegated RTS, in their in-force consolidated versions from the official EU source. Not three configurations of a tool: the same code, unchanged. Every piece of domain knowledge lives in the ontology pack for that domain, never in the engine, and an automated test swaps one domain for another to show the engine has learned none of them.

That is the reason to expect it to work on your corpus, which resembles none of the three.

0 unrelated domains live on one unmodified engine
0 claims in the software reference corpus, from 228 documents
0 entity classes in the software domain
0 claims across 4 instruments in the EU reference corpus
EU reference corpus · one event, five deadlines
One incident3 instruments · 3 supervisory regimes

An incident at a regulated financial entity that also processes personal data. GDPR, NIS2 and DORA each apply, under a different supervisory regime, and five separate initial-notification duties bind at the same time.

jurisdiction: EU stage: initial notification

The EU corpus produced no conflicts at all. Its finding is this cluster: obligations that do not contradict each other and all hold at once. Across 4 instruments and 445 claims there are 3 cross-instrument co-applicability clusters.

GDPR Art. 33
“72 hours after becoming aware”GDPR · Art. 33 · consolidated version
NIS2 Art. 23
“72 hours of becoming aware”NIS2 · Art. 23 · consolidated version
NIS2 Art. 23 · trust service providers
“24 hours”NIS2 · Art. 23 · consolidated version
DORA RTS Art. 5
“no later than 24 hours from becoming aware”DORA delegated RTS · Art. 5 · consolidated version
DORA RTS Art. 5 · on classification as majortightest stated deadline
“4 hours from classification as major”DORA delegated RTS · Art. 5 · consolidated version

Every member of the cluster carries all six of these:

CELEX article consolidated version ELI byte range content hash
The tightest stated deadline in the cluster is four hours. No single document states that. It exists only in the relation between the five.

These are public documents we selected as a reference corpus. They are not a customer result.

The EU material is reused under Commission Decision 2011/833/EU, with the source acknowledged.

Only the Official Journal edition is authentic. Consolidated texts are documentation tools and have no legal value.

Medical reference corpus · one test, two authorities
Impaired fasting glucose: the lower bound disagrees
6.1 to 6.9 mmol/L (110 to 125 mg/dL)WHO
5.6 to 6.9 mmol/L (100 to 125 mg/dL)ADA
same test · same population
Under the hood

No domain literals in engine code, no branching on domain name, and a domain-swap parity test that runs one domain's configuration through another domain's pipeline and back. All of it is enforced in CI. Adding a domain means writing an ontology pack, not changing the engine.

Private beta. Every corpus on this page is public material we selected ourselves, not a customer result.

How the layer gets built, and how it stays right.

Curio is not a one-time cleanup project. The layer is rebuilt as your documentation changes, and everything new is checked on the way in.

Connect your sources

Wiki, docs, runbooks, repos, and every version of them. Old branches and other languages included.

Curio builds the layer

One entry per thing your documents describe, with every claim attached to its scope and its source sentence.

You resolve what genuinely disagrees

Reviewed side by side with citations. Extraction artifacts have already been filtered out.

New content is checked as it arrives

New, restatement, or contradiction. You find out before it's published, not after someone acts on it.

Your agents query the layer, not the pile

Scoped context in, answers checked on the way out.

Knowledge control center
Canonical entries one per thing · sources listed
Genuine conflicts both sentences quoted
Scope mismatches release · distribution · jurisdiction
Checks on AI output supported / contradicted / unsupported / out of scope
Illustrative
Private beta

Two reasons to want this early.

If your documentation has stopped being something you'd point a new hire at — duplicated pages, stale branches, answers that disagree — the layer is what turns that into a queue you can actually work through.

And if you're putting an AI assistant in front of documentation nobody has verified, the layer is what its answers get checked against before your users believe them.

Curio is in private beta. Leave your email and we'll get in touch when access opens.