Skip to main content
Glama

Reelier

Let your agents write. Keep the receipts.

Your agents worked all night. Here's exactly what changed.

Reelier records the run that worked, freezes it as a replayable skill, and replays it deterministically — every run comes back as a receipt: proof of what the agent did and what changed because of it. Agents make claims. Reelier writes receipts.

npm version CI tests license Discord stars

Website · Docs · SPEC.md

▶ watch with sound (27s)


Receipts on your agent PRs — install and done

Agent-authored PRs (Dependabot, Claude, Codex, Cursor, …) get a receipt comment in seconds: author, files changed, declared scope vs. what actually changed, sensitive paths flagged. No workflow file, no CLI, no config.

→ Install the Reelier receipts GitHub App — free on public repos, forever.

Reelier receipt — agent PR Author: dependabot[bot] · Files changed: 2 (+119 −41) Declared scope: none (add .reelier/scope.yml to enable unexpected-write detection) Sensitive paths touched: ⚠ 1 — package-lock.json Proves scope and change, not correctness

A real receipt from Reelier's own repos — see one live. Declare scope per agent in .reelier/scope.yml (or a reelier-scope block in the PR body) and the receipt reports unexpected writes. The receipt proves scope and change, never correctness or safety.


Related MCP server: MCP Execution Ledger

Why

AI agents are non-deterministic — the same prompt, a different result every run — and they'll claim they did the work whether they did or not. Reelier records the run that worked, replays it deterministically, and writes a signed receipt that proves it. Point it at your existing CI in one workflow — it adds a verifiable receipt, it doesn't replace your stack.

Measured on a real head-to-head benchmark, same task, same data (full method):

  • 1,000 / 1,000 replays byte-identical

  • Every replay ships a signed receipt — proof of what ran and what changed, never a claim

  • 0 LLM calls at replay — deterministic re-execution, not re-reasoning

Deterministic replay is also ~50× cheaper and ~59× faster than re-running the agent, on the same benchmark.

Install

npm i -g reelier && reelier init
# No Node install needed — same commands via Docker:
docker run --rm ghcr.io/seldonframe/reelier --help

reelier init [--dry-run] performs one checkpointed local inspection across all three Reelier paths: Path A observation coverage, Path B replay/freeze candidates, and Path C boundable/outcome-capable/shadow-only/unsupported connections and candidates. It does not deploy, gate, dispatch, upload, copy credentials, or rewrite host configuration. --dry-run writes nothing; the normal command writes only sanitized artifacts below .reelier/init/.

As an agent plugin

Teach your coding agent when to reach for Reelier. Same two commands, either host:

claude plugin marketplace add seldonframe/reelier
claude plugin install reelier@seldonframe
codex plugin marketplace add seldonframe/reelier
codex plugin add reelier@seldonframe

This installs two Agent Skills and nothing else. reelier-replay teaches your agent to freeze a repeatable tool-call job and replay it at 0 tokens. reelier-write-safety covers bounding an agent's writes before you grant them: what the recorder sees, what a policy refuses, and what a receipt does and does not prove. It ships no MCP servers, so it does not wrap, observe, or gate any tool call on its own; the reelier CLI does that, and the skills drive it via npx. Packaged in both the Agent Plugins v1.0.0 format (plugin/agent-plugins/) and the Claude Code format (plugin/claude/), generated from one source by scripts/build-plugin-packages.mjs.

Verified end to end on codex-cli 0.147.0-alpha.1.2: both formats install, enable, and the skill reaches the model. Other hosts are untested, and per-host status is tracked in docs/specs/agent-plugins-coverage-v1.md §4 rather than claimed here.

How to use it

