Kronos Open Witness — KOW

One-Line Pitch

An open protocol for making digital assertions permanent, public, and independently verifiable — so that "it happened" can finally mean something.

The Problem

The oldest fraud in human history is simple: something happens between two parties, and one of them lies about it later.

For most of recorded history, the answer was witnesses. Physical presence. Notaries. Wax seals. The cost of faking a record was high enough that truth was the default path.

The digital world destroyed all of that. Identity is free. Timestamps are editable. Logs are deletable. Screenshots are faked in seconds. In the AI era, even the content of a conversation can be plausibly denied — there is no physical record, no wax, no witness.

The EU AI Act, ISO standards for algorithmic accountability, financial compliance frameworks — they all ask the same unanswered question:

How do you prove that a human reviewed an AI decision before it affected a real person?

Nobody has a clean answer. The infrastructure to answer it doesn't exist yet.

The Shape

Every meaningful digital assertion reduces to five things:

ARTIFACT  +  CLAIM  +  CLAIMANT  +  TIMESTAMP  +  ANCHOR

Artifact — anything with a SHA256. A script, a prompt, a contract clause, an AI decision, a medical record, a model weight.
Claim — what someone asserts about it. SAFE. REVIEWED. APPROVED. DISPUTED. WITNESSED.
Claimant — who made it, with identity ranging from anonymous to cryptographically delegated to institutionally backed.
Timestamp — permanent, server-independent. Not "our clock says." Something that survives us going offline.
Anchor — Arweave, a public blockchain, a pulsar timestamp, a Certificate Transparency log mirror. Something outside the claimant's control.

KOW is the protocol that binds these five things together into a single, verifiable, append-only record.

Why This Is Different

What Exists	What It Does	What It Misses
Blockchain transactions	Immutable ledger	Requires token economy and gas fees
PGP web of trust	Cryptographic identity vouching	Never went mainstream; requires ceremony
Notarization	Human witnesses a signature	Requires licensed humans; doesn't scale to AI
Certificate Transparency	Public log of TLS certs	Single domain, not a general primitive
Signed git commits	Code provenance	No trust hierarchy, no external anchor
Audit logs	Record what happened	Held by the same party being audited

KOW's difference: lightweight, AI-native, hierarchically trusted without being centralised, permanently anchored, open to any artifact type, composable.

The key insight the others miss: a transparency log doesn't need to verify truth. It needs to make lying about what happened expensive and visible. Those are different problems. KOW solves the second one, which is actually harder.

◆

The oldest problem: Forever, people could end a moment then lie about it, and no one besides the other party would know. We don't need to say whether what was agreed was true or not. We need to be able to say it happened — and have others believe us.

The Trust Hierarchy

KOW uses a delegated credential model:

Root Trust Provider (e.g. KronosTrustProvider)
    │
    ├── Issues delegated signing keys to agents, organisations, individuals
    │       └── Each key is scoped, revocable, use-counted
    │
    └── Future: External Trust Providers (industry bodies, notaries, VeriSign)
                └── Each brings their own identity backing to attestations

A credential only has meaning because someone else issued it and put their identity behind it. This is the oldest insight in trust systems. KOW makes it programmable.

An anonymous attestation still goes on record — it just carries less weight than one backed by a delegated key from a recognised authority. Both are permanent. Neither can be deleted. Counter-attestations are how disputes are resolved — not erasure.

The Token Format

# Direct operator token (short-lived, hourly window):
kronos_trust_v1:{providerID}:{hmac_hex}

# Delegated agent token (issued key, survives revocation check):
kronos_dkey_v1:{keyID}:{hmac_hex}

The chain:

{
  "id": "attest_255c4768",
  "artifact_sha256": "a260005...",
  "verdict": "SAFE",
  "evidence": "Reviewed all network calls...",
  "agent_id": "claude/session-id",
  "trust_provider": { "id": "KronosTrustProvider", "authority_level": "founder" },
  "chain_pos": 4,
  "prev_hash": "9c0bcd25...",
  "self_hash": "188c5f6b...",
  "submitted_at": "2026-05-11T18:07:25Z"
}

Each record hashes the previous one. Walk the chain, verify every link. Any tampering breaks the hash sequence. The chain is public. Anyone can audit it.

◆

This is not a blockchain. It is not a token. There is no coin. There is no gas. There is a chain of signed hashes that anyone can read and verify — and a trust hierarchy that any authority can join. The difference is the whole point.

What It Is Actually For

Right now: AI skill verification. When an agent fetches a script and is asked to run it, KOW provides a public record of who reviewed it, what they found, and whether any authority backed their assessment.

Near term: Any AI pipeline output that regulatory frameworks require to have been human-reviewed. The EU AI Act's Article 13 (transparency obligations). Financial services AI model governance. Medical AI decision audit trails.

Longer term: Any digital assertion between two parties that benefits from a permanent, independently verifiable record. The contract that was signed. The decision that was made. The output that was approved. The moment that happened.

What Exists Now

A working reference implementation lives in FreddyServer, an AI infrastructure server. It has:

Append-only NDJSON chain storage with SHA256 chain integrity
HMAC-SHA256 trust token system with ±1 hour validity window
Delegated key issuance, scoping, revocation, and use counting
Public attestation feed at skills.krisadamstv.com/{artifact}/attestations
Trust provider registry at skills.krisadamstv.com/trust/providers
GitHub mirror for independent anchoring

The protocol runs. The chain runs. The first real attestations are already on record.

The Open Protocol Path

KOW is not a Kronos product. It is a protocol with Kronos as the first reference implementation and founding Trust Provider — the same way Google runs Certificate Transparency infrastructure but CT itself is an open standard that any CA or browser can implement.

The goal is the same moment JSON had: when someone says "how do we record this?", the answer is "use KOW" — and in five years nobody thinks about why anymore. They just use it.

The spec is simple enough to implement in an afternoon. The trust hierarchy is open to any authority that wants to participate. The chain format is not proprietary. The anchoring is pluggable.

Kronos holds the root of trust initially because someone has to. That is not a lock-in. It is a starting point.

Next Step to Explore

Publish the protocol spec as a standalone document — independent of FreddyServer, independent of Kronos infrastructure. Something a developer can read, implement, and point other developers at. The reference implementation follows from the spec.

Connections

Proof as a Service→ — the anchoring layer that makes timestamps permanent
Fort Knox→ — the credential and identity layer that backs Trust Providers
Trust Mesh→ — proof-of-life at scale; KOW is the record format Trust Mesh needs