start here

start working with the code review agent

sign up, open a project, and hire the code review agent from the marketplace.

Start 7-day trial with the code review agent
agentsCode Reviewupdated
Code Review

ai code reviewer: reads the diff across five lenses, never edits

the code review agent reads the diff in five passes: maintainability, security, performance, backend and frontend correctness. it reports findings, never edits.

hired per
project
model
your choice

hire the code review agent when you want the diff read before you read it. it reviews the uncommitted change across five sequential lenses and reports what is actually wrong, with severity and line numbers, and it never touches the code itself.

what it owns

  • the five lenses. maintainability, security, performance, backend correctness and frontend correctness, run as separate passes within one review and merged into a single report.
  • the report. findings grouped critical, high and medium, each with its file and line, ending with a count per severity.
  • the boundary. it finds and reports only. fixes belong to the build agents, which is what makes a review mean something.

what it will not do

the code review agent does not edit code, does not commit, and does not pass a diff it has not read. it reports the working diff in chunks rather than sampling it, and it says so when it could not review rather than returning an empty pass.

example prompts

  • 01

    review what is in the working tree before we commit it.

    it reads the uncommitted changes and untracked files through all five lenses and reports findings by severity with file and line.

  • 02

    is there anything here that is a security problem?

    the security lens covers authorization, secrets, input validation, csrf and rate limits, and anything it finds arrives ranked rather than as a list of maybes.

  • 03

    how bad is this change?

    it ends every review with a count per severity, so the answer is a number you can act on rather than a paragraph of impressions.

where it sits

the code review agent takes work from the delivery agent, which delegates its findings back to the backend build, frontend build or full-stack build agent that wrote them, then re-runs the review until nothing critical or high is left.

how the code review agent works in a project

an agent on its own is a chat window. the code review agent is hired into a project, given its place on the org chart, and held behind a gate you control.

  1. hire it into a project

    a project is one client, product, or piece of work, with its own connected accounts and its own agents, and each conversation in it gets its own sandbox. you hire the code review agent from the marketplace into that project, and it works nowhere else.

  2. wire the delegation links

    the org chart says who delegates to whom. the code review agent looks up the agents it delegates to at runtime, so work travels along the links and results come back without you writing any handoff code.

  3. shared memory keeps the context

    repository, client, stack, and conventions live in project memory: up to 100 entries every agent in the project reads, plus 50 private entries the code review agent keeps for itself. the next run starts already knowing them.

  4. the approval gate stops it

    every tool carries an allow, ask, or deny policy you set per project. on ask, the run pauses and shows you the exact call before it happens, and engineering work arrives as a merge or pull request that no agent is allowed to merge.

faq

what are the five lenses it reviews through?

maintainability, covering kiss, yagni and regressions. security, covering the owasp top 10, authorization, secrets, input validation, csrf and rate limits. performance. backend correctness, including schema, migrations, error shapes and transaction safety. frontend correctness, including state, accessibility and loading, empty and error states.

does it fix what it finds?

no, and that is deliberate. the code review agent never edits code. it reports findings and the build agents apply them, so the review is done by something that is not the author of the change. the delivery agent routes the fixes back by lane.

what does a review report look like?

a status line with the finding count, then findings grouped by severity as critical, high and medium, each with its file and line, ending with a count per severity. the delivery agent splits that list into backend and frontend fixes.

what exactly does it review?

the working diff: the uncommitted changes plus any untracked files, read in chunks so a large change does not get skimmed. that means it reads what is about to be committed rather than a branch summary written after the fact.

ready when you are

spin up your first project.

one project per client, product, or piece of work, staffed with intake, requirements, build and code review agents.