A correction to my original model: provenance is not a boolean, and human verification does not automatically mean truth.
My previous article, The Living Ontology, argued that AI-generated and human-verified information should not be represented as separate entity types.
They are the same entity, with different provenance states.
I still believe that.
But a comment on the article exposed a limitation in my model that I had overlooked.
I treated provenance as a flag.
It isn't.
It is a structure.
The correction
In the original model, a StatusRow could look roughly like this:
StatusRow
- content
- isManuallyEdited
- sourceTask
The assumption was straightforward:
AI generated
↓
Human verifies
↓
Human edits
↓
Authoritative state
This works until we ask a simple question:
Which human?
And then another:
Based on what evidence?
Consider a house.
An AI vision model says the roof was replaced recently.
The homeowner says it was replaced ten years ago.
The municipal assessor has a record saying something different.
A contractor physically measuring the roof observes something else.
All four statements describe the same entity.
All four can have provenance.
But they do not have the same evidentiary status.
The problem is therefore larger than:
Was this generated by AI or edited by a human?
The real question is:
Why should the system believe this particular claim?
Provenance is a structure, not a flag
My original isManuallyEdited field collapses too much information into one bit.
It distinguishes:
AI
Human
But real systems need to distinguish between different kinds of evidence.
For example:
MEASURED
STATED
RECORDED
MODELED
These aren't universal truth rankings.
They are evidence classes.
A physical measurement is different from someone's statement.
A statement is different from an official record.
A model's inference is different from all of them.
The important part is that the ontology preserves the distinction instead of flattening everything into:
human = trusted
AI = untrusted
That distinction matters because provenance isn't simply about who produced the value.
It is about how the value became knowable.
Human verification is not the same as authority
This creates another problem with my original model.
I described the human override as sacred.
The intention was that once a human corrected an AI-generated value, the AI should never silently overwrite it.
I still think that invariant is useful.
But it doesn't answer what happens when two humans disagree.
Suppose:
Homeowner:
roof replaced in 2016
Assessor:
roof replaced in 2021
Both are human.
Both may be credible.
Neither should automatically overwrite the other.
The ontology needs another concept:
authority.
But authority should be scoped to a domain.
The assessor may be authoritative about a legal or valuation record.
The homeowner may be authoritative about their own intentions or recent work.
A vision model may be useful for describing what is visibly present.
These aren't necessarily competing claims.
They are claims operating under different authority boundaries.
Conflict is a valid state
This changes something fundamental.
Previously, I implicitly treated disagreement as something the system should resolve.
Now I think disagreement can itself be information.
Instead of:
claim A
↓
claim B
↓
choose one
we can represent:
┌── Claim A
Entity ─┤
└── Claim B
↓
CONFLICT
The system doesn't have to pretend that reality has been resolved when it hasn't.
This gives us another possible state:
UNVERIFIED
VERIFIED
OVERRIDDEN
CONFLICT
The exact states will depend on the domain.
The principle is more important:
An ontology should be able to represent uncertainty and disagreement without destroying either claim.
Conflict is not necessarily an error.
Conflict can be a property of the knowledge we currently have.
The ontology becomes a knowledge graph, not just a state machine
This also changes how I think about the original model.
I initially had something close to:
AI → Human → Frozen
The richer model looks more like:
┌── Evidence A
│
Entity ─── Claim ───┼── Evidence B
│
└── Evidence C
│
Authority Scope
│
Verification State
The entity is stable.
Claims about the entity can change.
Evidence can accumulate.
Different agents can disagree.
Authority can vary by domain.
And the ontology records those relationships rather than pretending there is always one canonical answer.
Verification must also expire
There is another consequence.
Suppose a human verifies a value.
Later, the underlying content changes.
Can the system continue saying:
VERIFIED
Probably not.
Verification is meaningful only relative to the thing that was verified.
So a verification can be bound to a content hash:
Claim
↓
Content
↓
Hash
↓
Verification
If the content changes:
new content
↓
hash mismatch
↓
verification expires
The system therefore doesn't merely remember that something was verified.
It remembers what was verified.
That distinction becomes critical in systems where information is continuously edited.
A revised model
The original model had:
StatusRow
- content
- isManuallyEdited
- sourceTask
The revised model might look more like:
Claim
- subject
- value
- provenance
- authorityScope
- verificationState
Evidence
- source
- type
- timestamp
- contentHash
Verification
- agent
- timestamp
- verifiedHash
- authorityScope
Conflict
- claims[]
- detectedAt
- resolutionState
Now the ontology can answer questions that the original boolean could not:
Where did this claim come from?
What evidence supports it?
Who verified it?
What authority did they have?
Was the underlying content changed?
Are there competing claims?
Is the conflict resolved?
If it is resolved, why?
That is a much more useful definition of provenance.
The deeper principle
My original article argued:
Provenance is the primary axis.
I would now refine that statement:
Evidence, provenance, and authority are first-class properties of knowledge.
AI doesn't simply generate facts.
Humans don't simply verify facts.
Systems continuously accumulate claims from agents with different evidence, authority, and confidence.
The ontology's job is not always to decide which claim is true.
Sometimes its job is to preserve enough structure that humans can understand why the system currently believes what it believes.
That changes the role of the ontology.
It isn't merely a representation of the world.
It becomes a representation of our relationship to what we believe about the world.
The machine still proposes
I still stand by the central idea from the original article:
AI proposes. Human disposes.
But I think it needs one more sentence:
And the ontology remembers why.
It remembers the evidence.
It remembers the agent.
It remembers the authority.
It remembers the disagreement.
It remembers what was verified.
And, importantly, it remembers when that verification is no longer valid.
That is a more complete trust model.
Not:
AI → Human → Truth
but:
AI
Human
Systems
Records
Measurements
↓
Claims
↓
Evidence + Provenance + Authority
↓
Verification / Conflict
↓
Current operational truth
The goal isn't to eliminate uncertainty.
The goal is to make uncertainty legible.
That is the correction I would make to The Living Ontology.
Top comments (1)
"Conflict doesn't mean error',amaizing read