github repo · commit · pull request · pasted code

A review engine,
not a chat window.

Revisa pairs a deterministic review pipeline with LLM reasoning. Paste a GitHub URL or a snippet of code: the engine does the mechanical work, the model explains what it finds, and every finding is located, checked, and deduplicated before it reaches you.

Public repositories and pasted code. You'll sign in to start your first review.

pipeline

How a review runs

Nine steps, in order. Eight are deterministic Rust. The model is asked to do the one thing it is good at.

prepare

  1. 01

    Acquire

    Clone the repository, or accept the pasted file.

    engine
  2. 02

    Resolve

    Pin the target: repository HEAD, a commit, or the PR head against its base.

    engine
  3. 03

    Diff

    Compute what changed, or enumerate whole files when there is no diff.

    engine

select

  1. 04

    Select

    Skip vendored, generated, and secret-bearing paths, and record why for each.

    engine
  2. 05

    Match

    Choose the review rules that apply to each file.

    engine
  3. 06

    Group

    Assemble related files into units that share context.

    engine

reason

  1. 07

    Review

    An agent reads each unit with read-only repository tools and quotes evidence for every finding it reports.

    model

verify

  1. 08

    Locate

    Quoted code is matched back to an exact file and line, so findings land where they claim.

    engine
  2. 09

    Verify

    Filter, deduplicate, and drop findings that fail the check. Dropped ones stay visible.

    engine

division of labor

Mechanical work, done reliably. Reasoning, where it counts.

engineThe engine

deterministic

  • determine exactly what is being reviewed
  • calculate diffs and enumerate files
  • select relevant files and discover context
  • apply review rules
  • locate findings by their quoted code
  • filter and deduplicate findings

modelThe model

reasoning

  • understand intent
  • reason about behavior
  • identify bugs and security problems
  • spot architectural problems
  • explain why something is dangerous
  • propose fixes

Findings reach you only when both halves agree.

sandbox
Passive analyzers like Semgrep run in a network-disabled microVM, and their evidence is stored with the review.
audit
Files, lines, tokens, cost, and every dropped finding are reported on each review. Nothing is summarized away.
agents
The same reviews are reachable from a terminal, so a coding agent that wrote the code can get an independent check of its work.

cli

The same engine, from a terminal

A thin client over the same API. It submits the review, waits, and renders the findings. 

$ review https://github.com/acme/atlas/pull/42
Review completed

Files analyzed 7        Related files 3
Lines reviewed 2,184    Findings      4 kept · 1 dropped

HIGH    src/auth.ts:184    Unchecked authentication result
MEDIUM  src/cache.rs:72     Race condition during refresh
MEDIUM  src/upload.rs:41    Whole file buffered before size check
LOW     src/api.rs:91       Error context is lost

For agents, --json prints the full structured result: findings, locations, diagnostics, and stats, ready to read programmatically.

Give it a URL.

A repository, a commit, a pull request, or a snippet pasted straight in.

Start a review