Don’t let the model decide what’s true.

The problem isn’t finding information.

It’s what happens when the information disagrees.

Ask an agent about a used guitar and it might find a seller calling it a 1968 Telecaster, an owner saying the finish is original, a dealer saying it was refinished, a serial number suggesting one date, and a component date suggesting another.

An LLM can reason across all of that. It can also turn it into: “This is a 1968 Fender Telecaster with its original blonde finish.”

Now the disagreement is gone. So are the uncertainty and provenance.

ObjectCanon takes a different approach.

Claims, not facts.

ObjectCanon doesn’t pretend to know whether a 1968 Telecaster’s finish is original.

It records who says it is. It records who says it isn’t. It keeps the source, confidence, evidence, and timing behind each claim.

Then it applies an explicit rule to determine which claim currently wins. Nothing gets silently discarded.

The agent gets the answer and the receipt.

The 1968 Telecaster, straight from the server.

"finish": {
  "value": "Blonde, original",
  "source_kind": "owner",
  "confidence": "low",
  "evidence": "contested",
  "contested_by": [{
    "value": "Blonde, refinished",
    "source_kind": "third_party",
    "confidence": "medium"
  }],
  "resolved_against_stronger_evidence": true
}

"neckOriginal": {
  "value": true,
  "evidence": "contested",
  "abstentions": [{
    "source_kind": "ai",
    "confidence": "low",
    "asserted_at": "2026-09-01",
    "reason": "insufficient_evidence"
  }]
}

If stronger evidence lost because of the policy, ObjectCanon says so. An agent can use the default resolution or inspect the claims and apply a policy appropriate to its task.

Preserve the disagreement. Make resolution explicit.

ObjectCanon separates evidence from resolution. Claims describe what different sources say about an object. Resolution rules determine which claim becomes the current answer.

The LLM doesn’t decide what wins. Given the same claims and the same policy, ObjectCanon returns the same result.

That’s the deterministic part.

Agents increasingly have to act on messy reality.

This problem isn’t unique to guitars. A house can have conflicting square-footage records. A car can have conflicting mileage or service records. A watch can contain replacement parts. A painting can have disputed attribution. A piece of furniture can have several possible dates. A collectible can have competing provenance claims.

The difficult question isn’t always, “What information can the agent find?” Sometimes it’s, “What should the agent do when reliable sources disagree?”

Don’t hide the disagreement inside the model. Keep the claims. Keep the evidence. Make the resolution policy explicit.

Canonical doesn’t mean infallible.

ObjectCanon isn’t claiming to possess ground truth about every physical object.

The canonical part is the record: what is known, what is claimed, who claimed it, what evidence exists, what conflicts, and why the current answer won.

New evidence can change the resolved answer without erasing the history that produced the previous one.

The record can be canonical without pretending the answer is absolute truth.

The policy is explicit — and debatable.

The current experimental default evaluates source precedence first, then confidence, then recency:

owner > appraiser > third_party > ai   →   confidence   →   recency

This is an experimental default, not a universal hierarchy of trust. An insurer, marketplace, collector, estate administrator, researcher, or purchasing agent might reasonably rank the same evidence differently.

That’s why ObjectCanon returns the underlying claims with the resolved answer. The evidence can remain the same even when the resolution policy changes.

Think the policy is wrong? Good. The claims are still there.

Ask it yourself.

ObjectCanon is live as a remote MCP server. No signup. No API key. Read-only.

https://objectcanon.replit.app/mcp

• typesSee the object types and attribute vocabulary currently in use.
• lookupFind objects by type or by values in any claim, including claims that lost.
• resolveReturn the current resolved attributes, or request every raw claim with view: "claims".

Clients that take a JSON config:

{
  "mcpServers": {
    "objectcanon": { "url": "https://objectcanon.replit.app/mcp" }
  }
}

Tiny dataset. Intentionally.

ObjectCanon is an experiment in the shape of the answer, not the size of the catalog.

The current server contains 53 public records: three hand-built objects — a guitar, a watch, and a table — plus 50 clearly labeled synthetic guitars designed to exercise clean, contested, corroborated, abstained, sparse, recency-tiebreak, and confidence-tiebreak cases.

The point right now isn’t coverage. It’s to test whether this is a useful way for agents to deal with conflicting information about physical things.

What ObjectCanon is — and isn’t.

The web gave pages URLs.

It gave machines a reliable way to refer to digital resources. Physical objects never got the equivalent.

An agent trying to understand a guitar, watch, chair, camera, tool, car, or artwork usually has to reconstruct its identity from whatever descriptions happen to be available. Those descriptions are messy. They change. They conflict. Increasingly, machines are expected to act on them.

What would it look like if physical objects had records that agents could read consistently, with the evidence attached?

That’s the question ObjectCanon is testing.