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.
- CooL reframes logging as evidence, packaging runtime events into receipts that are meant to survive audits, disputes, and long-retention verification.
- Its core trick is layered trust: salted commitments, canonical CBOR, Merkle transparency, hybrid signatures, and attestation each add a different guarantee.
- The verifier is intentionally honest about simulation versus hardware, which prevents soft proof from being mistaken for a strong one.
- The project fits between observability and attestation, serving teams that need AI change history to be defensible instead of merely visible.
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 log | CooL receipt |
|---|---|
| Records an event | Commits to an event |
| Readable, but easy to mutate | Deterministic and tamper-evident |
| Usually tied to a service database | Verifiable offline from the receipt itself |
| Good for debugging | Good for audits and disputes |
| Trust comes from infrastructure | Trust comes from cryptographic structure |
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.
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.
| Layer | What it buys | Why it exists |
|---|---|---|
| Ed25519 | Fast, widely understood authentication | Protects today’s deployments |
| ML-DSA-65 | Post-quantum resilience | Protects long-retention evidence |
| Hybrid verification | Both signatures must pass | Reduces single-algorithm dependence |
| Canonical CBOR | Stable bytes before signing | Prevents 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.
| Path | What it means | Risk |
|---|---|---|
| Simulated | The flow was exercised without a real TEE | Good for development, weak for proof |
| Hardware-attested | The record is tied to a trusted execution environment | Stronger evidence, stronger operational requirements |
| Invalid | The receipt fails cryptographic or attestation checks | Should 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.
| Category | What it optimizes for | What it lacks |
|---|---|---|
| Standard logging | Debugging and visibility | Tamper evidence |
| AI observability platforms | Traces, metrics, and evaluation | Offline-verifiable evidence |
| Transparency logs and attestation tools | Append-only integrity and provenance | AI-specific runtime semantics |
| CooL SDK | Cryptographic evidence for AI execution | A 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.





