Reelier — 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.

$npm i -g @seldonframe/reelier && reelier init

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

Sound / expand

The mechanism, sliced

Your agent does the job — once~$0.02 · ~3s · tokens^MEASURED

→ compiled to a skill file (SKILL.md)

→ replays deterministically0 tokens · no re-reasoning^MEASURED

→ receipt written, every run

The mechanism, in four commands

$ reelier init

60 seconds: record → compile → replay → your receipt.

✓ receipt · 2/2 passed · 0 tokens

$ reelier run <name>.skill.md

Replay any skill — deterministic, 0 tokens.

✓ 2/2 passed · 44ms · 0 tokens

$ reelier diff <name>

SAME or DRIFTED, per step — exit 1 on drift.

⚠ DRIFTED · step 3 · 200 → 401

$ reelier push

Sync receipts to your cloud ledger.

✓ pushed · permalink + badge

$ reelier init --yes

Reelier init — record once, replay forever. Let's get your first receipt in under 60 seconds.

Recording the zero-setup demo — 2 real HTTP requests, nothing fabricated:
  Recorded .reelier/traces/2026-07-19T00-00-00.jsonl

Compiling live (zero LLM calls)...
  Wrote reelier-init-demo.skill.md
  steps: 2  asserts: 2  binds: 1

Replaying once (Level 0 — the LLM is never constructed or called)...
  ✓ Step 1 — GET npm registry metadata [passed]
  ✓ Step 2 — GET package homepage [passed]

Your receipt:
  steps:        2 total, 2 passed, 0 unchecked, 0 failed
  replay time:  210ms [measured]
  LLM tokens:   0 [measured]

What a run actually writes to disk

your-repo/

└─ .reelier/traces/2026-07-19T00-00-00.jsonltrace — what happened

└─ skills/deploy-smoke.skill.mdskill — the recipe, with its own assertions

└─ .reelier/runs/2026-07-19T00-00-04.jsonlruns — the receipts

Same four stages, on a loop

Record → compile → replay → self-heal. Every lap after the first: 0 tokens.

Replays never call a model; a heal costs ~$0.001, once. Skills get cheaper with age. ^MEASURED

RecordAn MCP proxy watches the agent work

CompileTrace → SKILL.md, an assert on every step

ReplayLevel 0 · no LLM · 0 tokens

Self-healDrift patches once, writes its own changelog

cheaper with age

first pass

Record and compile happen once, at the cost of a normal agent run.

every run after

Replay loops at Level 0 — deterministic, no model, 0 tokens.

on drift only

Self-heal patches the one broken step and feeds it back — the same drift never bills twice.

on a schedule

reelier diff compares each run to your frozen baseline — SAME or DRIFTED, per step.

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 ever 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 →

reelier diff post-deploy-smoke

Model-upgrade check: re-record on the new model, diff against your 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. A compiled file never relearns and can’t drift. ^ATTRIBUTED

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. RPA rotted; skills get cheaper with age. ^ATTRIBUTED

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

A replay is pinned — it can’t drift and never calls the new model. So 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 isthe pipeline. Reelier compiles it into a tested file you replay deterministically — determinism without the hand-coding. ^STRUCTURAL

A real self-heal, from our test suite

^MEASURED

heal-me.skill.mdL1 heal — bind only, no LLM tool call beyond the patch

before — broke

### Step 1 — get a note
- intent: fetch a note
- action: http.get {"url": "https://example.com/note"}
- assert: status == 200
- bind: id = json.id
- effect: read

after — healed once

### Step 1 — get a note
- intent: fetch a note
- action: http.get {"url": "https://example.com/note"}
- assert: status == 200
- bind: id = json.note.id
- effect: read
 
## Changelog
- 2026-07-18 — L1 heal, step 1 (get a note): the id moved under a 'note' wrapper object

The receipt — a real skill that broke and healed

^MEASURED

sf-post-deploy-smokeSKILL.md

RunStepsWhat happenedTimeTokens

run 1✓✓✓✓drift detected → healed, changelog written1.3s687 + 105

run 2✓✓✓✓deterministic replay—0

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

AGPL, BYOK, Level-0 replay never calls a model — leaving is copying a folder. ^STRUCTURAL

The self-healing ladder

Nearly everything stays at Level 0.

Level 0is deterministic replay — 0 tokens, always. A model is only reached if a recorded step drifts (an API or page changed underneath it), and only if you opt in. Each rung is rarer than the last.

Deterministic replay

0 LLM calls · 0 tokens · byte-identical. Fails closed on drift — never guesses.

the default

Re-read the captured result

Patch the step's assertion against what it already saw. No re-execution.

→ your model

Propose new args, one safe re-exec

Read / idempotent-only. Destructive steps never escalate.

→ your model

You edit the skill by hand

The rare case the recorded workflow no longer applies at all.

human

LLM-agnostic · BYOK

Replay calls no model. Escalation calls yours.

Level 0 touches zero LLMs by construction. Only escalation reaches a model — through one narrow interface, out to any provider you point it at. Any model, your key.

replay stepmatches → no model · 0 tokensdone

on drift — escalation only (opt-in)

One narrow interface

OpenAI-compatible baseURL + native Anthropic adapter

Anthropicnative adapter

OpenRouterOpenAI-compat

Ollamalocal

GeminiOpenAI-compat

GroqOpenAI-compat

Kimi (Moonshot)OpenAI-compat

vLLMself-host

LM Studiolocal

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

Real receipts, as they land

^MEASURED

sf-post-deploy-smoke✓✓✓✓drift detected → healed, changelog written1.3s687 + 105 tok

sf-post-deploy-smoke✓✓✓✓deterministic replay—0 tok

reelier-init-demo✓✓deterministic replay (2 real HTTP calls)210ms0 tok

benchmark batch (1,000 runs)✓1,000 byte-identical replays48ms avg0 tok

Reelier Cloud

Sign in with GitHub to get your account and API key. Push your receipts to a hosted ledger and run skills on a schedule while your laptop’s closed. Share any receipt as a public permalink with an embeddable verified-replay badge for your repo. Free tier, your data exports anytime.

What you get when you sign in: runs, schedules, and shareable receipts, all in one dashboard.

The anchor

Your agent graph is ungrounded. Reelier is the anchor.

The field is shifting from single loops to graphs of loops — agents watching agents. A graph without anchors fails worse than a loop: consistent, plausible, verifying nothing. 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.

Get it on your machine.
Let the receipt convince you.

$npm i -g @seldonframe/reelier

GitHub → seldonframe/reelier·SPEC.md ships in the tarball·running while you sleep → Cloud

Sources — every number on this page is tagged

MEASURED

Our own artifacts. The heal receipt and every latency and 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 examples/benchmark.

ATTRIBUTED

Cited third parties. “Groundhog day” — recurring theme across HN / Claude-community threads, 2025–26 · drift / “scar tissue” in long-running agents — r/AgentsOfAI + r/AI_Agents threads, July 2026 · 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. Nothing here depends on a vendor’s good behavior.

Agents make claims. Reelier writes receipts.

Record → compile → replay → self-heal. Every lap after the first: 0 tokens.

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

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

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

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

“Anything deterministic should just be code.” Agreed — your agent already wrote it.

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

Nearly everything stays at Level 0.

Replay calls no model. Escalation calls yours.

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

Your agent graph is ungrounded. Reelier is the anchor.

Get it on your machine.Let the receipt convince you.

Get it on your machine.
Let the receipt convince you.