# Agents make claims. Reelier writes receipts.

*Every run: re-reasoned · re-billed · quietly drifting.*

Reelier compiles the run that worked into a file that replays deterministically — 0 tokens, byte-identical, a receipt on every step — and diffs runs to catch drift. [MEASURED]

**Record the run that worked. · Replay it deterministically. · Diff every run to catch drift.**

For agents on recurring production workflows — where "it ran" isn't proof.

**The mechanism (the slice):** your agent does the job once (~$0.02, ~3s) [MEASURED] → compiled to a skill file (SKILL.md) → replays deterministically (0 tokens, no re-reasoning) [MEASURED] → receipt written, every run.

Install: `npm i -g @seldonframe/reelier && reelier init`

Free forever · open source (AGPL) · runs on your machine · your keys · leaving = copying a folder

**Proof strip:** 1,000 replays: 1,000 byte-identical, 0 tokens [MEASURED] · every step assertion-checked [STRUCTURAL] · real drift self-healed for ~$0.001, once, then free [MEASURED] · ~50x cheaper ($0.019 vs ~$0.95 at 50 runs) [MEASURED] · ~59x faster (48ms vs ~2,842ms avg, varies by network) [MEASURED] · catches cross-run drift (SAME/DRIFTED, per step) [STRUCTURAL] · 224 open tests · mechanism independently corroborated (arXiv 2605.14237) [ATTRIBUTED]

## The mechanism, in four commands

1. `reelier init` — 60 seconds: record → compile → replay → your receipt.
2. `reelier run <name>.skill.md` — Replay any skill: deterministic, 0 tokens.
3. `reelier diff <name>` — SAME or DRIFTED, per step — exit 1 on drift.
4. `reelier push` — Sync receipts to your cloud ledger.

## What developers freeze first

- `sf-post-deploy-smoke.skill.md` — post-deploy smoke: asserted checks after every ship; broke once when an API shifted, healed for ~$0.001, 0 tokens since. [MEASURED]
- `posthog-weekly-pull.skill.md` — weekly metrics pull: same HogQL calls, fresh {{today-7d}} window every Monday, shape-asserted, 0 tokens. (In the repo: examples/loops.)
- `reelier diff post-deploy-smoke` — model-upgrade check: re-record on the new model, diff vs the frozen baseline — SAME or DRIFTED per step, exit 1 gates the rollout. [STRUCTURAL]

## Your agent relearns the job every run — then quietly drifts.

Every run re-derives the workflow, and every small "rational" fix compounds — what long-run operators call scar tissue. [ATTRIBUTED] A compiled file never relearns and can't drift.

## 374 clean runs. Zero silent wrong answers. The problem is the bill.

"How much did that cost?" is the first reply every long agent run gets. ~$0.019 and ~3 seconds per run, forever — or a Reelier replay: 0 tokens, receipt attached. 1,000 replays, 1,000 identical. [MEASURED]

## RPA replayed pixels and broke. Reelier replays tool calls — and proves each one.

Typed JSON in, typed JSON out, an assertion on every step — independently corroborated at 93.3–99.98% token reduction. [ATTRIBUTED] RPA rotted; skills get cheaper with age.

## Upgraded the model? Diff the runs before production finds out.

A replay is pinned — it can't drift and never calls the new model. Re-record on the upgraded model and `reelier diff` against your frozen baseline: SAME or DRIFTED, per step, with the failing assertion as the why. When an API shifts under a skill, assertions fail loudly — never silently. [STRUCTURAL]

## "Anything deterministic should just be code." Agreed — your agent already wrote it.

The agent's real, working run *is* the pipeline. Reelier compiles it into a tested file you replay deterministically — determinism without the hand-coding. [STRUCTURAL]

**The receipt:** a real API change broke a skill. The heal cost 687 + 105 tokens (~$0.001) and 1.3 seconds — once. Every run since: 0 tokens, no re-reasoning. And it holds at scale: 1,000 replays of another skill came back 1,000 byte-identical, 0 tokens, every single one. [MEASURED]

## Your skill is a markdown file in your repo. Nobody can hold it hostage.

AGPL, BYOK, and Level-0 replay never calls a model. [STRUCTURAL] Leaving is copying a folder. Closed alternatives: macOS-only, no EU, re-bill every replay. [ATTRIBUTED]

## Local proves it works once. Cloud proves it keeps working.

Sign in with GitHub and the same skill runs at 3am with your laptop closed — drift healed by morning. Local is free forever; Cloud is early access and free — sign in with GitHub to get your account and API key, push receipts, and run skills on a schedule. Share any receipt as a public permalink with an embeddable verified-replay badge for your repo. Your data exports anytime.

## Grounded, not ungrounded

Your agent graph is ungrounded. Reelier is the anchor. The field is shifting from single loops to graphs of loops — agents watching agents, evals over evals. But a graph without anchors fails worse than a loop: consistent, plausible, and verifying nothing ("green lights on the way down"). Reelier is the anchor — a deterministic, receipted, frozen node that actually touches the ground.

- **A measurement that can't be argued with:** the receipt — a run that actually ran, byte-identical, 0 tokens, asserted. [MEASURED]
- **A frozen node the optimizer can't tune:** Level-0 replay calls no model by construction, so it can't drift or game its own metric. [STRUCTURAL]
- **The honest edge:** assertions check each step against reality, and Reelier marks where its authority ends — what "better" means stays yours.

Loops optimize. Graphs arbitrate. Reelier anchors.

## The offer, honestly loaded

- **Dream outcome:** delegate repetitive work to your agent and never re-explain, never babysit, never wonder if it actually ran.
- **Likelihood it works:** assertions check every step; receipts prove every run; 224 open-source tests; spec'd formats; arXiv-corroborated mechanism.
- **Time to value:** one install, one "record yourself doing this," one replay. Minutes.
- **Effort:** your agent does the demonstration — you just do the task with it once, like you already do.

## Get it on your machine

`npm i -g @seldonframe/reelier`

GitHub: https://github.com/seldonframe/reelier · npm: https://www.npmjs.com/package/@seldonframe/reelier · SPEC.md ships in the tarball · running while you sleep: Reelier Cloud (see above)

## Sources

Every number on this page is tagged: [MEASURED] our own artifacts (the heal receipt and every latency/token figure come from a real Reelier run record; the 224-test suite is in the repo; reproduce with `reelier run`), plus our benchmark — N=2,038 total runs (1,020 agent baseline + 1,018 deterministic replays), July 2026, methodology in https://github.com/seldonframe/reelier/tree/main/examples/benchmark · [ATTRIBUTED] cited third parties ("groundhog day" — recurring theme across HN / Claude-community threads, 2025-26; one-shot record→replay, 93.3–99.98% token reduction — independent team, arXiv 2605.14237, their numbers/their paper; closed alternatives macOS-only / no-EU / re-bill-per-replay — vendor docs, July 2026) · [STRUCTURAL] true by construction (BYOK; Level-0 replay never calls a model; the engine is AGPL, so fork/audit/self-host rights hold forever).

AGPL-3.0 · SKILL.md-compatible · BYOK · Built by the SeldonFrame team. No fabricated benchmarks: every number on this page is tagged in source. Terms: https://reelier.com/terms · Privacy: https://reelier.com/privacy

Machine-readable summary: https://reelier.com/llms.txt