# AT-1 / tinyfiles.io

> AT-1 is a structure-aware **lossless** compression engine and platform. It stores structured data smaller than general-purpose compressors, keeps it **queryable in place** (predicate/projection pushdown, range-GET, Apache Arrow into DuckDB/SQLite/Postgres), and **integrity-seals** every archive with an embedded SHA-256 trailer that detects a single tampered byte (whole-file detection; the trailer does not report WHERE — the hash-chained `at1 ledger` is the surface that names the broken frame). On top of storage, the *same* compression pass yields free signals (a label-free diagnostic/health residual) and verifiable AI artifacts. Business model: value-based ~$42 per TB-compressed per year, plus verticals. Honesty is a core principle — we publish where AT-1 ties or loses (e.g. natural images/video, raw market price prediction), not just where it wins.

## What AT-1 does
- **Structure-aware lossless codecs** that beat general compressors on logs, columnar/tabular, JSON/NDJSON, genomic VCF, DICOM, geo/OSM, time-series, EEG.
- **Queryable codecs** (qcolumnar/qjson): query a compressed `.at1` without decompressing — pushdown, zone-maps, bloom filters, range-GET; engine-agnostic C core into Apache Arrow.
- **Verified integrity**: SHA-256 trailer; tamper detected whole-file (not located — `at1 integrity` reports FAIL, not an offset). Localisation is a property of the hash-chained ledger and the `.lens` container, not of the plain archive trailer. Every query result is itself a new verified, re-queryable artifact.
- **Generative "store the rule"**: for rule-governed data, store the generating program (chess rules ~2× best general compressor; procedural video up to 10^6×) via an MDL law-search engine.
- **Diagnostic residual** (patent filed): the compression residual is a free, label-free anomaly/health signal.
- **Addressable + streaming + verified model weights** (patent filed): byte-identical inference from a compressed, verified weight store.
- **Training-data attestation (EU AI Act Art. 10)**: seal a training corpus into a 32-byte Merkle root plus a declared composition manifest, then prove a given record **was** in it — or, the question data subjects actually ask, prove it **was NOT**. Absence proofs require a complete sealed enumeration, which a signed PDF inventory can never provide. Measured: 1,000,000 records seal in 3.4s; an absence proof is ~3.3 KB and verifies in 0.27 ms. Verification is plain SHA-256 and **free forever** — `at1 trainset verifier` emits a dependency-free script an auditor runs with no AT-1 software. Honest scope: it proves the corpus you DECLARED, not what a model ingested. `at1 trainset seal|prove|verify|inspect|verifier` · https://tinyfiles.io/trainset
- **Conditional coding + reference negotiation**: code a stream relative to a shared reference (numeric delta / shared dictionary), and *discover which reference the receiver already holds* from 1 KB sketches per candidate — no reference body is read. Measured on a real model zoo, byte-exact: the same weights in a different container **1,266× smaller**, an identical tokenizer **3,337×**. Honest boundary — it exploits **duplication, not similarity**: two different models of the same architecture family share nothing and are correctly declined, and conditioning is only kept when it strictly beats compressing the stream alone (never-worse).

## Integrate it (copy-paste — this is where teams actually spend their time)
Install the CLI (native prebuilt binary, no Python required; works with npm/pnpm/yarn/bun — per-platform binary via optionalDependencies, no install script): `npm install -g @tinyfiles/cli` — or run it without installing via `npx @tinyfiles/cli …`. Decoding never needs an account; compressing past the one-time 100 GB-compressed free trial is metered (the trial is a lifetime credit, not a hard cap — add a card and metered usage continues). Install guide: https://tinyfiles.io/docs/npm

Core: `at1 compress qcolumnar data.csv data.at1` (lossless, verified) · `at1 decompress data.at1 out.csv` (byte-identical) · `at1 query data.at1 --where price:100:200 --select id,price` · `at1 sql data.at1 "SELECT id WHERE ts BETWEEN a AND b"`. Only the `qcolumnar` (tables/CSV) and `qjson` (NDJSON) codecs are queryable in place; other data is stored byte-exact and verified but not query-searchable (images/JPEG included — query works on rows/columns, not pixels).

