ATTESTABLE COMPRESSION · PATENT PENDING

The AI saw
everything. Prove it.

Most context compression is a black box. Facts disappear. You can't see what was cut, prove what survived, or verify what the model received.

Purgr compresses deterministically and emits a cryptographically signed receipt — same input, same output, every time — proving exactly what the model saw, and why.

Start free GitHub

100% NIAH @ 1M tokens 491 tests passing Zero runtime deps Nothing leaves your env

context · 242,304 tokens

tokens in242,304

tokens out114,802

facts preserved143 / 143

✓ SIGNED · MERKLE-ROOTEDEd25519

01What Purgr Does

Three operations. One chain of custody.

Compression without proof is truncation with extra steps. Each operation hands the next a verifiable artifact — compress, attest, carry.

Compress

Cut without guessing.

A phase-progressive scorer identifies what the model actually needs — not what it saw most recently. Amounts, dates, identifiers, and constraints are protected unconditionally. Everything else compresses deterministically.

Read the docs →

┌─ purgr compress ───────────────┐

│ tokens in 242,304 │

│ tokens out 114,802 (53% cut) │

│ anchors 3 │

│ msgs 368 compressed │

│ facts 143/143 preserved │

└────────────────────────────────┘

Attest

Prove what survived.

Every compression emits an Ed25519-signed receipt binding the input hash, the compression decisions, and a Merkle root over every individual choice. Any third party can verify it. No server required.

Verify a receipt →

$ purgr receipts --verify

inputHash a3f7b2c1d9e4…

merkleRoot 9b2e1f4a7c8d…

algorithm Ed25519

✓ SIGNATURE VALID

✓ MERKLE ROOT VERIFIED

✓ INPUT HASH MATCHED

Carry

Take your context anywhere.

Export the session as a signed, portable .purgr file. Import it in a new session, a different tool, or hand it to your team. The compressed context and the learned memory of the conversation travel together.

Learn about Passport →

format purgr-passport-v1

messages 252 compressed

purgr_state ✓ included

encrypted ✓ AES-256

signature ✓ Ed25519

— Signed. Verified. Yours.

PURGR RECEIPT

Compression Attestation · v1.0

NO. 0x9B2E1F
2026-04-26 03:41Z

tokens in242,304

tokens out114,802 · 53% cut

facts preserved143 / 143

input hash················

merkle root················

algorithmEd25519

VERIFIEDSignature · Merkle · Input hash

P<PURGR<A3F7B2C1D9E4F80B<<9B2E1F4A7C8D3E21<<<
ED25519<<242304<114802<143143<<VERIFIED<<<01

02The Receipt

Not a log. A signature.

Every decision Purgr makes is committed to a Merkle tree. The root is signed with Ed25519 and bound to the hash of your original input. Tamper with one token and the root changes — the signature breaks. Verification runs anywhere, against nothing but math.

Verify a live receipt →

03Why It Matters

Determinism, demonstrated.

ML compressors give a different answer every run. Purgr is a pure function: the same input produces a byte-identical output — and an identical hash. Run it a thousand times. The receipt never moves.

RUN 0103:41:22Z

$ purgr compress session.json

→ 242,304 → 114,802 tokens

outputHash

····················

RUN 0209:17:55Z

$ purgr compress session.json

→ 242,304 → 114,802 tokens

outputHash

····················

awaiting second run…

ML-based compression

Purgr

Probabilistic — same input, different output each run

Deterministic — identical output, every time

No audit trail — impossible to know what was cut

Every decision committed to a Merkle tree

Black box — can't verify what the model received

Input hash bound to receipt — third-party verifiable

Requires 2GB+ models, GPU, Python runtime

Zero runtime dependencies — runs anywhere Node runs

No fact protection — details silently disappear

143/143 critical facts preserved on a real 242k session

100% needle survival: 75% (LLMLingua, adversarial suite)

100% needle survival @ 1,000,000 tokens, 8 fixture types

View the full benchmark registry →

04Purgr Passport

Context that travels
with its papers.

A Passport is your whole session as a signed, encrypted, portable file — compressed context plus the learned Koopman state of the conversation. Import it elsewhere and the scorer picks up exactly where it left off. The receipt chain stays intact across the border.

Encrypted

AES-256

Signed

Ed25519

Portable

.purgr

VERIFIEDED25519

PURGR PASSPORT

Portable Session · v1

holderQ2 Audit Session

exported2026-04-26T03:41Z

messages252 compressed

purgr state✓ included

encryption✓ AES-256

signature✓ Ed25519

