Flagship

AT-1 Ledger

One file that is three things at once: an event log, an analytics table, and a tamper-evident ledger. AT-1 Ledger composes the AT-1 primitives — compression, in-place query, aggregate roll-ups, append-only frames, and a hash chain — into a single product. You append events without rewriting the file, query and aggregate them in place without decompressing, and verify that no record was inserted, deleted, reordered, or altered. It still reconstructs every original byte, and — where enabled — can erase a subject for GDPR.

Append events

Each batch is added as a new chained, byte-verbatim frame. The events are stored exactly (lossless) and never re-compressed; the frame is hashed and its hash chained into the previous link; every frame written before it is left byte-identical. The ledger only grows.

at1 ledger append ledger.at1 events.csv
# each batch becomes a new CHAINED, byte-verbatim frame:
#   the events are stored exactly (lossless), never re-compressed
#   the frame is hashed, and that hash is chained into the previous link
#   prior frames are left byte-identical — the ledger only grows

at1 ledger append ledger.at1 day2.csv     # CSV or NDJSON
at1 ledger append ledger.at1 day3.ndjson  # the chain extends, link by link

Verify — prove it wasn't tampered with

verify re-derives every frame hash and re-chains every link. If the whole chain checks out, the ledger is append-only intact. If any past event was changed, inserted, deleted, or reordered, the chain breaks at exactly that point and verify pinpoints the broken frame.

at1 ledger verify ledger.at1
# -> APPEND-ONLY INTACT: every frame hash re-derived, every link re-chained
#    nothing inserted, deleted, reordered, or altered

# tamper with ANY past event and the chain breaks at exactly that point:
at1 ledger verify ledger.at1
# -> BROKEN at frame 7: link mismatch (this frame or an earlier one changed)

Query & aggregate in place

The ledger is also an analytical store. A query uses the per-block zone maps to skip row-groups it can rule out, then decodes only the projected columns of the survivors — across all appends. An aggregate reads a compact roll-up from the footer, so a SUM / COUNT / MIN / MAX spans every frame without rehydrating the data.

# search across EVERY append, in place — no decompress step
at1 ledger query ledger.at1 --where ts:1704067200000:1704067210000 --select id,actor,action

# totals across all appends, read from the footer roll-up
at1 ledger agg ledger.at1 amount --op sum
at1 ledger agg ledger.at1 id     --op count
at1 ledger agg ledger.at1 ts     --op min
at1 ledger agg ledger.at1 ts     --op max

The hash chain, precisely

Every append's frame is hashed, and each hash is chained into the previous one:

link_0 = sha256(sha256(frame_0))
link_1 = sha256(link_0 + sha256(frame_1))
link_2 = sha256(link_1 + sha256(frame_2))
...
link_i = sha256(link_{i-1} + sha256(frame_i))

Because each link depends on the link before it, changing, inserting, deleting, or reordering anypast event changes that frame's hash, which breaks every link from that point forward — and verify reports exactly where. This is the same family of guarantee as Certificate Transparency, Amazon QLDB, or a blockchainledger — but inside one portable, compressed, queryable file you own. AT-1's contribution is putting a hash chain inside a compressed, queryable, byte-exact, erasable archive; the hash-chaining itself is standard and well-known.

What it's for

Anywhere you must keep an event history, proveit wasn't tampered with, still query it cheaply, and (for PII) still erase a subject:

  • Audit logs — a tamper-evident record of who did what, when.
  • Compliance & regulatory event trails — retained, queryable, and provably un-edited.
  • Financial / transaction ledgers — an append-only book of record with exact aggregates.
  • IoT / device event histories — keep a long device timeline small and still searchable.
  • Security / access logs— point lookups and ranges over events that can't be quietly rewritten.

Tamper-evident, honestly framed

AT-1 Ledger is tamper-evident: it detects tampering rather than preventing it. It is built on standard hash-chaining — the same well-known family as Certificate Transparency, QLDB, and blockchain ledgers. We did not invent hash chains; what AT-1 adds is putting one inside a single compressed, queryable, byte-exact, erasable file. Verification compares hashes, so a broken chain is proof a frame changed; an intact chain is evidence the history is append-only.

Decoding and verifying are always free and never need an account; the append and query paths are metered against the account whose API key the host process supplies — same as the rest of AT-1.