- **DuckDB**: `LOAD 'at1'; SELECT * FROM read_at1('data.at1') WHERE ts BETWEEN a AND b;` — selective queries read only the touched row-groups.
- **pandas / Polars (Arrow)**: `import at1_arrow; df = at1_arrow.to_pandas('data.at1')` or `at1_arrow.to_polars('data.at1', columns=[...], where={'k':(lo,hi)})`.
- **Postgres (FDW)**: `CREATE EXTENSION at1_fdw; CREATE FOREIGN TABLE t (...) SERVER at1 OPTIONS (filename '/data/x.at1');` then ordinary SQL. Same core bridges Trino/Presto/Spark/Flink via JDBC/Postgres.
- **S3-compatible storage**: run `python at1_cloud.py serve ./store --bucket at1 --port 9100`; point any S3 SDK (boto3, aws cli, Spark) at the endpoint — objects compress on PUT, decompress on GET, plaintext is never stored (failed round-trip → HTTP 422), plus a `/sql` REST endpoint.
- **Auto-tier a folder**: `at1-watch /data --older-than 7d --include "*.csv,*.log,*.ndjson" --verify-ledger`; preview savings first with `at1-doctor scan /data --report savings.html`.
- **Ingest from a URL**: `at1 fetch https://host/events.csv events.at1 columnar` (plaintext never lands on disk).
- **AI agents (MCP)**: an MCP server lets Claude/Cursor/VS Code compress & query `.at1` directly — setup & editor configs at https://tinyfiles.io/docs/mcp.
- **Front-end (React / TanStack Virtual)**: the in-browser query WASM decodes one row-group at a time, so a virtualizer renders millions of rows from one static `.at1` with no backend and <1% of the file read. Guide: https://tinyfiles.io/docs/tanstack-virtual
- **Front-end (React / TanStack DB & Query)**: hydrate a reactive TanStack DB collection (or a TanStack Query queryFn) straight from a compressed `.at1` — full rows via the /sql endpoint, or numeric columns client-side via WASM — then useLiveQuery reactively (read/query collections; not a write-sync backend). Guide: https://tinyfiles.io/docs/tanstack-db
- **Images**: lossless. Raw/scientific/DICOM win; already-compressed JPEG/PNG/WebP tie (verified container, no ratio). Not pixel-searchable — keep a `qcolumnar` metadata sidecar if you need search.

