Reelier vs VCR / Polly.js: cassettes mock, Reelier re-executes
A cassette library replays a frozen HTTP response so your test never touches the network; Reelier replays the recorded tool-call sequence against the real systems, so it catches drift a frozen response would hide.
Where VCR / Polly.js win
Reach for a cassette first when you are writing unit tests. VCR.py (Python) and Polly.js (JavaScript) record an HTTP interaction once into a serialized cassette, then on replay return that stored response without a single packet leaving the machine. That is the whole point, and it is a good one: the test is fast, offline, and deterministic, decoupled from a live server that might be slow, rate-limited, or down. For a pure HTTP client — one request, one response you want to assert against — a cassette is simpler than anything Reelier does.
The stale-cassette worry is real but the libraries answer it directly. VCR.py's record_mode (once, new_episodes, none, all) controls when a cassette re-records against the real server; Polly.js has the same record/replay/passthrough modes. So a cassette is not doomed to rot silently — you can set it to refresh. Do not read this page as “cassettes lie.” They replay exactly what you told them to record, on purpose, at the transport layer.
If your job really is testing an HTTP function in isolation, a cassette library is the right tool and Reelier is the wrong one. Nothing below is an argument to rip out VCR.
Where Reelier fits
Reelier operates a layer up. A cassette mocks the transport: it intercepts the HTTP call and hands back a stored body, so the code under test never learns whether the real endpoint still behaves. Reelier records the agent's own tool-call sequence — MCP tool calls and its http.get/http.post builtins — and on replay re-executes those calls against the live systems, checking an assertion on every step it can check. The npm download count a replayed skill reads is this week's number, fetched live, not the number from the recording.
That difference is the point of the tool. A frozen response passes a test even after the live API has changed its shape, added a required field, or started returning an error — because the cassette never asks. Reelier's replay does ask, every run, and when the fresh response fails a recorded assertion the step fails loudly: a named failing step on the receipt, reelier diff exiting 1 with the failing assertion as the why. Loud failure on real change is the feature; a cassette is designed to be silent about exactly that.
The trade-off is honest and symmetric. Reelier is not offline and not free of the network — it re-executes real calls, so replay latency tracks the workload, and a job that writes needs an explicit gate (replay is read-only by default; --allow-writes unlocks idempotent writes only, destructive steps need --yes). Judgment still needs a model, opt-in and BYOK. What you buy for giving up the cassette's offline purity is a run that actually verifies the live systems still answer the way they did when you recorded.
One naming caveat, since it trips people up: a newer MCP tool called “Agent VCR” does record/replay/diff for agents and is a different thing from the classic VCR.py library this page compares. Don't conflate the two.
Side by side
| VCR / Polly.js | Reelier | |
|---|---|---|
| What replays | A stored HTTP response (the cassette), returned by the transport mock | The recorded tool-call sequence, re-executed against the live systems |
| Touches the network on replay | No — that's the point: offline and deterministic | Yes — re-runs the real calls, so latency tracks the workload |
| Catches live API drift | No by design — a frozen response can't notice the world changed | Yes — a changed response fails a recorded assertion, reelier diff exits 1 |
| Primary job | HTTP unit tests decoupled from a live server | Regression/drift gate on a recurring agent job against real systems |
| Scope of recording | HTTP interactions at the transport layer | The agent's typed tool calls (MCP + http builtins) |
A real receipt
The output below is a real replay receipt, not a mockup: the registry-latest portfolio skill — one recorded HTTP call to the npm registry, two assertions — replayed on 2026-07-21 with the CLI pinned to the version that recorded the seed (npx -y reelier@0.12.1), so it reproduces verbatim. Unlike a cassette, the request actually went to the live registry; the assertions checked the fresh response.
npx -y reelier@0.12.1 run examples/portfolio/registry-latest.skill.md === registry-latest === ✓ Step 1 — Latest dist-tag from the registry [passed] 152ms PASSED: 1/1 steps ok, 0 failed, 152ms total
Verbatim seed receipt recorded in seldonframe/reelier examples/portfolio/README.md (reelier@0.12.1, 2026-07-21). Replay it yourself from a checkout of the repo — read-only, no account, no key.