Reelier

---

Dein Agent leitet denselben Workflow bei jedem Lauf neu her — verbrennt Tokens und driftet dabei leise ab. Reelier kompiliert einen Lauf, der funktioniert hat, in eine SKILL.md-Datei, die deterministisch wieder abgespielt wird (kein LLM, 0 Tokens, jeder Schritt in einer Quittung festgehalten) und vergleicht dann Läufe, um den Tag zu erkennen, an dem sie nicht mehr übereinstimmen. Für Agenten in wiederkehrenden Produktions-Workflows — wo „es lief“ kein Beweis ist.

Installation → deine erste Quittung in 60 Sekunden

npm i -g reelier && reelier init

reelier init durchsucht zuerst die Arbeit, die du bereits erledigt hast — in Claude Code, Codex, Windsurf und OpenClaw — und bietet an, eine echte vergangene Sitzung in eine wiederholbare Fähigkeit umzuwandeln. Keine solche Historie? Es führt eine Demo ohne Einrichtung aus und schließt mit einer echten Quittung ab:

Your receipt:
  skill:        reelier-init-demo
  steps:        2 total, 2 passed, 0 unchecked, 0 failed
  replay time:  44ms  [measured]
  LLM tokens:   0     [measured]

  An agent doing a comparable task re-reasons every run (~2.8s, ~18k tokens on
  our benchmark). Your replay: 44ms, 0 tokens.

Oder führe es mit Docker aus — keine Node-Installation

docker run --rm ghcr.io/seldonframe/reelier --help

# Replay a skill from the current directory:
docker run --rm -v "$PWD:/work" -w /work ghcr.io/seldonframe/reelier run my.skill.md

# Record from your agent history (mount it read-only):
docker run --rm -v "$HOME/.claude:/root/.claude:ro" -v "$PWD:/work" -w /work \
  ghcr.io/seldonframe/reelier scan

Warum

• Dein Agent lernt den Job bei jedem Lauf neu — und driftet dann leise ab. Jeder Lauf leitet den Workflow neu her, und jede kleine „rationale“ Korrektur summiert sich — was Langzeitbetreiber Narbengewebe nennen. Eine kompilierte Fähigkeit lernt nie neu und kann nicht abdriften.
• Das eigentliche Problem ist die Rechnung. „Wie viel hat das gekostet?“ ist die erste Antwort, die jeder lange Agentenlauf erhält. Reelier spielt für 0 Tokens wieder ab, mit einer Quittung.
• Es ist kein sprödes RPA. Es spielt Tool-Aufrufe (typisiertes JSON rein/raus) wieder ab, nicht Pixel — und jeder Schritt trägt seine eigene Zusicherung, sodass ein fehlerhafter Schritt laut scheitert, niemals stillschweigend durchläuft.
• Modell aktualisiert? Eine Wiederholung ist fixiert — zeichne mit dem neuen Modell neu auf und reelier diff gegen deine eingefrorene Basislinie: GLEICH oder ABGEDRIFTET, pro Schritt, bevor es die Produktion erreicht.
• „Alles Deterministische sollte einfach Code sein.“ Einverstanden — dein Agent hat ihn bereits geschrieben. Reelier erfasst seinen echten, funktionierenden Lauf in einer getesteten Datei. Determinismus ohne die manuelle Codierung.

Wie es funktioniert — aufzeichnen → kompilieren → wiederholen → vergleichen → Quittung

reelier init                        # 60s: record → compile → replay → your receipt
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)

