What's New

An AI review is only worth as much as your ability to check it. Every audit now has two new tabs that open the box completely: the Transcript shows the full conversation behind your audit, and the Rule trace shows which rules were in force and how each one was applied.

The Transcript — read the audit as it happened. Every step, in order, in plain English: the injection screen that checks your change before anything else reads it, the detection rounds, the standards recheck, the write-up, the final summary. Each step says what it did and how it ended — "Flagged 3 potential violations to verify", "Nothing new found", "The screen found no injection attempts" — so you never have to interpret raw output to know what happened. Where the AI produced reasoning, you can read it; where it didn't, the transcript says so plainly.

Your code is never kept. Where your change or a file was sent for review, the transcript records only the file name, its size, and a fingerprint of exactly what was sent — then links out to GitHub for the content itself, where your own repository permissions decide who may read it. Your context files go one better: each one links to the exact version the audit used, and that link keeps working even if you've edited or deleted the file since.

The Rule trace — which rules, provably. It opens with your own context files: which were in force (with the exact version, one click away), and which were set aside — with the reason in plain words, like "quarantined — injection risk" or "superseded by repo-level file". Then PRGuard's own automatic checks: how many ran against your change and what they flagged. And finally the auditor's own rule-by-rule account — clearly marked as the AI's self-report and cross-checked against the findings actually raised, so every claim reads either "corroborated by finding" or "attested only". You always know which statements are pipeline fact and which are the model's word.

Our instructions stay ours — verifiably. The prompts PRGuard writes are its craft, so the transcript seals them: you see their size and fingerprint, proving exactly what was sent and that it never changed, without the wording itself. The same goes for the injection screen's inner workings — its verdict is always shown; its detailed reasoning is withheld so the screen stays hard for an attacker to probe.

Both tabs are live today on every plan, on every audit from here forward. Open any audit from Governance → Audit log and look for Transcript and Rule trace next to the summary.

To catch as much as possible, PRGuard doesn't read your change once — it reviews it several times over, because a second and third look reliably find things a single pass misses. Until now, every one of those passes paid full price to re-read the same material: your change, your standards, the pre-scan results.

Now the repeat passes reuse what's already been read. The first pass pays once; the follow-up passes re-read the same material at a fraction of the price. On a large pull request reviewed across several passes, that cuts the review's reading cost by roughly half to two-thirds — and the bigger the change, the bigger the saving.

Nothing about the review itself changes. Every pass still takes a genuinely fresh look at your code and finds exactly what it would have found before. The only thing that's gone is paying repeatedly for the same reading.

And you can see it working. Open any audit's Transcript tab: passes that reused earlier reading carry a "cached" marker, so the saving shows up on the same record as everything else about your audit.

Every audit PRGuard runs leaves a record: what changed, who shipped it, what was flagged, and what happened to each finding afterwards. Insights, new today, makes that history conversational — ask a question in plain language and get an answer grounded in your audit trail, with a citation for every claim.

Ask the question a dashboard can't answer. "What changed in the payments module in the last 30 days?" "Who has been changing our auth code, and what did the audits flag?" "Which findings from last month are still unfixed?" One question replaces a Slack interruption, a trawl through pull requests, and an afternoon of git archaeology — and any member of your organisation can ask, project managers very much included.

Grounded by construction, not by promise. Insights is not a chatbot with opinions. Answers are assembled from a narrow set of read-only queries over your own organisation's audit records — the AI chooses search filters, and it never sees anything beyond what those organisation-scoped queries return. Every claim cites the audit it came from, each citation links straight to the full record, and citations are validated server-side: a reference that doesn't match an audit actually retrieved for that answer is stripped.

Flagged is not the same as fixed. Every finding carries its lifecycle — open, in progress, fixed, or dismissed — so answers distinguish "was flagged in review" from "is still a problem today". That difference is usually the whole point of asking before a release goes out.

Honest about coverage. Answers draw only on what PRGuard has audited on your connected repositories. If your question reaches beyond the audit record — an uncovered window, an unconnected branch — the answer says so rather than guessing.

You'll find Insights in your dashboard sidebar, included with the Pro, Pro Team and Enterprise plans — and included in the trial, so you can try it before choosing a plan. Questions are metered as AI credits like any other PRGuard call, with daily per-member and per-organisation allowances to keep usage predictable. Ask your first question — your audit history already knows the answer.

Until now, the first sign that your organisation had run out of audit credits was an audit that didn't run. That's the wrong moment to find out — so credit depletion now announces itself ahead of time, and stops repeating itself afterwards.

A warning while there's still time to act. When a debit takes your balance below 15% of your monthly plan allowance, owners and admins get one email — audits are still running, here's where the balance stands, here's the top-up page. It fires on the crossing, not on every call afterwards, so a draining balance doesn't become a draining inbox. Top up past the line and the warning resets for next time.