P<PURGR<Q2AUDIT<<SESSION<<<<<<<<<<<
252<<AES256<ED25519<<0426<<SIGNED<VERIFIED<01

05Instrument Readout

Measured, not asserted.

Needle Survival

@ 1,000,000 tokens · 8 fixtures

Token Reduction

avg on real content

Fact Fidelity

0/143

real 242k-token session

Tests Passing

across the suite · zero deps

06Implementation

Three lines to compress.
One line to verify.

No configuration. No server, no cloud, no data leaving your environment. The receipt is yours.

// Install: npm install purgr
import { Purgr } from 'purgr'

// Initialize — zero configuration required
const purgr = new Purgr({ scorerMode: 'auto' })

// Compress before your LLM call
const { messages, stats } = purgr.compress(conversationHistory)

// Every compression produces a signed receipt
console.log(purgr.receipt(stats))
// ┌─ Purgr ──────────────────────────────────────────┐
// │ Tokens in     242,304                             │
// │ Tokens out    114,802 (53% saved)                 │
// │ Fact fidelity 143/143 critical facts preserved    │
// │ Receipt v1.0  – verify at purgr.dev/verify        │
// └───────────────────────────────────────────────────┘

// Use compressed messages in your LLM call
const response = await openai.chat.completions.create({ messages })

import { verifyDocument } from 'purgr'

// Standalone — no Purgr instance needed
// Proves which facts in the AI response exist in your source document
const result = verifyDocument(contractText, llmResponse)

console.log(result.groundingScore)   // 0.94 — 94% of facts grounded
console.log(result.groundedFacts)    // ['$4,738,291', 'March 14, 2026', …]
console.log(result.ungroundedFacts)  // ⚠ facts not found in document

// Hard-Fact Traceability Receipt
// Proves token presence — not relational accuracy
// See docs for honest scope and limitations

import { Purgr } from 'purgr'

const purgr = new Purgr({ scorerMode: 'auto' })
const { messages } = purgr.compress(history)

// Export your session — signed, encrypted, portable
const passport = await purgr.exportPassport(messages, {
  description: 'Q2 audit session',
  encrypt: true,        // AES-256 — CLI/Node only
  passphrase: '…',
})

// Import in a new session — picks up exactly where you left off
const { messages, receipt, koopmanState } = await purgr.importPassport(passport)

// Koopman state restored — scorer continues learning
// Receipt verified — chain intact. Yours.

07Who Uses Purgr

For anyone who has to prove
what their AI saw.

01 / DEVELOPERS

Cut token cost, keep context.

Drop Purgr into any LLM pipeline in minutes. The proxy compresses automatically — your code doesn't change. Receipts come free with every call.

Proxy · MCP Server · CLI · SDK

02 / RESEARCHERS

A citable methodology artifact.

Compress literature corpora and prove your AI engaged with the source. Stateless architecture — your data never leaves your environment.

Corpus · verifyDocument() · Passport

03 / COMPLIANCE & LEGAL

A tamper-evident audit trail.

AML files, contracts, regulatory filings — exactly the facts Purgr protects: amounts, dates, identifiers, citations. The receipt records what the AI processed.

Receipt chain · Section protection · Fidelity

08Pricing

Start free. Scale when ready.

All tiers include cryptographic receipts. No credit card for the free tier.

Free

Forever · No credit card

✓Phase 1 Momentum compression

✓Basic cryptographic receipt

✓Web sandbox & tools

✓verifyDocument() — hard-fact traceability

–50k token limit per call

–No Purgr State in Passport

–No encryption

–No CLA liveness scoring

Download Free

The AI saw
everything. Prove it.

You compressed the context. Now prove what the model actually saw.

Three operations. One chain of custody.

Not a log. A signature.

Determinism, demonstrated.

Context that travels
with its papers.

Measured, not asserted.

Three lines to compress.
One line to verify.

For anyone who has to prove
what their AI saw.

Cut token cost, keep context.

A citable methodology artifact.

A tamper-evident audit trail.

Start free. Scale when ready.

Start compressing with proof.

The AI saweverything. Prove it.

You compressed the context. Now prove what the model actually saw.

Three operations. One chain of custody.

Not a log. A signature.

Determinism, demonstrated.

Context that travelswith its papers.

Measured, not asserted.

Three lines to compress.One line to verify.

For anyone who has to provewhat their AI saw.

Cut token cost, keep context.

A citable methodology artifact.

A tamper-evident audit trail.

Start free. Scale when ready.

Start compressing with proof.

The AI saw
everything. Prove it.

Context that travels
with its papers.

Three lines to compress.
One line to verify.

For anyone who has to prove
what their AI saw.