> ## Documentation Index
> Fetch the complete documentation index at: https://docs.komodor.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Code Reviewer

> Reviews every pull request from its diff and reports Blocking, Should-fix and Nit findings, each citing a file, a line and a consequence.

Deploy this agent to put a consistent review on every pull request before a human reads it. It works
from the diff, sorts what it finds by whether it should stop the merge, and posts a comment per
commit so each push is reviewed visibly. This page covers what it needs, how it is triggered, and
where it stops.

## What it does

On each push to a pull request, it reads the diff and reports what a maintainer needs to know before
merging. Findings come back in three buckets, and each one names a file, a line, and the concrete
consequence rather than a style preference:

| Bucket     | What belongs in it                                |
| ---------- | ------------------------------------------------- |
| Blocking   | Something that should stop the merge              |
| Should-fix | Worth fixing, but not a reason to hold the change |
| Nit        | Minor, and explicitly optional                    |

It comments once per commit rather than amending a single review, so the history of what was flagged
and when stays readable on the pull request itself.

### The verdict

The worst finding in the review decides the verdict, and the agent does not get to choose it — the
buckets are what it produces, and the verdict follows from them:

| Worst finding         | Verdict           | The comment reads                     |
| --------------------- | ----------------- | ------------------------------------- |
| A Blocking finding    | Changes requested | **Code Reviewer — Changes requested** |
| A Should-fix finding  | Comment           | **Code Reviewer — Comments**          |
| Only Nits, or nothing | Approve           | **Code Reviewer — Looks good**        |

Finding nothing is a valid and common result. The review says so rather than padding itself with
observations to look thorough.

## What a review looks like

A comment with one Blocking and one Nit finding:

```markdown theme={null}
### Code Reviewer — Changes requested

Adds retry handling to the payment webhook consumer. One correctness issue in the
retry path, and a naming nit.

**Blocking**
- `consumers/webhook.py:88` Retry loop re-sends before the idempotency key is
  refreshed — a duplicate charge on the second attempt.

**Nit**
- `consumers/webhook.py:12` `n` reads better as `attempt`.
```

With nothing to report, the body is the summary followed by `No blocking or should-fix findings.`

## What it reads

| Source                | What it uses it for                            |
| --------------------- | ---------------------------------------------- |
| The pull request diff | The whole basis of the review                  |
| Repository metadata   | Locating the file and line a finding refers to |

It reviews against its own rubric. There is no policy file to write and no repository convention to
configure — which is the trade: consistent reviews everywhere, rather than reviews tuned per
repository.

## Before you deploy

| Requirement       | Detail                                                                     | Where to set it up                                                       |
| ----------------- | -------------------------------------------------------------------------- | ------------------------------------------------------------------------ |
| Model access      | The managed model gateway, or your own Claude API key                      | [Credentials & secrets](/manage-your-agents/build/credentials-secrets)   |
| GitHub connection | Read access to the pull request, and permission to post the review comment | [Built-in integrations](/manage-your-agents/build/built-in-integrations) |

The GitHub connection is required and gates the only path this agent has to GitHub. Without one it
cannot read the pull request at all: it fails closed and returns a verdict saying so, rather than
reviewing blind.

<Note>
  This agent is enabled per workspace. If it is not in your catalog, an account administrator can
  request it for your account.
</Note>

## How it is triggered

This is the one catalog agent you do not give a schedule. It is driven by the repositories bound to
the review workflow, so a pull request arriving is what starts a run — there is no cron trigger to
set in the wizard, and the **Triggers** step has nothing to collect.

## Defaults and limits

|             |                                                         |
| ----------- | ------------------------------------------------------- |
| Catalog ID  | `code-reviewer`                                         |
| Model       | `claude-sonnet-5`                                       |
| Time budget | 600 seconds, adjustable 60–1800 per run                 |
| Deployment  | Komodor cloud                                           |
| Chat        | No — it reviews a diff, it does not hold a conversation |

The time budget degrades rather than fails: past it, the agent reports the findings it already has
rather than abandoning the review.

## In a workflow

It is the review step itself rather than a specialist another agent delegates to. A pull request
opens or is pushed to, the step runs, and the comment lands on the pull request — the workflow's
output is visible in GitHub rather than only in the console.

## What it will not do

It never casts a GitHub approval. Its verdict is reported in its own comment — "Looks good" is a
verdict, not an approving review — so it cannot satisfy a branch-protection rule that requires one,
and it never merges. A maintainer still reviews and merges.

Posting that comment is the only thing it writes. It does not push, branch, or change a file.

<Note>
  A review the clock stopped never comes back as approve. Where the time budget cut a review short, an
  otherwise-empty result is downgraded to Comment and says plainly that it is incomplete — so "no
  findings" from a partial review cannot be mistaken for "nothing wrong".
</Note>

It also reviews only what the diff shows. A change that is wrong because of something in a file it
did not touch is outside what the review can see — the review is a filter in front of a human, not a
replacement for one.

## Next steps

<CardGroup cols={2}>
  <Card title="GitHub Agent" href="/manage-your-agents/build/catalog/github-agent">
    The same repositories, read to find the code behind an incident.
  </Card>

  <Card title="Built-in integrations" href="/manage-your-agents/build/built-in-integrations">
    Create the GitHub connection this agent needs.
  </Card>

  <Card title="Runs & evidence" href="/manage-your-agents/run/runs-evidence">
    Read the reasoning behind a finding.
  </Card>

  <Card title="Agent catalog" href="/manage-your-agents/build/catalog/overview">
    Every catalog agent, side by side.
  </Card>
</CardGroup>


## Related topics

- [Agent catalog](/manage-your-agents/build/catalog/overview.md)
- [GitHub Agent](/manage-your-agents/build/catalog/github-agent.md)
- [Remediation Executor](/manage-your-agents/build/catalog/remediation-executor.md)
- [Evaluations](/manage-your-agents/optimize/evaluations.md)
- [Admin Console](/security-and-governance/controls/admin-console.md)