A clear notice the moment audits pause. If the balance falls below the minimum needed to start an audit, a second email says exactly that: reviews on new pull requests and pushes are paused, each affected commit shows an "insufficient credits" commit status on GitHub, and auditing resumes automatically as soon as credits are available — by top-up or at your next cycle reset.

One email, not one per push. Previously, every audit blocked by an empty balance emailed every owner and admin — an active repo could turn a quiet billing state into a stream of identical messages. Blocked-audit emails are now throttled to one per organisation every six hours, and topping up (or a plan renewal, upgrade, or gifted credits) resets the throttle immediately so a fresh depletion is never silently swallowed.

The billing page tells the same story. When your balance is low or exhausted, the billing screen now opens with a banner stating exactly where you stand — amber while audits still run, red once they're paused — with a one-click jump to the top-up section. The email links land on that same spot, and the "Credits Remaining" figure changes colour to match. Same thresholds everywhere: email, GitHub commit status, and billing page never disagree.

Two upgrades this week, both aimed at the question an auditor will actually ask you: not "did you review this change?" but "prove it, and prove the record hasn't been touched since."

Append-only, all the way down. Every decision made about a finding — a status change, an auto-fix outcome, a retraction — now writes an entry in an append-only journal: who made the change, what it changed from and to, and when. Journal entries can never be edited or deleted, by anyone, including us.

Findings resolve to the exact rule that raised them. Context files now keep full version history — every edit preserves the previous text, who changed it, and when. Each audit records the precise version of every rule it ran against, so a finding from last quarter still shows the rule text as it stood at the time, even if the rule has been rewritten since. Each record also carries the audit engine's prompt version, so you can always tell which generation of the reviewer produced a finding.

See every change to a rule — and roll one back. Open any context file in Context Studio and click History for a complete timeline: each version, who changed it and when, and a line-by-line diff of exactly what changed — with the full text of any past version one click away. Need to undo an edit? Restore any previous version in a click; it’s saved as a new version, so nothing in the history is ever lost. The record is append-only — the same evidence an assessor would ask for: what the rule said, and when.

PR-only fix delivery, enforced org-wide. Auto-fixes have always landed as a reviewable pull request by default, with direct commit as a per-fix choice. Organisations that want the human-review step to be a guarantee rather than a default can now enforce it: with the policy enabled, every AI fix lands as a pull request — the direct-commit option disappears from every dispatch, anything that slips through is converted to a PR before it touches GitHub, and each conversion is logged. A control your auditor can rely on, not a preference they have to verify per commit.

As always, no action is needed — the evidence guarantees apply to every audit from today. The PR-only policy can be switched on — or off — by any organisation owner or admin from the Organisation page, and every change to it — who, when, and in which direction — is recorded in your activity log.

Two engine upgrades this week, both focused on making every audit sharper and more dependable.

Deterministic pre-scan, verified by AI. Every audit now opens with a deterministic security scanner that checks the changed lines for high-risk patterns — SQL built by string concatenation, shell commands assembled from user input, disabled TLS verification, unsafe deserialisation, hardcoded cloud keys and tokens, committed private keys, and more. Each hit is passed to the AI auditor for verification in full context: genuine problems land in your review with the usual plain-language explanation, while pattern-level false positives are filtered out before they reach you. The result is the precision and repeatability of pattern matching combined with the judgment of the AI review — in a single audit, at no extra credit cost. The scan runs on our workers, adds no LLM calls, and if it is ever unavailable, your audit simply proceeds as before.

Full provider failover. When an LLM provider suffers an outage, PRGuard already failed the main audit over to your fallback provider. Now the supporting calls — finding deduplication, detailed write-ups, and summaries — fail over too, so a mid-audit outage no longer degrades your report to terse one-liners. A transient malformed response from a provider is retried rather than downgrading the audit, and billing always attributes each call to the provider that actually served it.

As always, no action is needed — every improvement is live on your next push.

Today PRGuard goes public. Connect your GitHub organisation and every pull request and push is automatically audited against your own governance rules before it merges — no extra steps in your workflow.

What you get from day one:

• Automated PR & push audits. A GitHub App installation is all it takes. PRGuard fetches the diff, evaluates it against your Context Files, and posts its findings straight back to GitHub as a review.
• Prompt-injection screening. Every audit is pre-screened by a lightweight gatekeeper before the main review runs, so malicious diffs can't hijack the audit.
• Choose your own model. Pick between Google Gemini and Anthropic Claude for your audits.
• Context Studio. Write your coding standards, security policies, and compliance rules as Markdown and inject them into every audit.
• Credit-based, usage-linked billing. Pay for the audits you run — plan credits each cycle, with top-ups that roll over.
• Findings as tasks. Assign findings to teammates and track them to resolution from your dashboard.

This dev log is where we'll post everything new from here on. Thanks for being here at the start.