reelier init --dry-run              # inspect Path A/B/C locally; write nothing
reelier init                        # persist resumable sanitized inspection artifacts
reelier run  <name>.skill.md        # replay deterministically — 0 tokens (read-only by default)
reelier diff <name>                 # SAME or DRIFTED, per step — exit 1 on drift
reelier push <name>.skill.md        # sync receipts to your ledger (opt-in)
reelier ci                          # write a workflow: drift-CI + PR receipts, one command
  1. Inspect, then record or freeze. reelier init reveals observed coverage and local candidates without changing routes. reelier mcp --wrap "<mcp server>" proxies live tools; reelier scan/from-session freezes supported history.

  2. Compile. reelier compile turns a trace into a SKILL.md — 0 LLM calls, minimal assertions, honest gaps printed as Open questions.

  3. Replay. reelier run replays it at Level 0 — no LLM, byte-identical, read-only by default (writes need --allow-writes).

  4. Diff. reelier diff reports SAME or DRIFTED per step, with the failing assertion as the why — exit 1 on drift.

  5. Log in. reelier login connects this machine to Reelier Cloud with a device code in your browser — or set REELIER_CLOUD_URL/REELIER_CLOUD_KEY for CI and self-hosting.

  6. Push. Every run is a receipt; reelier push optionally syncs it to a ledger for a permalink and an embeddable verified-replay badge.

Already have an Agent Skill? Convert it — your skill, minus the model:

reelier compile trace.jsonl --from-skill ./my-skill/SKILL.md

Three tests, one skill

Test

Command

Answers

Determinism

reelier run <skill.md>

Does this still do what it did?

Recovery

reelier run <skill.md> --fail N

If this broke, would the skill notice and heal?

Drift

reelier run <skill.md> --wrap "<your mcp server>"

Has the world moved out from under this skill?

Taxonomy due to Mads Hansen's review of the launch post. Full semantics for each test, including recovery injection and manifest guardrails: docs/REFERENCE.md.

Gate Dependabot / Renovate bump PRs

Dependabot and Renovate open the PR and run your test suite — but neither knows what your agent actually does at runtime, so a dependency bump that silently changes a tool call's shape (a renamed field, a new default, a different error) sails through with green unit tests. This is the check they don't run.

Copy .github/workflows/reelier-bump-check.yml into your repo, point skill: at your own recorded .skill.md file(s), and it will: gate to PRs from dependabot[bot]/renovate[bot] (or a dependencies label), install the bumped dependency, replay your recorded skill live against it at --max-level 0 (0 tokens), and fail the check on the exact step that drifted.

This tests dependency and MCP-tool-call behavior — it does not test model upgrades; --max-level 0 never calls an LLM. Full listing copy and setup: docs/marketplace-listing.md.

Prove it

A pushed receipt carries a ladder of independently-verifiable claims — not one blanket "verified." Depending on what you turn on, it can be signed, timestamped, CI-attested, and carry cross-checkable provider request-ids. reelier verify recomputes every claim offline, and a claim you haven't enabled just renders as an honest gap, never a shamed one.

See a real one: reelier.com/r/HWBdmGob9KeHRqXi-OEaRD0z.

Full 8-rung ladder, what each rung does and doesn't prove: docs/REFERENCE.md.

If your skills are employees

Employee lifecycle

Reelier equivalent

Skillify a session

reelier from-session

Performance review

reelier run + reelier diff

Fleet maintenance

scheduled replays + drift alerts

The record

signed receipts

"Verified" describes the record, never the agent — a receipt proves what ran and what changed, not that the agent was good at its job.

An employment contract doesn't make an employee good — it makes what they did visible and bounded. Same here: receipts prove scope and change, never correctness.

Who it's for

  • Solo dev / OSS maintainer — a real regression test again; drift can't pass silently.

  • Team shipping agent changes — "it ran clean" becomes a checkable PR artifact, not a claim.

  • Agency running agents for clients — signed, timestamped proof-of-delivery a client can verify.

  • Marketplace buyer or seller — corroborated receipts are reviews that can't be astroturfed.

  • Audit-facing ops — a signed, CI-attested trail of every write, idempotency key included.


MIT, free forever (versions ≤0.16.0 remain AGPL-3.0). Your data — skills, traces, runs — is specified in SPEC.md, so leaving is copying a folder.

Contributing: issues and PRs welcome — SPEC.md is the source of truth for formats; fix the code, not the spec. npm test before a PR.

If Reelier saved you a re-run, star it ⭐ — it's how other builders find it.

Available Tools

5 tools
reelier_diffA

