AI ships more code.
Critique makes the merge feel earned.
A GitHub-native review control plane that reads the diff, related files, and test surface before anyone has to guess where the risk lives, then hands accepted fixes to Remedy with the exact evidence attached. Try Critique Chat in the browser with no install needed.
One review surface, grounded by repo context
Pull requests, check runs, ownership context, and follow-up chat all compound into the same evidence layer.
Merge posture
Review outputs stay grounded in repo evidence, then route to the right specialist only when the diff demands it.
Repo-aware
Reads diff, related files, tests, and ownership map.
Parallel specialists
Security, billing, and performance lanes spawn only when needed.
Shared evidence board
Every agent compounds to the same investigation layer.
The browser chat for codebase questions that usually turn into detective work.
Ask the repo what changed before you read the diff.
Multi-model, repo-aware chat in the browser for the fast questions, the odd regressions, and the "what actually changed?" moments that block momentum.
Model switching
Route harder questions to a slower model without leaving the thread.
Repo context
Connect GitHub once and keep answers grounded in the real codebase.
Immediate access
Open chat in the browser first, then graduate to deeper review flows as needed.
Why now
Code generation accelerated. Review quality did not.
AI can write features, boilerplate, tests, and migrations faster than ever. But merging faster code safely requires a deeper review layer — one that understands architecture, tests, security boundaries, and downstream impact.
Not a single model pass. A coordinated review system.
The app is the control plane — policies, persistence, GitHub output. The sandbox is the execution plane — repo clone, evidence collection, optional sandbox-native final artifact.
Maps files, dependencies, tests, call sites, impact zones. Sandbox-backed analysis is attempted first; GitHub API scout is fallback.
Creates a live evidence and task layer for all agents. The app is the control plane; the sandbox is the execution and evidence plane.
Security, tests, architecture, performance, docs — each with grounded sandbox evidence.
Synthesises findings, removes noise, makes final verdict. Sandbox-native artifact used when available; backend synthesis is the fallback.
Live beta: managed execution in E2B sandboxes with guarded pushback. BYOA (external-agent handoff) is roadmap.
Agents shouldn't review in isolation.
Scout turns the PR into a shared investigation space. Tasks, evidence, context, and follow-up questions are posted to a common board so specialists can coordinate, not duplicate work. The app is the control plane — it owns policy, persistence, and GitHub publication; the sandbox execution plane handles repo inspection and can author the final review artifact.
One review system.
Multiple engineering surfaces.
From security and tests to architecture, performance, and autonomous fix — each surface is a clear module you can rely on.
Critique Chat
Try multi-model, repo-aware chat in the product — no install required to start. Connect GitHub when you want live code context and usage limits that match your plan.
Open ChatSecurity Review
Catches auth bypasses, permission gaps, secret exposure, unsafe data access, and boundary regressions.
Test Coverage Review
Finds missing tests, weakened assertions, untested pricing or billing paths, and regression risk.
Architecture Review
Flags layering violations, hidden dependency drift, incorrect abstractions, and risky structural changes.
Performance Review
Detects N+1 queries, repeated fetch patterns, wasteful loops, and scalability concerns.
Remedy
Turns findings into code changes, runs verification, and pushes fixes automatically.
Bring Your Own Agent
Send Critique's structured fix blueprint to Codex, Claude Code, Copilot, or any external agent workflow.
A simple animated line
from repo to review.
Scout takes the repo
It reads the diff, nearby files, and tests first, then decides what actually deserves deeper review.
A review UI that actually shows
how the system thinks, searches, and decides.
This example walks through the full flow: Scout reads the repo, specialists are created with named models, tool usage is exposed, and the final review stays technical enough to be acted on instead of being dismissed as generic AI commentary.
This is the real-time surface: Scout reads the repo, creates specialists only where the diff demands it, records tool usage, and waits for evidence before the lead model writes the review.
Reads the diff first, then builds the context envelope needed for specialist review.
Final synthesis blocks merge because the tenant boundary regression is externally reachable, the Stripe mutation can apply twice on retry, and the context graph builder now serializes 54 reads in the hot path.
Critique finds the issue.
Remedy proves the fix.
Instead of stopping at review comments, the platform hands accepted findings to Remedy with suspect files, the invariants that must hold, and the verification bundle required before any branch gets touched.
Critique flags that workspace authority can shift from the route param to request-body input.
The seat mutation can apply twice if the server action retries before local state catches up.
Remedy patches the code, runs lint and tests, and only then pushes the verified fix package.
Critique isolates the exact lines tied to the finding.
Remedy writes the patch in an isolated execution environment.
Verification runs before any pushback hits the branch.
Not all AI review is the same.
The difference is not whether a model can comment. It is whether the system understands the repo, coordinates evidence, and gives engineers something they can trust enough to merge or act on.
Typical AI PR reviewer
- —Reads the diff only
- —Single model output
- —Limited architectural context
- —Can comment, but not execute
- —Weak cost control
- —Little policy flexibility
Critique
- ✓Repository-aware scouting
- ✓Parallel specialist agents
- ✓Shared evidence coordination
- ✓Final lead reasoning layer
- ✓Autonomous fix or BYOA execution
- ✓Flexible model routing and credit control
Strict where it matters. Flexible where it doesn't.
- ·Require deeper review on auth or billing code
- ·Escalate security agents on protected directories
- ·Tune strictness by repo or branch
- ·Choose lead model and specialist stack (Standard & Pro: same catalog)
- ·Route routine PRs to lighter models; save frontier models for when it matters
- ·Ultra: GPT-5.2 Pro, GPT-5.4 Pro, Claude Opus 4.6, and any lead as a sub-agent
Credits follow the work — not a single flat rate.
Specialist sub-agents handle narrow inspection tasks; the lead model synthesises the verdict. Standard and Pro ship the same selectable catalog — Ultra adds GPT-5.2 Pro, GPT-5.4 Pro, and Claude Opus 4.6 — so you scale with credits instead of surprise routing.
Built for teams shipping in the age of generated code.
AI-heavy product teams
Review the flood of generated code with more than a single diff pass.
Engineering leads
Catch structural regressions, missing tests, and security drift before merge.
Startups moving fast
Add deep review without building internal agent infrastructure.
Teams with existing coding agents
Keep Codex, Claude Code, or Copilot for execution and let Critique own review quality.
Standard and Pro share one catalog; Ultra adds GPT-5.2 Pro, GPT-5.4 Pro, and Claude Opus 4.6 — or let Critique route for you.
System credibility
Built to be inspected, not merely trusted.
Repository-native, sandboxed by default, policy-aware, and explicit about the evidence behind every output.
Runs attach to pull requests, check runs, and repository context instead of forcing another review surface.
Each execution path stays contained, so investigation and remedy work happen away from your local machine.
Routing, tool access, and operational constraints stay explicit instead of being buried in a black-box prompt.
Findings, artifacts, and review traces stay inspectable, linkable, and easy to verify after the run.
Simple, transparent
pricing.
- — 500 credits / month
- — Full lead & specialist catalog (same as Pro)
- — GitHub check runs
- — Dashboard access
- — 2,000 credits / month
- — Same model catalog as Standard
- — Fix proposal agent
- — 7-day free trial
- — 10,000 credits / month
- — GPT-5.2 Pro, GPT-5.4 Pro, Claude Opus 4.6 (Ultra-only)
- — Same lead ↔ sub flexibility as Standard / Pro, plus frontier models
- — Org-wide tooling
- — Priority support
Move from AI output to merge-ready confidence.
Start reviewing before code ships.
Critique Chat is live today. GitHub App review runs, sandbox-backed analysis, and GitHub publication are already in the product. Managed Remedy is live in beta for guarded fix execution and PR pushback.
Start in the browser with repo-aware chat.
Connect GitHub when you want review runs.
Escalate to remedy flows when a fix should be proposed.