PRGuard

Audit Evidence · Every plan

The AI Review You Can
Actually Verify.

Most AI code review asks for trust: a verdict appears, findings appear, and the reasoning that produced them is nowhere to be seen. When that verdict blocks a merge — or waves one through — “trust us” is not an answer an engineering leader can take to an auditor, a customer, or a sceptical developer.

PRGuard opens the box. Every audit ships with two evidence records: the Transcript — the full conversation with the AI, step by step — and the Rule trace — exactly which rules were in force and how each one was applied. Not a summary of what probably happened. The record of what did.

This Is What an Audit Carries.

The two tabs on a real audit — switch between them.

Audit · fix/payment-lookup Illustrative example
Summary
1 Gatekeeper claude-sonnet-5 · 1.8 s

Screens the change for injection attempts before any other stage reads it.

The screen found no injection attempts in this change.
2 Detect round 1 of 2 claude-sonnet-5 · 21.5 s

Scans the diff for standards violations.

Flagged 2 potential violations to verify.
PRGuard instructions (4 parts) sealed · c4d8…
Your context files · languages/python.md ↗ v4 · f59f…
Your code · payments/lookup.py ↗ not stored · 342f…
3 Detect round 2 of 2 cached claude-sonnet-5 · 1.2 s
Nothing new found — a clean round is how the detection loop knows it’s done.
4 Standards Recheck The re-check found nothing further.
5 Duplicate Check Checked the findings for duplicates.
6 Write-Up Wrote up 2 findings in full.
7 Evidence Check Checked each finding is grounded in an explicit rule.
8 Rule Coverage Accounted for 5 standard rules.
9 Summary Wrote the audit’s overall summary.

The Transcript: Read the Audit as It Happened.

Every step the AI took, in order, in plain language — with its outcome stated, not implied.

Every step, named and explained

The injection screen that checks your change before anything else reads it. The detection rounds. The standards recheck. The write-up. Each step carries a one-line description of what it does and a status of how it ended — “Flagged 3 potential violations to verify”, “Nothing new found” — so you never interpret raw output to know what happened.

Flagged 3 potential violations to verify.

The model’s own reasoning

Where the AI produced reasoning, you can read it — clearly labelled as the model’s own account, because that is what it is. Where it produced none, the transcript says so plainly — and where its reasoning would restate PRGuard’s own sealed instructions, it renders sealed instead.

AI-reported“I checked the flagged lines myself…”

Your code is never kept

Where your change was sent for review, the transcript records only the file name, size, and a fingerprint of exactly what was sent — then links to GitHub for the content, where your own repository permissions decide who may read it. Context files link to the exact version the audit used, and that link keeps working even after you edit or delete the file.

payments/lookup.py ↗·342ffedb·not stored

Sealed, but provable

PRGuard’s own instructions are its craft, so the transcript seals them — showing their size and fingerprint, proving exactly what was sent and that it never changed, without publishing the wording. The injection screen’s verdict is always shown; its inner reasoning is withheld.

sealed · c4d89498… · unchanged

The Rule Trace: Which Rules, Provably.

When an audit blocks a merge, the first question is “says who?” The Rule trace is the answer.

Your rules, in force

Which of your context files were applied to this change — with the exact version one click away — and which were set aside, with the reason in plain words: quarantined after an injection scan, superseded by a repo-level file, not relevant to the changed file types. An audit with no rules configured says exactly that, rather than staying quiet.

languages/python.md ↗repo · v4

PRGuard’s deterministic checks

Alongside your rules, PRGuard’s deterministic pre-scan runs pattern checks suited to your changed file types — and the trace records how many ran and precisely what they flagged, identified down to the exact revision of the check set.

py-sql-fstringfired on line 57

The AI’s account — cross-checked, never blurred

The trace ends with the auditor’s own rule-by-rule account of what it checked — clearly badged as the AI’s self-report and kept structurally separate from the pipeline facts above it. Every violation it claims is cross-checked against the findings actually raised: each reads either corroborated by finding or attested only. You always know which statements are record and which are the model’s word.

corroborated by findingattested only

Built for the Moment Someone Asks “Why?”

Developers

A finding you disagree with stops being an argument with a black box.

Open the transcript, read the exchange, see the rule it grounded on.

Engineering leads

Proof the standards you wrote are the standards being enforced.

Every audit shows your rules in force, at the exact version that ran.

Security & compliance

Evidence an assessor can open, not assurances they must accept.

What ran, against which rules, with fingerprints proving nothing changed.

What the Record Is — and Isn’t.

Both records are permanent. The transcript and the Rule trace are kept with the audit itself — immutable, for as long as the audit exists — because an evidence record you might delete isn’t much of a record. Both cover audits from the point the features went live on your organisation; older audits keep their reports but carry no transcript.

And the AI’s reasoning is shown for what it is: the model’s own narration, labelled as such — never presented as proof of how an answer was reached. We would rather show it honestly than hide it or oversell it.

Open the box on your next review.

Connect a repository — every audit carries its evidence from the first one.