Agent guardrails, with a receipt

Your coding agent is one
command from deleting prod.

Provenrail stops it, and writes a receipt that cannot be altered without the change showing. One command puts guardrails at your agent's own tool boundary, so rm -rf, terraform destroy, force pushes and leaked keys are blocked before they run. Every decision is signed and hash-chained off-box, verifiable by anyone with an open-source tool that trusts neither the agent nor us.

In April 2026 an AI coding agent deleted a production database and every backup in nine seconds. There was no forensic record of what it was asked to do. The incidents, and what would have stopped them →

Free tier. No credit card. Installs in seconds. See how it compares.

Honest scope: guardrails cover the tool calls your agent routes through its hooks, and a record is immutable and verifiable once it reaches the sink. Completeness is never claimed: a process that never calls the hook will not appear. We state this plainly rather than bury it. See the full threat model.

30-second install

Two commands.
Nothing to rewrite.

If you use Claude Code, pr guard install arms the destructive, secrets and production rule packs and wires them into its own tool hooks. No SDK, no code change. There is also an installable Claude Code plugin if you would rather not touch a settings file. For your own agents there is a Python and TypeScript SDK, with drop-in capture for the OpenAI and Anthropic clients, LangChain and MCP. A run recorded in either language produces the same bytes and verifies with the same open-source tools, and a cross-language test in CI fails the build if that ever stops being true.

uv tool install provenrail  /  npm install provenrail

Read the quickstart guide
quickstart.py
# 1. Install, and arm the guardrails (no account, nothing leaves the box)
$ uv tool install provenrail
$ pr quickstart && pr guard install

# 2. Your agent tries something destructive
> rm -rf ./src
  blocked  destructive.recursive-force-remove

# 3. The block is signed evidence. Check it yourself.
$ pr guard receipt
  1 DENIED  rm -rf ./src
$ pr verify guard-receipt.json
  RESULT: VERIFIED
How it works

Three steps. Zero trust required.

The design is simple by intention: fewer moving parts to trust means less to audit.

01Instrument

Wrap your agent loop

One with pr.record() block captures every model and tool call wherever your agent makes decisions. Each event is hashed and sequenced on the client before it leaves your process.

02Chain

Records land on an off-box rail

Each record carries a hash of the previous one, forming a chain. The sink is append-only: records cannot be deleted or reordered without breaking the chain. On Builder and higher plans, RFC 3161 timestamps from an independent authority anchor the sequence so back-dating is detectable; the Free plan hash-chains the sequence without a third-party timestamp.

03Verify

Anyone can check the proof

The open-source pr-verify tool reconstructs the chain and validates every anchor independently. Export your bundle and share it with a client, auditor, or regulator who runs the same tool; on Builder and higher a hosted read-only proof link is also available. They trust the math, not you.

Try it right here

Change one byte. Watch the proof break.

Below is a real Provenrail record, verified live in your browser. Flip a single character and the open-source verifier rejects it. This is the whole idea, and you do not have to trust us to see it.

Verifying the record...

Recomputing every hash, signature, Merkle anchor, and witness cosignature locally.

Open the full verifier

Runs entirely in your browser via the open-source verifier. Your data never leaves your device, not even to us.

See it in action

Watch it work, end to end.

Real terminal sessions, no mockups. Every command and every output below is captured verbatim from a live run.

Start here · 25s Guard a coding agent Two commands, then rm -rf and terraform destroy are blocked and the block is signed evidence.
Tutorial 01 · 16s Install, record, verify Four commands: install, pr quickstart, pr demo, pr verify.
Tutorial 02 · 20s Verify it yourself Witnessed verify, then catch a one-byte tamper with a non-zero exit code.
Tutorial 03 · 25s Plans & licensing Subscribe through Polar, get a license key, pr activate your server.
Tutorial 04 · 22s Record from code Python & TypeScript record() to pr report and a portable evidence pack.
Tutorial 05 · 31s Team & SSO Invite teammates with roles, connect your OIDC identity provider, and sign in with your IdP.

For freelancers and agencies

Deliver AI work with a
verifiable paper trail.

When you deliver an autonomous agent project to a client, billing disputes and scope-creep questions are inevitable. Provenrail gives you a verifiable record of exactly what the agent did, when, and in what order. No more "the agent went rogue" conversations.

