Runback records everything an agent does so you can reproduce any run, find what broke, test a fix before release, and keep a signed record you can prove.
Every step records the precise context the model was handed — system prompt, conversation, tools — captured at the model boundary, with PII redacted in-process. A failed run opens on the step that broke. Click any step:
Re-execution holds tools, retrieval, context and timing fixed and runs the model fresh — so you can see if behaviour has changed, not watch a recording. LLMs are non-deterministic; getting a different output on replay is the signal, not a defect. When something breaks, bisect the model and prompt timeline to the exact change that caused it, in log₂ tries. Upgrading models? Replay a sample of real production decisions from the last 90 days against the candidate before you ship — behavioral drift shows as regressions, not incidents.
Flagged the $85k application for human review — correctly applied the $50k limit.
Approved the same $85k application — ignored the $50k limit entirely.
The same production failure, resolved with a log pipeline and with Runback. The difference is not tooling preference — it is whether the decision can be reproduced at all.
Save the step to a dataset with the checks it must keep passing and run it as an eval before release. Go further: simulate a candidate policy against 90 days of your own production decisions — not synthetic test cases — to know exactly which past runs would have been blocked before you ship it. Then enforce it in-process — the violating action is blocked before it runs, with a re-runnable record of the block. A breach becomes a red row, never an incident.
Export a complete, tamper-evident record of any run — every event in a SHA-256 hash chain, signed. Change one byte and verification fails. The artifact an auditor actually asks for.
SHA256(prev_hash + canonical({kind, key, output}))Runs seal into an org-wide ledger too. Each run becomes a leaf; the leaves form a Merkle tree, so a single signed root proves any one run is in the log — without handing over the rest of them.
A run that breaches policy or errors is auto-enrolled as a golden test — deduped so each distinct failure is one test. Re-run the suite on any candidate model before release and see, in seconds, whether an old incident would come back. Your regression suite is written by reality and grows with every run — the loop closes on itself.
Walk the loan-approval-agent incident — all 5 steps, the policy block, the cassette →
Logs record the outcome. Re-execution shows the reasoning — the exact context, retrieval, and messages[] the model saw. Root cause in 4m 23s, not 3h 48m.
Demo scenario — walk the exact step · walk it →The capture layer takes a sprint. The golden corpus, fleet benchmarks, and policy history take years — and can't be imported, back-filled, or bought.
Fleet benchmarks, golden suite, policy library · what's in Growth and Pro →Move models, frameworks, or vendors. The cassette stays open-format, signed, and re-executable. Your proof outlasts every software contract.
Open and verify a run yourself · open a run →EU AI Act Art. 12, APRA CPS 230, NIST AI RMF — one continuous record covers all three, built from the first run, not retrofitted when the auditor asks.
EU AI Act, Article 12 — read the law · the law ↗one Runback cassette · satisfies all three
GPT, Claude, Gemini, Llama, or your own — across LangGraph or any framework. One governance layer above every model vendor.
Why we don't compete on models · the standard →Observability records after the call. Runback seals the delegation before execution — scope, caller, and chain cryptographically proven.
Inter-agent trust chain — Enterprise · how delegation is signed →Behavioral history only builds forward. Every month you delay is a month of data you can never recover. That gap compounds.
Fleet benchmarks, model diff, policy library · what's in Pro →loan-approval-agent · 2:47 AM · every month you delay is behavioral data you can never recover
A fair question — your model calls happen inside your own application, not on Runback. You hook it up once; everything else runs on the trace that capture produces. Nothing sits in your critical path.
A ~3-line SDK wrap, a base-URL swap, or your existing OpenTelemetry traces. It's a post-hook: your real model call runs untouched — Runback only records the request it saw, the response, tokens, latency and tool calls.
const dbg = withDebugger(model)
const res = await generateText({ model: dbg.model })
await dbg.finish({ status: "success" })Secrets, keys, emails, card numbers and SSNs are scrubbed inside your application process, before a trace is sent anywhere. Even your own backend never sees them.
Captured runs are written to Postgres you control — self-hosted in your VPC — or our managed cloud. You set retention and access; delete a run and it's gone.
Every feature reads those captured traces — re-run from the captured context, gate releases against policy, export a signed record. No extra wiring, no second integration.
Live replay and evals re-execute a captured step against a model, so they use a provider key configured server-side — the only thing beyond the one-time hookup. Observe, time-travel, and audit need no model key at all.
Use the SDK for the deepest capture, or point existing OpenTelemetry traces at Runback — it sits above whatever framework you build in.
import { withDebugger } from "@runback/sdk";
import { generateText, stepCountIs } from "ai";
const dbg = withDebugger(model, { runName: "support-agent", redact: "standard" });
const res = await generateText({
model: dbg.model,
tools: dbg.tools(myTools),
stopWhen: stepCountIs(8),
prompt: task,
});
await dbg.finish({ output: res.text, status: "success" });Every run now shows up ready to observe, replay, gate, and audit. See all integrations →
Walk a real failing run step by step — no signup.