CooL SDK Turns AI Execution Into Cryptographic Evidence

A TypeScript SDK for confidential computing, transparency logs, and hybrid post-quantum signatures. It is built to prove what ran, where it ran, and whether the record was tampered with.

9 min read • View on GitHub • More from Northwind-Cipher

A wide editorial scene shows an AI system on the left feeding a sealed receipt machine in the center, then a transparent vault on the right. The scene explains how runtime events become tamper-evident evidence that can be carried into an audit or later verification.
CooL does not just record events. It turns them into receipts that can be checked long after the original system has moved on.
Key Takeaways

Why a log is not enough

A JSON log tells you a story after the fact. It does not automatically tell you that the story is intact, that the bytes were canonical, or that the system running the code was the one you meant to trust. CooL starts from that gap and treats it as the product.

That is why the repo reads less like a logging SDK and more like a receipt system. It is built for the moment when a team needs to prove who changed what, when, and under which execution conditions, without handing over the entire contents of the underlying data.

Standard logCooL receipt
Records an eventCommits to an event
Readable, but easy to mutateDeterministic and tamper-evident
Usually tied to a service databaseVerifiable offline from the receipt itself
Good for debuggingGood for audits and disputes
Trust comes from infrastructureTrust comes from cryptographic structure
A close editorial scene shows a single record flowing through a sequence of stamped stages. The image explains how CooL adds privacy, determinism, append-only integrity, and authenticity one layer at a time.
The receipt is not one proof. It is a stack of proofs, each adding a narrower attack surface.

CooL’s receipt line

The main flow is simple to say and harder to fake: observe, commit, sign, attest, anchor. CooL takes an event and turns it into a receipt that can be checked later without trusting the original runtime or the original operator.

This diagram shows the full evidence pipeline, not just the crypto pieces. Each stage adds a different property, from privacy to append-only integrity to provenance.

The interesting part is not the sequence itself. It is the fact that CooL refuses to collapse privacy, integrity, and provenance into one vague trust claim. Each stage does a different job, and the final receipt only means something because the earlier stages are explicit about what they guarantee.

const receipt = await cool.record({
  event: "prompt_changed",
  payload: {
    promptId,
    modelId,
    permissions
  }
})

const verdict = await cool.verify(receipt)
// verdict.ok depends on the cryptographic layers, not on a server callback

What makes the receipt hard to fake

CooL leans on canonical CBOR so the same logical object always becomes the same byte sequence. That matters because hashes only defend you if the input bytes are stable. If the representation can drift, the proof can drift with it.

The other key move is the transparency log. Records become Merkle leaves, which makes inclusion proofs possible and makes truncation or rewriting visible. That pushes CooL into a different category from normal observability tools: it is not just storing history, it is making history accountable.

Salted commitments fill the privacy gap. They let the system prove that a specific input existed without exposing the plaintext in the public evidence object. The result is a receipt that can be checked without turning into a data leak.

Why CooL signs twice

The hybrid signature block is the clearest sign that this project is thinking in time horizons, not just release cycles. Ed25519 gives you a mature classical signature today. ML-DSA-65 gives you a post-quantum layer for the world the project expects to outlive.

LayerWhat it buysWhy it exists
Ed25519Fast, widely understood authenticationProtects today’s deployments
ML-DSA-65Post-quantum resilienceProtects long-retention evidence
Hybrid verificationBoth signatures must passReduces single-algorithm dependence
Canonical CBORStable bytes before signingPrevents representation drift

That dual-signature choice is not ornamental. It says the receipt should remain defensible even if one era of crypto ages badly. For regulated AI and long-lived archives, that is a serious design constraint, not a feature bullet.

Simulated is not hardware

CooL does something rare in developer tooling: it distinguishes simulation from hardware-backed evidence instead of hiding the difference behind a friendly green checkmark. The verifier can tell you when something is real, and when it is only a faithful rehearsal.

PathWhat it meansRisk
SimulatedThe flow was exercised without a real TEEGood for development, weak for proof
Hardware-attestedThe record is tied to a trusted execution environmentStronger evidence, stronger operational requirements
InvalidThe receipt fails cryptographic or attestation checksShould not be relied on at all

That honesty is one of the repo’s strongest signals. It is easier to market every check as proof. It is harder, and more useful, to make the verifier say exactly how much trust the record deserves.

Where CooL fits in the market

CooL sits between observability, transparency logging, and attestation. It is not trying to replace Langfuse-style tracing or a supply-chain attestation platform. It is trying to make AI change history cryptographically defensible.

CategoryWhat it optimizes forWhat it lacks
Standard loggingDebugging and visibilityTamper evidence
AI observability platformsTraces, metrics, and evaluationOffline-verifiable evidence
Transparency logs and attestation toolsAppend-only integrity and provenanceAI-specific runtime semantics
CooL SDKCryptographic evidence for AI executionA broad dashboard experience

That positioning matters. If you need a dashboard, you buy a dashboard. If you need a receipt that can survive a regulator, an auditor, or a hostile future, you need something much closer to a proof system.