Share a portable proof bundle your client verifies themselves, or a hosted proof link on Builder and higher.
Tamper-evident: if anything is altered after delivery, the chain breaks.
Builds repeat business. Clients who can verify the work trust the next project.
Client proof link
streamproj_acme_seo_refresh
events1,847
period2026-05-12 to 2026-05-14
chainINTACT
timestampsVERIFIED (RFC 3161)
deletionsNONE DETECTED
tools usedweb_search, file_write,
browser_navigate (49x)
model callsclaude (312x)
verified bypr-verify 1.2.0

For developers with production-access agents

When something goes wrong,
know exactly what happened.

Agents with access to money, production infrastructure, or email can cause real damage. After an incident you need a reconstruction, not speculation. Provenrail gives you a verifiable sequence of every decision the agent made, in the exact order it made them.

Post-incident reconstruction without log-tampering doubts.
Drop-in capture for OpenAI, Anthropic, LangChain and MCP.
Any other provider, framework or custom loop records with one line, to the same chain.
Incident reconstruction
seqtimeevent
109114:22:01model_call claude in=512tok
109214:22:03tool stripe.charge $340
109314:22:04tool stripe.charge $340
109414:22:04tool stripe.charge $340
109514:22:06model_call claude in=891tok
chain INTACT, timestamps VERIFIED
root cause: retry loop, no idempotency key

For teams with regulatory exposure

The technical evidence layer
for EU AI Act and HIPAA.

EU AI Act Article 12 logging requirements apply from 2027-12-02 for standalone high-risk systems, deferred from 2026-08-02 by Regulation (EU) 2026/1744. HIPAA 164.312(b) requires audit controls for systems handling protected health information. Provenrail provides an append-only, timestamped, tamper-evident event log designed to serve as technical evidence in regulatory contexts. Certification and any formal attestation remain your responsibility, and we issue neither.

Append-only log; RFC 3161 trusted timestamps on Builder and higher.
Evidence report templates mapped to EU AI Act Article 12 and HIPAA audit-control requirements.
HIPAA 164.312(b) evidence mapping; you remain the covered entity and certify compliance.
EU AI Act Art. 12 HIPAA 164.312(b)
Evidence report
regulationEU AI Act Art. 12
requirementAutomatic logging of
AI system operations
evidenceAppend-only event log
tamper proofHash chain + RFC 3161
evidence pack1-click (Team)
Attestation signed by: Your team
Evidence provided by: Provenrail
Why Provenrail

Built to be independently verified.

Most observability tools ask you to trust them. Provenrail is designed so that you do not have to.

Open-source verifier

The pr-verify tool is open-source and runs entirely offline. Any party can check the chain without contacting our servers. Trust the math, not the vendor.

RFC 3161 trusted timestamps

On Builder and higher plans, each anchor is timestamped by an external authority using the RFC 3161 standard, so the timing cannot be back-dated, even by us. The Free plan hash-chains ordering without a third-party timestamp.

Witnessed log, standards-aligned

An independent off-box receipt chain closes the single-host rewrite gap on every plan. On Builder and higher, an append-only Merkle log cosigned by independent witnesses closes the equivocation gap too, and every inclusion is emitted as an IETF SCITT (COSE) receipt any standards-aware auditor can verify.

Privacy-first by default

Default mode stores a SHA-256 hash of each prompt and response, not the raw text. Selective-disclosure redaction lets you reveal or erase sensitive fields later, without breaking the proof.

Works across every provider

Drop-in capture for the OpenAI and Anthropic clients, LangChain and MCP. Any other provider or framework, Gemini, local models, or a custom loop, records with one line, all to the same chain.

Honest about the threat model

We document exactly what Provenrail does and does not catch. Technical buyers trust specificity. We tell you what we cannot guarantee before you commit to a plan.

Two chains, not one

The agent signs and links each record; the sink independently re-chains them in arrival order. Rewrite the agent's chain and the sink's stored bytes catch it. Edit the sink's bytes and the agent's signatures catch it. Getting away with a change means breaking both at once.

Two verifiers that must agree

A Python verifier and a JavaScript one are held to 12 frozen public test vectors in CI, and every release must satisfy both. Build a third from the spec and check it against the same vectors. That is what "independently verifiable" is made of, rather than asserted.

Approvals fail closed

When a headless agent needs a human, an unanswered request, an expired link and an unreachable sink all leave the action blocked. Only a person pressing the button on the review page releases it, and that decision is signed into the same record.

Pricing

Start free. Scale when you need to.

No email gate on pricing. No hidden fees. Cancel anytime.