Full single-file integration guide for AI assistants (copy-paste recipes inline): https://tinyfiles.io/llms-full.txt
Docs: [Start here (plain English)](https://tinyfiles.io/docs/start-here) · [Examples & integrations](https://tinyfiles.io/docs/examples) · [Query from your engine](https://tinyfiles.io/docs/engines) · [Managed cloud / S3](https://tinyfiles.io/docs/cloud) · [Images](https://tinyfiles.io/docs/images) · [SDK & bindings](https://tinyfiles.io/docs/sdk) · [CLI](https://tinyfiles.io/docs/cli)

## Products and verticals
- [AT-1 lakehouse cold tier](https://tinyfiles.io/lakehouse): Store Delta/Iceberg/Parquet ~27% smaller than Parquet+zstd, byte-for-byte lossless, and query it in place. Verified byte-identical on Snowflake and Databricks against real NYC-TLC; read directly by Spark, Trino and DuckDB through the gateway. Saves storage not compute; reading is free, only tiering (writing) is metered. Does NOT work against Cloudflare R2 (Snowflake region defect).
- [AT-1 Reveal](https://tinyfiles.io/reveal): Selective disclosure over video and documents. Withhold frames, blur a region, or hide rows, and the recipient can still prove every part they can see is byte-identical to the sealed original and that nothing was added or removed. Merkle root over parts; withheld parts leave their commitments behind. Verified client-side with no install or account. Does NOT judge whether the right things were redacted.
- [Condition Monitoring](https://tinyfiles.io/diagnostic): label-free predictive-maintenance health index from the compression residual. Validated on real CWRU bearings (78% fault detection, 0% false alarm) and NASA C-MAPSS engines (median rank-correlation 0.88 vs remaining-life across 709 run-to-failure engines, condition-agnostic). Licensed engine — enable in your dashboard at https://tinyfiles.io/engines.
- [Compliance](https://tinyfiles.io/compliance): verified, tamper-evident, queryable archive for regulated/evidentiary records (SEC 17a-4 WORM, ESG, audit) + a verified avoided-emissions certificate (a transparency metric, not carbon credits).
- [Regulated Archive](https://tinyfiles.io/regulated) (`at1 regulated`): compressed + queryable + tamper-evident + per-subject-erasable in one archive. Identifying columns are encrypted per data subject (AES-256-GCM, subject id as AAD); erasure destroys that subject's key, leaves every other row byte-exact, does not rewrite the archive, and emits an Ed25519 certificate whose `archive_hash_before` == `archive_hash_after`. **Build with `--signing-key` to sign the integrity manifest** — without it, `at1 regulated verify` proves the data matches the manifest but NOT that the manifest is the original, so an attacker who edits the data can rewrite the hashes to match; signing binds them to a key the customer holds. `verify` names which part changed and states whether the manifest was signed, unsigned, or carries an invalid signature. **Honest layout note**: put identifying fields in a small subject table and measurements in a large readings table. Identity repeated on every row makes the encrypted-PII envelope dominate — on real-shaped telemetry the flat layout measured 0.67x vs `xz -9e` while the normalised one measured 1.52x (readings alone 2.99x), same data and same guarantees.
- **AI Evidence Capsule**: a notarized, reproducible receipt for a single AI inference — a tiny per-inference capsule plus a shared verified weight store lets an auditor re-run the exact inference offline and get byte-identical output, with tamper detection. Built for EU AI Act record-keeping. Licensed engine — enable in your dashboard at https://tinyfiles.io/engines.
- **Risk-Tape**: a model-free market-stress index (Compression-VIX, ~0.886 correlation with realized volatility) + order-flow structure score from the compressed market-data tape — a risk/correlation gauge, explicitly not a trading-alpha signal. Licensed engine — enable in your dashboard at https://tinyfiles.io/engines.
- [Verify any document](https://tinyfiles.io/prove-income) (verify at https://tinyfiles.io/verify): Prove an institutional document (bank statement, invoice, levy statement, municipal bill, payslip) is genuine and reveal **only the fields you choose** — the recipient verifies it in their browser, nothing uploaded, no account. Sender-, document- and country-agnostic **by construction**: it verifies the sender's own **DKIM email signature** (validated on real FNB and Xero mail) — any institution, anywhere, no integration and no aggregator KYC. Runs entirely on the applicant's device; only a serverless share link (the redacted proof in the URL fragment) leaves it — no storage, no honeypot. **Honest trust tiers**: SOURCE-VERIFIED (a DMARC-aligned DKIM signature, a signed PDF/PAdES, or a zkTLS session) vs SELF-ATTESTED (uploads, WhatsApp/Telegram forwards, downloads, screenshots — sealed and tamper-evident, but source not cryptographically verified), rendered as unmistakably different certificates so a self-attested proof can never be mistaken for a verified one. Selective disclosure = SHA-256 Merkle inclusion proofs. **Trustless zk-email tier is shipped**: the recipient verifies a zero-knowledge proof in their browser that a chosen figure genuinely appears in a DKIM-signed email, and the sender is **named** by matching the proof to that domain's live DKIM key — zero trust in the applicant, whole document never travels. Heavy proving runs on a prove-and-discard service; verification is a few KB, on-device. Structured bank-app data via zkTLS is on the roadmap. Honest scope: fully-trustless redaction of a field buried inside a PDF **attachment** is still an open problem (would need PDF-parsing in ZK) — whole-document authenticity is trustless and universal today.
- [AT-1 Serve-DB](https://tinyfiles.io/serve-db) (`at1 serve-db`): a verified single-binary backend (PocketBase-shaped) where every REST answer is proof-carrying and every change is a tamper-evident audit event — proof-carrying `/query` + byte-exact time-travel (`?asof`) + a live SSE audit stream, compute-on-compressed (scan-free derived columns/features/anomaly), an offline self-verifying HTML export (a query becomes an ~11 KB file that re-verifies itself; tamper → red), delete-a-subject-with-a-certificate (GDPR crypto-erasure + Ed25519 cert; survivors byte-exact), sealed-model co-serving (data + a non-extractable model in one process, license fail-closed), OEM/white-label embed (partner overlay + per-tenant verified rollup), verified read-replication (a follower proves byte-exact faithfulness from a 32-byte root), a signed RFC-6962 transparency log for the change log (inclusion/consistency proofs), and cross-org PSI federation (two orgs compute a joint sum/intersection without exposing either dataset) — nine capabilities behind one fail-closed auth gate (bearer or HS256-JWT) you self-host as one binary.
- [Generative compression](https://tinyfiles.io/generative) · [Queryable video/media](https://tinyfiles.io/video) · [Free compressibility audit](https://tinyfiles.io/compressibility) · [Living AI](https://tinyfiles.io/living-ai).

## Compressed-intelligence products (each is one `at1 <verb>`, verified-lossless, pay-as-you-go with a monthly free tier)
- [AI Memory](https://tinyfiles.io/memory) (`at1 ctx`): output-lossless compression of LLM context + KV-cache — same answers, fewer tokens. Billed on tokens saved. For teams building on LLMs. `ctx proxy` runs it as a drop-in Analyst/LLM proxy that compresses context transparently.
- [Features](https://tinyfiles.io/compute-on-compressed) (`at1 features`): extract ML features straight from the compressed columns — skip the decompression tax. For ML/analytics pipelines.
- [Model-coupled Links](https://tinyfiles.io/model-coupled-links) (`at1 link`): when sender + receiver share a model, transmit only the residual "surprise". For bandwidth-constrained telemetry/video/IoT.
- [Observability](https://tinyfiles.io/observability) (`at1 observe`): anomaly detection by bits-per-event — a spike in incompressibility is the incident, no rules to write. For SRE/security.
- [Data Appraisal](https://tinyfiles.io/data-appraisal) (`at1 appraise`): an MDL (information-theoretic) valuation of a dataset — how much real information it holds. For data marketplaces / data-asset pricing.
- [Explain](https://tinyfiles.io/explain) (`at1 explain`): the Kolmogorov machine — returns the shortest human-readable program that reproduces the data, or honestly reports there isn't one. For research/discovery.
- [Century Archive](https://tinyfiles.io/century-archive) (`at1 century`): a self-decoding container that carries its own decoder — format-rot insurance for decades-long retention.
- [Model Artifact](https://tinyfiles.io/model-artifact) (`at1 artifact`): turns private data into a model + a certified synthetic twin that behaves like the original, so it can be shared/tested (`artifact twin` emits the twin CSV; `certify` proves its fidelity). For privacy-constrained (POPIA/GDPR) teams.
- [Rule-Tier](https://tinyfiles.io/rule-tier) (`at1 ruletier`): store the generating rule, discard the rows, regenerate exactly on demand with a certificate. For law-governed / simulation data.
- [Codec Compiler](https://tinyfiles.io/codec-compiler) (`at1 codec`): synthesize a byte-exact compressor for an unseen proprietary format from a few samples. For legacy/odd binary formats.
- [LENS](https://tinyfiles.io/lens) (`at1 lens`) + [App Store](https://tinyfiles.io/store): apps that are a single verifiable file — data + interface + proofs in one, runs offline, every number certified. Flagship: **AT-1 Sheets** (a spreadsheet in one file). Open apps in-browser at /store; creators keep 85% on paid sales. `lens daily-pack` renders a certified daily summary sized for WhatsApp/mobile delivery.
- [GenDerive](https://tinyfiles.io/genderive) (`at1 genderive`): discover columns that are exact functions of other columns (total=qty×price, tax, buckets, keys, indexes, composed FDs), store them as a ~20-byte formula instead of data, and answer predicates on them scan-free — index/aggregate queries read zero bytes; reconstructs byte-exact. The general form of GenQuery. For analytics/warehouse tables.
- [Compression Intelligence API](https://tinyfiles.io/intel) (`at1 intel`): tell_me_about(file) — entropy, estimated compressibility + storage cost, kind, duplicate-block ratio, and for tables a schema + discovered derived columns. Read-only, no lock-in. Information theory as an API.
- [Dataset Registry](https://tinyfiles.io/dataset-registry) (`at1 dataset`): publish a dataset → a content-addressed, tamper-evident, versioned, citeable artifact; the citation IS the SHA-256, so cite `at1://<hash>` instead of a URL, and resolve byte-identical or the resolve refuses. Reproducible data distribution.

## Verifiable-data suite additions + AI-infrastructure (2026-07 release; each pay-as-you-go with a monthly free tier)
- [Agent State Sync](https://tinyfiles.io/agent-sync) (`at1 statesync`): byte-exact delta-from-prior sync of evolving agent/LLM state — KV-cache, long-term memory, context — across a fleet; ships ~9–37× fewer bytes than re-sending full state each step, because agent state is dominated by frozen/appended history. `diff`/`apply`, SHA-verified reconstruction. For multi-agent / LLM infrastructure.
- Verifiable analytics — `at1 prove range`: an O(log N) authenticated SUM/COUNT/AVG proof over a sealed column — a third party verifies the answer WITHOUT re-scanning the data; 100% tamper-detection (answer-inflation, leaf-tamper, forged-path all rejected). Joins the existing Verifiable Data suite (`at1 prove`). Grouped queries: `at1 prove seal-sorted`/`group`/`verify-group` add a verifiable SQL GROUP BY tier — an O(log n) per-group SUM/COUNT/AVG proof over a SORTED commitment, verified root-only; a load-bearing sortedness certificate makes it sound even against a malicious sealer who commits an unsorted column to forge group boundaries.
- Proof-of-inference — `at1 prove infer`: verify a committed model produced a claimed output at 5–31× fewer FLOPs than re-running it (Freivalds matmul check + Merkle weight commitment; a forged output is caught with overwhelming probability). HONEST SCOPE: lightweight probabilistic verification — it saves verifier compute, it is NOT zero-knowledge and NOT succinct (not zkML).
- Portfolio Codec (`at1_portfolio`, columnar path): decimal-aware per-column codec — never-worse structural transforms + a cheap coder, byte-exact, per-column random access; ratio ≥ zstd-19 on numeric/financial columnar data. Ships in the licensed wheel.

## Regulated-archive & reconciliation products (each is one `at1 <verb>`, verified, pay-as-you-go with a monthly free tier)
- [Snapshot Archive](https://tinyfiles.io/snapshot-archive) (`at1 snapshot`): delta-chain near-identical nightly CSV snapshots into one archive; `SELECT … AS OF '2026-05-14'` materializes any night with NO restore — row-exact for querying, or byte-identical to the original file with `--exact` — plus per-night hash-chain tamper-evidence. ~2–12× smaller than gzipping each night (grows with overlap). `snapshot build-raw` delta-chains binary (non-CSV) nightly dumps as a byte-exact CDC chain. Every business with a nightly-backup folder.
- [Reconciliation Certificates](https://tinyfiles.io/reconciliation) (`at1 reconcile`): a signed verdict that archive A ⋈ B under rule-set R yields matches M + residuals X, auditor-verifiable WITHOUT raw rows; a silently-dropped unmatched row is cryptographically detectable. Matches on amount+date by default (bank & POS tapes share no reference strings) with shared tokens as an optional booster; inputs are CSVs with date/amount columns. `reconcile --fees` is fee-aware and composition-tolerant (settles net-of-fee tapes where the gross/fee split differs). `reconcile grossnet` is the deterministic gross==net batch reconciler: dedup by a configurable key tuple, group by batch, optional adjacency merge, then match each batch's gross sum to its bank credit EXACTLY to the cent (real books settle net==gross), with an honest per-row-observable vs counting-evidence vs on-account split that is never conflated. Bank/POS settlement forensics.
- [Derivation Certificates / DATABOM](https://tinyfiles.io/databom) (`at1 databom`): signed, RE-EXECUTABLE certificates that prove HOW an output was derived — seal {input hashes, program hash, output hash, environment fingerprint}, and an independent party re-runs the sealed program on the sealed inputs to confirm the output reproduces byte-exact. Certs compose transitively into a hash-continuous pipeline DAG (one stage's output hash == the next stage's input hash), so a whole lineage — raw inputs → intermediate artifacts → final figure — is re-derivable and tamper-evident. Non-deterministic steps are REFUSED (fail-closed, never a silent pass). Where custody proves what arrived and reconciliation proves a join verdict, DATABOM proves derivation. The AI-Act / regulated data-lineage wedge: "show me how this figure was produced, and prove it." Seal is metered; verify/graph/refuse-check are free.
- [GenQuery / Zero-Scan](https://tinyfiles.io/zero-scan) (query-on-generator): answer range predicates and exact selectivity on generated/derived columns by algebraically inverting the recovered closed-form generator — reads ZERO stored bytes, byte-identical to a full scan, ~30,000× faster. The engine behind GenDerive's scan-free queries; ships in the licensed AT-1DB wheel. Patent-pending (prov. 64/106,606).
- [Signed Query Receipts](https://tinyfiles.io/qsign) (`at1 qsign`): sign a query result so anyone can verify the reported number is real WITHOUT access to the underlying data — a portable receipt a third party re-derives from the receipt alone. Signing is metered; verifying is free. For "prove this figure" reporting.
- [FP-CODEC](https://tinyfiles.io/fpcodec) (`at1 fpcodec`): a verified deterministic context-mixing codec for cold text & logs — maximum shrink (below zstd and xz), bit-identical across architectures, byte-for-byte reconstruction anywhere. Verified round-trip on every encode.
- [Selective Disclosure](https://tinyfiles.io/selective-disclosure) (`at1 disclose`): a redacted export (e.g. PAN masked) that still verifies against the ORIGINAL seal — prove present-but-masked, not fabricated. `disclose profile` applies cross-file consistent tokenization (the same real value maps to the same token across exports). The mirror of erasure; PCI/POPIA exports.
- [WORM Journal](https://tinyfiles.io/worm-journal) (`at1 worm`): the archive as the live write path — per-record hash-chained streaming append + periodic sealing + torn-tail recovery + an external anchor against re-forge. POS/pharma/gaming compliance.
- [Completeness / Absence Proofs](https://tinyfiles.io/completeness) (`at1 complete`): prove receipts 1..N are all present (or list the exact gaps), or that a record is absent — a sorted-Merkle proof over a keyed sequence. Deleted-transaction fraud.
- [Postgres CDC Sink](https://tinyfiles.io/postgres-cdc) (`at1 cdcsink`): continuously seal a live Postgres into queryable `.at1` cold segments (hot in PG, cold in .at1, one SQL surface, exactly-once across a crash); a Supabase mode seals a hosted Supabase Postgres the same way.
- [Codec Registry](https://tinyfiles.io/codec-registry) (`at1 codereg`): a versioned catalog of byte-exact codecs for proprietary formats (MT940/DBF/EBCDIC, plus a FoxPro/dBase .dbf codec), each certified by byte-exact round-trip on a held-out corpus — makes Century Archive's format-rot insurance credible.
- [Fraud Fingerprints](https://tinyfiles.io/fraud-fingerprints) (`at1 fingerprint`): per-entity compression baselines (per-cashier/per-pump) → a CALIBRATED anomaly review queue (two nulls + a controlled false-alarm rate), never a fraud verdict. `fingerprint pilot` runs a scoped, time-boxed pilot to calibrate the queue on a site's own history before go-live.

## Back-office capture, custody & extraction products (2026-07 release; each is one `at1 <verb>`, verified, pay-as-you-go with a monthly free tier)
- **Seal-at-Source Agent** (`at1 sealagent`): a capture agent that watches folders on a fragile back-office PC and hash-chains + ships each nightly file exactly once — offline / power-cut tolerant, exactly-once, with a heartbeat (`run`/`once`/`verify`/`status`/`init-config`). Seals data where it is born, before the network.
- **Ingestion Custody Receipts** (`at1 custody`): every ingested file becomes one hash-chained append in a per-site ledger (source, content SHA, rows, timestamp); `verify` detects and localizes a tampered entry, and it renders an embeddable "Data custody: verified" badge. Chain-of-custody for data at the point of intake.
- **Cross-file Views** (`at1 crossview`): a manifest-aware UNION of an archive of per-unit `.at1` files as one logical table (e.g. `cashup_*.at1` → view `cashup`), with per-file min/max pruning (`build-manifest`/`query`/`explain`/`views`). Query a fleet of per-site/per-day files as one table.
- **Answers-with-Receipts** (`at1 askreceipt`): NL→SQL where every answer carries a signed, re-verifiable receipt of the exact SQL run (tables/columns/row-count/result-hash) — a wrong-column answer becomes a visibly-wrong, auditable query instead of a confident hallucination.
- **Certified Document Extraction** (`at1 docextract`): learn a template from sample reports/statements, extract cells bound to their source page + byte offset with a certificate, and TRIP a drift alarm when a document stops matching its template (`learn`/`extract`/`verify`). Extracted numbers stay provably tied to the source bytes.
- **Wet-Stock Reconciliation** (`at1 wetstock`): statistical fuel-tank inventory reconciliation — detect leaks and meter drift from daily dips / deliveries / pump totals via a model-coupled residual + CUSUM; emits a certified report with loss rate + confidence interval and an onset date. For fuel retailers / forecourt operators.
- **OEM / Embed Program** (`at1 embed`): run AT-1 engines per tenant, roll up ONE consolidated invoice, render white-label "Verified by AT-1" verify pages, and generate a wholesale price sheet (`run`/`rollup`/`verify-page`/`price-sheet`/`serve`). For MSPs / platforms embedding AT-1 under their own brand.

## Key pages
- [Platform](https://tinyfiles.io/platform) · [Benchmarks (proof on real data)](https://tinyfiles.io/comparison) · [Pricing](https://tinyfiles.io/pricing) · [Docs](https://tinyfiles.io/docs) · [Try it](https://tinyfiles.io/try)

## Honest scope
AT-1 wins on **structured/lossless** data and on the **queryable + verified** layer. It does **not** beat general compressors on natural images/video (a counting-theorem wall) and does **not** predict market price direction (tested exhaustively). We say so plainly.