Compare two runs of the same skill and report SAME or DRIFTED — the drift-detector for a recorded baseline replayed on a schedule. Compares per-step outcomes, structure, and heal-level from .reelier/runs/.jsonl (defaults to the last two runs); data values that legitimately change run-to-run are NOT drift. Drifted steps carry why (the failing assertion). To check a MODEL upgrade: re-record the workflow with the new model, then diff against your frozen baseline — replaying a pinned skill can't reveal model changes (replay never calls a model). Honest when there aren't two runs yet.

Inputs: skill (required), cwd, baselineIndex, candidateIndex.

reelier_from_sessionA

Compile a SKILL.md from a session transcript. USE WHEN: the work ALREADY happened (this session or by hand) — recording can't be retroactive. NOT for work that hasn't happened yet (record that live via the reelier mcp proxy). Get the transcriptPath from reelier_scan first. Returns the written skill's path, stats, and open questions — or, honestly, that nothing in the transcript was replayable. If the workflow used a relative time window ("this week"), bind it to a date variable (e.g. {{today-7d}}) so later replays pull the CURRENT window, not a frozen one — the openQuestions output flags this.

Inputs: transcriptPath (required), out, name, force.

reelier_pushA

Push a skill's local run records (and, on first push, the skill file) to your receipt ledger, where each receipt gets a shareable permalink + verified-replay badge. Requires an apiKey — from reelier login (or REELIER_CLOUD_KEY in env) — reports skipped-no-key honestly when absent; the cloud URL always resolves on its own. USE WHEN: a run's receipt should be durable or shareable.

Inputs: skillPath (required), all, cwd, dryRun, +1 more.

reelier_replayA

Run a skill file at Level 0 (deterministic replay, zero LLM calls) and return the real run record: per-step outcomes, timing, totals, and — when a step drifted — why (the failing assertion). Never fabricates a pass. Reproduces the recorded TOOL CALLS (MCP/HTTP) only — no LLM reasoning or prose step re-runs. It does NOT schedule itself: pair with cron/CI for recurring runs. Pass vars to fill {{templated}} inputs (e.g. a computed date window) so a replay pulls current data. READ-ONLY by default: 'idempotent-write' steps are held back (reported as a refused/failed step) unless you pass allowWrites — so replaying never re-fires a write.

Inputs: skillPath (required), cwd, vars, wrap, +2 more.

reelier_scanA

Discover replayable workflows in an agent's session history (defaults to ~/.claude/projects). Returns each session's transcript path — feed one to reelier_from_session. Only MCP/HTTP tool-call sequences are replayable; native file/shell actions are reported as skipped, never fabricated into a fake result. USE WHEN: deciding which past work is worth compiling into a replayable skill.

Inputs: dir.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A4.4/5.0

    Scored across 5 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose: scan discovers workflows, from_session compiles them into skills, replay executes skills, push shares receipts, and diff compares runs. No overlap or confusion.

    Naming Consistency5/5

    All tools share the 'reelier_' prefix followed by a clear verb or action (scan, replay, push, from_session, diff). The pattern is consistent and intuitive.

    Tool Count5/5

    Five tools is a well-scoped set for the domain of replayable skill management. Each tool serves a core function without redundancy or excess.

    Completeness4/5

    The tool surface covers scanning, compiling, replaying, sharing, and comparing skills. However, there is a notable gap: live recording of workflows is mentioned but not provided as a tool, which limits the server's ability to create new skills from scratch.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Records all MCP tool interactions in a centralized ledger, enabling developers to trace, replay, inspect, and audit AI agent workflows.
      -
    • A
      license
      Not graded
      quality
      B
      maintenance
      This MCP server provides a stateful, resettable, verifiable API runtime that gates every tool call, enabling agents to run long workflows against provider-shaped environments without live provider write access. It records decisions, side effects, and outcome evidence for replayable, verifiable benchmark runs.
      Apache 2.0
    • A
      license
      B
      quality
      D
      maintenance
      Privacy-first, tamper-evident receipts for MCP tool calls. It hashes and signs arguments/results so you can verify what ran, when, without storing raw payloads.
      2
      MIT