Free
$0
forever
  • 50k events per month (roughly 200 to 500 agent runs)
  • Single project, single user
  • Hash-chain integrity (local timestamps)
  • Open-source verifier, offline or hosted
  • Regime mapping reports via CLI (pr report), run on a bundle you export yourself
  • Self-contained evidence packs via CLI (pr pack), the same way
  • Prove a transcript is authentic (pr verify-content)
  • Community support
Get started
Team
$99/mo
billed monthly
  • 2M events per month
  • Everything in Builder
  • Up to 10 team members, roles + SSO
  • Unlimited projects
  • Data exports (NDJSON / SIEM)
  • Evidence packs mapped to EU AI Act Article 12 and HIPAA audit-control requirements, from the dashboard in one click, no export step first (the CLI versions are on every plan)
  • Priority email support
Start Team
Enterprise
Custom
volume + support
  • Unlimited events
  • Everything in Team
  • Unlimited members + SSO
  • Private / self-hosted deployment
  • Support terms by agreement
  • Dedicated support
Contact sales

Every plan includes full hash-chain integrity and the open-source verifier, identical on every tier. Paid plans add RFC 3161 trusted timestamps, shareable proof links and a live badge (Builder); then up to 10 team members with roles and SSO, data exports, and evidence packs mapped to EU AI Act Article 12 and HIPAA audit-control requirements (Team). Limits apply to the licensed build you run. We host no agent records. 14-day refund on paid plans.

Full tier comparison and pricing FAQ →

FAQ

Common questions.

A cooperative agent cannot silently alter records once they reach the sink: the hash chain makes any tampering detectable, and on Builder and higher plans RFC 3161 timestamps from an external authority prevent back-dating. However, a hostile agent that simply does not call the SDK at all will not appear in the record. Provenrail detects tampering and deletion of records that were written. It cannot force an uncooperative agent to write in the first place. This limitation is a documented part of the threat model, not fine print.
No. The verifier (pr-verify) is open-source and verifies the hash chain locally without contacting our servers. On Builder and higher plans it also checks RFC 3161 timestamps from an external time authority. You can run it yourself, or export a portable bundle and hand it to any third party who runs the open-source verifier; on Builder and higher a hosted read-only proof link is also available. You do not need to trust us or the agent; you need to trust standard cryptography and, on paid plans, the third-party time authority.
The default mode is store-hash-not-content: we record a SHA-256 hash of each prompt and response, not the raw text. The hash proves the content existed and has not changed; the raw text stays on your infrastructure. Selective-disclosure redaction lets you commit sensitive fields as salted hashes and reveal or erase them later without breaking the proof. For HIPAA-covered entities, Provenrail maps evidence to 164.312(b); you remain the covered entity and own certification.
Provenrail provides the technical evidence layer: an append-only, timestamped, tamper-evident log of AI system operations of the kind EU AI Act Article 12 calls for. Article 12 applies from 2027-12-02 for standalone Annex III high-risk systems and 2028-08-02 for Annex I embedded systems, deferred from 2026-08-02 by Regulation (EU) 2026/1744. Article 50 transparency obligations were not deferred and apply from 2026-08-02. Your team is responsible for regulatory certification. We provide the evidence; you provide the attestation. The Team plan includes one-click evidence packs designed for use with auditors and regulators.
Free: $0, 50k events/month, single project, single user, hash-chain integrity, open-source verifier. Builder: $29/month, 500k events, RFC 3161 trusted timestamps, shareable client proof links and live badge, single user. Team: $99/month, 2M events, unlimited projects, up to 10 team members with role-based access and SSO, data exports, and one-click evidence packs mapped to EU AI Act Article 12 and HIPAA audit-control requirements. Enterprise: custom pricing, unlimited members, private deployment, support terms by agreement, contact us. Limits apply to the licensed build you run; the open-source integrity guarantee is identical on every plan, and we host no agent records. All paid plans include a 14-day refund window.
Install the verifier: uv tool install provenrail (or pip install provenrail inside a virtualenv). Export your stream as a bundle, then run: pr verify bundle.json --pin pin.json. The tool recomputes the client hash chain, every Ed25519 signature, the independent server receipt chain, and every anchor locally, trusting neither the agent nor the sink. On Builder and higher plans each anchor carries an RFC 3161 trusted timestamp that the tool verifies against the external time authority. It exits 0 if intact and non-zero with a detailed error if any record is missing, reordered, altered, or back-dated. You can hand the bundle to a third party to run the verifier themselves; on Builder and higher a hosted read-only proof link is also available.