1. Aufzeichnen — drei Wege: reelier mcp --wrap "<your mcp server>" (ein verlustfreier Proxy vor den Tools deines Agenten), direkt aus einer bestehenden Sitzung (reelier scan / reelier from-session) oder der geführte reelier init.
2. Kompilieren — reelier compile wandelt einen Trace deterministisch in eine SKILL.md um (0 LLM-Aufrufe) — ein Rezept mit einer Zusicherung bei jedem Schritt, und die ehrlichen Lücken des Compilers werden als Offene Fragen ausgegeben (einschließlich literaler Daten, UUIDs und Zeitstempel, die er als „sollte das eine Variable sein?“ kennzeichnet), anstatt zu raten.
3. Wiederholen — reelier run führt es auf Level 0 aus: kein LLM, Millisekunden, byte-identisch. Standardmäßig schreibgeschützt — ein Schreibschritt (idempotent-write) wird nie erneut ausgelöst, es sei denn, du übergibst --allow-writes.
4. Vergleichen — reelier diff vergleicht zwei Läufe einer Fähigkeit und meldet GLEICH oder ABGEDRIFTET pro Schritt, mit der fehlgeschlagenen Zusicherung als Warum. Exit-Code 1 bei Drift, sodass es eine geplante Wiederholung blockiert.
5. Quittung — jeder Lauf ist eine Quittung (Ergebnisse pro Schritt, Zeitmessung, 0 Tokens). reelier push synchronisiert sie optional mit einem Quittungsbuch für einen teilbaren Permalink + ein einbettbares Verified-Replay-Badge.

Eine Agentenfähigkeit konvertieren

Wandle eine Anweisungsfähigkeit + einen aufgezeichneten Lauf in eine deterministische Wiederholung um — deine Fähigkeit, abzüglich des Modells:

reelier mcp --wrap "<your mcp server>"                 # record: agent runs the skill's task once
reelier compile trace.jsonl --from-skill ./my-skill/SKILL.md
# → my-skill.skill.md — name + description carried from your SKILL.md,
#   steps ONLY from the recorded run (never generated from instruction text)

Sitzungen von jedem Agenten importieren

Du hast bereits wiederholbare Workflows in den Sitzungsprotokollen deines Agenten. reelier scan findet sie; reelier from-session macht daraus eine Fähigkeit. Das Format wird aus dem Inhalt der Datei erkannt — kein Flag für die unterstützten Agenten erforderlich:

reelier scan                                          # discovers sessions from every known agent under your home dir
reelier from-session ~/.claude/projects/*/*.jsonl      # Claude Code
reelier from-session ~/.codex/sessions/**/rollout-*.jsonl   # Codex CLI
reelier from-session ~/.openclaw/agents/*/sessions/*.jsonl  # OpenClaw

Agent	Sitzungsspeicherort	Status
Claude Code	~/.claude/projects/<project>/<uuid>.jsonl	unterstützt
Codex CLI	~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl	unterstützt
OpenClaw	~/.openclaw/agents/<agentId>/sessions/<sessionId>.jsonl	unterstützt
Cursor	.../User/globalStorage/state.vscdb (SQLite, undokumentiert)	erkannt, noch nicht analysierbar
Windsurf	.../User/globalStorage/state.vscdb (SQLite, undokumentiert)	erkannt, noch nicht analysierbar

Nur wiederholbare Aufrufe (Reeliers eigene Builtins oder mcp__<server>__<tool>-Aufrufe) werden jemals in eine Fähigkeit kompiliert — native Datei-/Shell-/Suchaktionen werden als übersprungen gemeldet, niemals als Schritt erfunden. Übergib --agent <claude-code|codex|openclaw>, um ein Format zu erzwingen, anstatt es automatisch zu erkennen; reelier scan / reelier from-session --agent cursor (oder --agent windsurf) geben ehrlich wieder, was auf der Platte ist, anstatt bei einem undokumentierten Binärformat zu raten.

Drei Tests, eine Fähigkeit

Eine aufgezeichnete Fähigkeit liefert dir drei verschiedene Fragen, die du an sie stellen kannst, nicht nur eine:

• Determinismus — reelier run <skill.md> spielt gegen die von dir aufgezeichneten Zusicherungen wieder ab. Gleiche Schritte, gleiche Zusicherungen, 0 Tokens. Antwortet auf: macht das noch, was es gemacht hat?
• Wiederherstellung — reelier run <skill.md> --fail N[=status] injiziert einen synthetischen Fehler bei Schritt N (Standardstatus 500; überschreibbar mit --fail N=429, wiederholbar), anstatt den echten Tool-Aufruf dieses Schritts auszuführen, und durchläuft dann DIESELBE Eskalationsleiter, die ein echter Fehler treffen würde. Außerhalb des Netzwerks passiert nichts wirklich — ein simulierter Schritt ruft sein Tool nie auf, sodass du einen Schreibschritt ohne --allow-writes und ohne Seiteneffekt auf Wiederherstellung testen kannst. Antwortet auf: wenn das kaputt ginge, würde die Fähigkeit es bemerken und heilen? (Ein Mock-Lauf ist nur ein lokaler Test — reelier push weigert sich, einen zu veröffentlichen; siehe unten.)
• Drift — reelier run <skill.md> --wrap "<your mcp server>" spielt gegen deine live, schreibgeschützten Abhängigkeiten anstelle des aufgezeichneten Traces wieder ab. Gepaart mit reelier manifest (unten) erkennst du so, wenn sich das Schema eines Tools unter dir wegbewegt, bevor es eine echte Wiederholung tut.

Taxonomie dank Mads Hansens Überprüfung des Launch-Posts.

Tool-Schema-Drift: reelier manifest

Die Schritte einer Fähigkeit rufen bestimmte Tools mit bestimmten Argumentformen auf. Wenn sich das Tool-Schema eines eingebundenen MCP-Servers seit deiner Aufzeichnung geändert hat, sollte die Wiederholung laut verweigern, nicht stillschweigend die falschen Argumente füllen. reelier manifest stempelt einen Schema-Digest für jedes Tool, das die Schritte der Fähigkeit tatsächlich verwenden:

reelier manifest <skill.md> --wrap "<your mcp server>"   # stamp/refresh the manifest from live servers
reelier run <skill.md> --wrap "<your mcp server>"         # preflight checks the manifest BEFORE step 1 runs

Wenn das Schema eines gestempelten Tools abgedriftet ist (oder das Tool fehlt), scheitert reelier run geschlossen — MANIFEST DRIFT — refusing to replay — bevor irgendetwas ausgeführt wird. --ignore-manifest ist die explizite Notfall-Überschreibung für den Fall, dass du weißt, dass die Drift in Ordnung ist; sie wird trotzdem im Lauf aufgezeichnet (manifestIgnored: true), ist also niemals eine stille Umgehung. Eine Fähigkeit ohne Manifest erhält lediglich einen Hinweis — jede Fähigkeit vor der Manifest-Einführung funktioniert unverändert weiter.

Schrittweise Schreibfreigabe: reelier approve

--allow-writes/--yes sind pauschale Flags — sie sagen „dieser Lauf darf schreiben“, nicht „dieser exakte Schreibvorgang ist überprüft“. reelier approve bindet die Freigabe per Hash an das Tool + die Argumentvorlage eines bestimmten Schritts:

reelier approve <skill.md>          # walk each write/destructive step, y/N to approve
reelier approve <skill.md> --all    # approve every write step non-interactively

Ein freigegebener Schritt, dessen Tool/Argumente noch mit seinem gestempelten Hash übereinstimmen, wird ganz ohne Flags ausgeführt. Wenn sich das Tool oder die Argumente des Schritts seit der Freigabe geändert haben, scheitert die Wiederholung geschlossen — Approval mismatch — und kein Flag setzt es außer Kraft; du überprüfst und genehmigst erneut. Ein Schreibschritt ohne approve:-Feld behält das heutige exakte --allow-writes/--yes-Verhalten bei, unverändert.

Den Wert zusichern, nicht nur die Form

Die Zusicherungen einer Fähigkeit machen eine Wiederholung zum Beweis. Die Grammatik prüft Status, Struktur und Wert:

- assert: status == 200
- assert: json.results is array
- assert: json.count >= 1              # numeric range
- assert: json.plan is string          # type
- assert: json.id matches /^usr_/      # value pattern
- assert: body contains "ok"

Verwende es in deinem Coding-Agenten (MCP)

reelier serve stellt Reeliers eigene Befehle als MCP-Tools bereit, sodass Claude Code / Cursor / Windsurf / Codex sie mitten in der Sitzung aufrufen können:

{ "mcpServers": { "reelier": { "command": "npx", "args": ["-y", "reelier", "serve"] } } }

Der Agent erhält reelier_scan, reelier_from_session, reelier_replay, reelier_diff und reelier_push — mit Beschreibungen, die ihm genau sagen, wann er welche verwenden soll (und wann nicht). Er zeichnet eine deterministische Aufgabe einmal auf und spielt sie dann wieder ab, anstatt sie neu zu durchdenken.

Tools

• reelier_scan — Durchsucht den Sitzungsverlauf des Agenten (Claude Code, Codex, Windsurf, OpenClaw) nach wiederholbaren Tool-Aufruf-Workflows
• reelier_from_session — Kompiliert eine aufgezeichnete Sitzung in eine wiederholbare SKILL.md mit einer Zusicherung bei jedem Schritt
• reelier_replay — Spielt eine Fähigkeit deterministisch mit 0 LLM-Tokens wieder ab (standardmäßig schreibgeschützt; Schreibvorgänge durch --allow-writes geschützt)
• reelier_diff — Vergleicht zwei Läufe: GLEICH oder ABGEDRIFTET pro Schritt, mit der fehlgeschlagenen Zusicherung als Warum; Exit 1 bei Drift
• reelier_push — Synchronisiert eine Laufquittung mit dem Ledger für einen teilbaren Permalink (Opt-in)

Der gemessene Beweis

Aus einem echten, live durchgeführten Direktvergleich (Agent vs. Reelier, gleiche Aufgabe, gleiche Daten) — vollständige Tabellen + Methodik in examples/benchmark:

• 1.000 / 1.000 Wiederholungen byte-identisch (N=1000 Tail-Varianz-Test)
• 0 Tokens pro Wiederholung — verifiziert aus dem Laufprotokoll, nicht angenommen
• ~50× günstiger (0,000000 $/Wiederholung vs. 0,019068 $/Lauf im Durchschnitt über den Agentenarm)
• ~59× schneller (48 ms vs. 2.842 ms durchschnittliche Latenz)
• eine echte Drift selbst geheilt für ~0,001 $, einmal, dann jede Wiederholung danach kostenlos

Latenz variiert je nach Netzwerk — Level-0-Wiederholung führt die Tool-Aufrufe der Fähigkeit erneut aus, daher hängt die Echtzeit von deiner Verbindung ab. Was nicht variiert: 0 LLM-Tokens, die gleichen Schritte bei jedem Lauf und die Quittung. Unabhängig bestätigt — arXiv 2605.14237 fand 93,3–99,98 % Token-Reduktion für dasselbe Aufzeichnen-und-Wiederholen-Muster.

Funktioniert mit jedem Modell (BYOK)

Level-0-Wiederholung (der Standard) ruft niemals ein Modell auf — 0 Tokens, konstruktionsbedingt. Eskalation (--max-level 1|2) ist Opt-in und kommuniziert über eine schmale BYOK-Schnittstelle (--llm-base-url + --llm-model): einen nativen Anthropic Messages-Adapter und einen OpenAI-kompatiblen Adapter für alles andere (OpenRouter, Ollama, Gemini's OpenAI-Endpunkt, Groq, vLLM, LM Studio, Kimi, …). Richte es auf ein stärkeres Modell und die nächste Selbstheilung jeder Fähigkeit wird kostenlos intelligenter.

Besitze es — MIT, BYOK, Local-First

Verwende es überall, bette es in alles ein — keine Copyleft-Auflagen, keine rechtliche Prüfung erforderlich. Deine Fähigkeiten, Traces und Laufaufzeichnungen sind deine Daten — Gehen bedeutet, einen Ordner zu kopieren. Die Formate sind in SPEC.md spezifiziert, einer normativen Referenz im RFC-Stil, sodass jeder sie ausgeben oder konsumieren kann, ohne den Quellcode zu lesen.

Mitwirken

Issues und PRs sind willkommen — siehe SPEC.md für die Formate (die Spec hat Vorrang vor dem Code; korrigiere den Code, nicht die Spec). npm test führt die gesamte Suite aus; npm run build && npx tsc --noEmit vor einem PR.

git clone https://github.com/seldonframe/reelier && cd reelier
npm install && npm test

Stern-Verlauf

Lizenz

MIT — frei zum Forken, Einbetten, Auditieren und für immer selbst Hosten. (Versionen ≤0.16.0 wurden unter AGPL-3.0 veröffentlicht und bleiben es.)