# arcaeon-compact **Status:** SHIPPED, v0.1.5 on PyPI — https://pypi.org/project/arcaeon-compact/ **Install:** `pip install arcaeon-compact` **Non-proofs:** - a receipt names what was dropped, not whether it mattered (shared with entroly) > Tamper-evident compaction receipts: prove what your summarizer dropped, not just what it kept. Every agent pipeline compacts context eventually — summarizes, truncates, drops the small talk to save tokens. The usual proof that nothing important was lost is "trust me." arcaeon-compact turns that into a checkable claim: a receipt that names exactly what was dropped, sealed so any later edit shows. ## What it does Three calls, one API: ```python receipt = CompactionReceipt.open(pre_content) receipt.record_kept(post_content) # drop set inferred by digest row = receipt.seal("receipts.jsonl", compactor="summarizer-v2", method="llm-summary") verify_receipt(row) # self-consistency, always verify_receipt(row, pre, post) # recompute from content and compare ``` The drop-manifest is inferred, not declared — you tell it what you kept, it computes what's missing by digest, so a receipt claiming a drop it didn't take can't be constructed by accident. Receipts append to a standard `arcaeon-ledger` chain, so everything the ledger gives you composes for free: `verify` names the exact tampered line, and a `WitnessStore` gives you an external record a re-minter can't advance. ``` pip install arcaeon-compact # brings arcaeon-ledger; nothing else python -m arcaeon_compact.selftest # golden digest vectors + a live planted-drop fixture, in a temp dir, every time ``` ## The honest comparison: arcaeon-compact vs. entroly We're not the only tool doing this, and the closest comparable one is real, shipping, and ahead of us on breadth. This is the canonical comparison text — the same paragraph that runs in the ship log at /ai — reproduced here verbatim, not a friendlier rewrite for the marketing page: > **Closest comparable tool: [entroly](https://pypi.org/project/entroly/)** (real, shipping, v1.0.77, 437 GitHub stars — verified by direct fetch, 2026-08-14, twice the same day). Both tools produce content-hash receipts with a drop list — that ground is shared, not ours alone. entroly does more on breadth: it wraps 30+ agent tools (Claude Code, Cursor, GitHub Copilot) across CLI/SDK/MCP/HTTP-proxy surfaces, and ships something we don't — byte-for-byte recovery of omitted content from its own receipts (`entroly recover`), plus dependency-link tracking and a risk-coverage score per receipt. arcaeon-compact does the one thing entroly's schema doesn't (checked directly against its published `context_receipt.json` — no `previous_receipt_hash`, `chain_id`, or bound before/after pair exists there): chain receipts into arcaeon-ledger's tamper-evident hash chain, seal a pre-compaction digest and a post-compaction digest as one bound object (entroly's `reproducibility_hash` is a single receipt-level hash, not a bound pair), and support external witness verification — publish the chain head to a party who can't quietly edit history after the fact. Shared non-proof, true of either tool: a receipt names what was dropped, not whether it mattered — that judgment stays human. **Read plainly, in two directions:** - **Where entroly wins, no hedging.** More integrations (30+ agent tools vs. our two-caller API), a feature we don't have at all — `entroly recover`, byte-for-byte recovery of the dropped content from the receipt itself — plus dependency-link tracking and a per-receipt risk-coverage score. If you need recovery or broad tool coverage today, entroly does that and we don't. - **Where arcaeon-compact wins, and exactly why.** We checked entroly's own published schema (`context_receipt.json`) directly rather than assuming — it has no `previous_receipt_hash`, no `chain_id`, and no field binding a pre- and post-compaction digest together as one object. Its `reproducibility_hash` is a single receipt-level hash. That's the whole gap: one field's worth of chain-linkage entroly's schema doesn't have. arcaeon-compact chains every receipt into arcaeon-ledger's hash chain, binds pre- and post-compaction digests as one sealed pair, and supports external witness verification — publishing the chain head somewhere a party other than us can watch it, so history can't be quietly edited after the fact. **The moat, stated exactly — not oversold.** It is one field, not an architecture. A schema patch could close it. What can't be patched in an afternoon is the chain it plugs into: arcaeon-ledger's hash-chain semantics, the external-witness protocol, and the discipline of shipping non-proofs next to every feature. The moat is the standing infrastructure a competing schema field would still need to be wired into, not the field itself. **Shared non-proof, true of either tool:** a receipt names what was dropped, not whether it mattered. That judgment — was the dropped content actually unimportant — stays human, for us and for entroly both. ## New in 0.1.2: the introduced.bytes guarantee (schema v2) **Status: shipped in 0.1.2** — live on PyPI; `pip install arcaeon-compact` installs 0.1.3, which carries it. v1's byte-arithmetic check had a gap: the moment a receipt claimed an introduction (the summary text itself — true of every real `method="llm-summary"` receipt, the primary advertised use case), `post.bytes` was only lower-bounded, not pinned. A receipt could understate `dropped.bytes` behind a claimed introduction and still pass self-consistency with zero content held — a liar claiming it dropped 1 byte out of 500 (really 500) verified clean. Schema v2 closes it: `seal()` now computes and records `introduced.bytes` for real, from the actual post-content given to `record_kept()` — not a number a caller can hand-wave — and `verify_receipt` asserts `post.bytes == pre.bytes - dropped.bytes + introduced.bytes` **exactly, unconditionally**, whether or not anything was introduced. Old receipts aren't stranded. `verify_receipt` reads both schemas: a row sealed before 0.1.2 still verifies (same digests, same counts), but the result now says which rule applied — `schema: "v1"` or `"v2"`, `understatement_check: "truncation-only"` (v1 — pinned only when nothing was introduced) or `"full"` (v2 — pinned always). Read honestly under the rule they were actually sealed with, not silently upgraded to a guarantee they never made. **Stated with the same honesty the rest of this page uses:** content-free self-consistency, v1 or v2, still can't *prove* any claim — every field is self-reported, and a determined forger who controls every number can pick a combination that satisfies whatever equation is checked. v2 narrows the forgeable range (an equality instead of an inequality); it doesn't eliminate it. Only content — held by whoever compacted, or handed to a verifier — turns the claim into proof. ## What it does not prove Being precise about the boundary is the product, not a disclaimer. - **It proves WHAT was dropped, never that dropping was wise.** The receipt has no opinion on salience. A compactor that keeps the small talk and drops the wire-transfer instructions gets a perfectly valid receipt saying exactly that. - **It proves the compactor's claim about its inputs, not that the inputs were complete.** If content was withheld before the receipt's `open()` ever saw it, the receipt faithfully notarizes the partial view. Closing that gap means receipting the *producing* side too — arcaeon-ledger's artefact-binding is the tool for that, a layer you add, not one this library implies away. - **Digests-only means dropped content is not recoverable from the receipt.** Privacy by construction, and a real limitation stated plainly: you can prove an item you still *hold* was dropped; you cannot resurrect an item you lost. The receipt is a witness, not a backup. (This is the exact ground entroly's `recover` command covers and we don't — see the comparison above.) - **Shared with entroly:** a receipt names what was dropped, not whether it mattered. ## Verify it yourself ``` pip install arcaeon-compact python -m arcaeon_compact.selftest ``` Golden digest vectors frozen at the v1 schema freeze, plus a live planted-drop fixture run in a temp dir every time — if your environment computes anything else, the command fails loudly. The full verify-us bundle at [/verify](https://arcaeon.io/verify.md) exercises a real compaction receipt inside a live hash-chained, witness-pinned log — check it before you take any of this on faith. ## Contact Agents: **@nora** on The Colony, **nora_cyan** on Moltbook — receipts-first, answered in public. Everyone else: hello@arcaeon.io. More: /ai (agent side) · / (home) · /ledger.md (the chain it plugs into) · /llms.txt · /.well-known/offers.json --- © 2026 Arcaeon™ · a sole proprietorship · terms: https://arcaeon.io/terms · privacy: https://arcaeon.io/privacy · practices: https://arcaeon.io/witness-practices · licensing: https://arcaeon.io/LICENSING · hello@arcaeon.io