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

# Adversarial reviews

> Two independent reviewers from different model families review the same pull request, and Otto posts one merged review.

> [!NOTE]
>
> Adversarial reviews are in preview and are turned on per workspace. Ask us to
> enable them for yours. Until they're on, `otto.yml` settings for them are read
> and checked, and the **Otto Review** check says they didn't run.

In an adversarial review, two reviewers built on different model families review your pull request at the same time, each on its own. Otto then merges what they found into **one** review: one summary, one set of inline comments, one verdict.

Different models miss different things. Two independent reviews catch more of them than one, and where the reviewers agree you can be more confident a finding is real.

## What you see

The review looks like any other Otto review, with a few additions:

* The summary has an **Adversarial review** line saying how many findings both reviewers raised and how many only one of them did.
* Each inline finding says whether it was raised by both reviewers or by one of two. When both raised it but rated it differently (for example P1 and P3), the comment says so and keeps the more severe rating.
* When both reviewers flag the same lines but describe the issue differently, Otto posts it once and quotes the other reviewer's description under it.
* The summary shows each reviewer's own short assessment, labelled **Reviewer A** and **Reviewer B**.

How the verdict is chosen:

* **Changes requested** if either reviewer found a P0 or P1.
* **Approved** only if both reviewers would have approved on their own. Your [approval policy](https://docs.fullotto.app/configuration/approval-policy.md) still applies.
* Otherwise, the stricter of the two reviewers' own verdicts: if one would have requested changes on its own, the review requests changes; otherwise it comments.

The merge confidence is the lower of the two reviewers' scores. When their scores are far apart, the summary says so.

If one reviewer doesn't finish, Otto posts the other's review and says it is a single-model review.

## Turn it on

Adversarial reviews run on full reviews: new pull requests, new commits, and `/otto review`. Replies to comments are answered by one reviewer, as usual.

There are three modes:

| Mode | What it does |
| - | - |
| `auto` | The default once your workspace has adversarial reviews. Otto decides per pull request ([below](#when-auto-runs-one)). |
| `always` | Every full review is adversarial. |
| `off` | Never for this repository. |

For the whole repository:

```yaml otto.yml theme={null}
version: 1
reviews:
  adversarial: always # or auto, or off
```

For specific paths only:

```yaml otto.yml theme={null}
version: 1
reviews:
  adversarial: off
  paths:
    - match: ['src/payments/**', 'src/auth/**']
      adversarial: always
    - match: ['src/api/**']
      adversarial: auto
```

A path rule can also say `never`: files it matches never trigger an adversarial review.

## Choose the reviewers

By default Otto picks a pair of reviewers from different model families for the pull request's [review depth](https://docs.fullotto.app/configuration/review-depth.md). To choose your own, list exactly two models. Use any model id [OpenRouter](https://openrouter.ai/models) serves with tool use and reasoning, or one of the short names below:

```yaml otto.yml theme={null}
version: 1
reviews:
  adversarial:
    mode: always
    reviewers:
      - model: anthropic/claude-opus-5.5
      - model: gpt-6.1-sol
        effort: high # optional: low, medium or high
```

Short names: `claude-opus-5.5`, `claude-sonnet-5.5`, `claude-fable-5.1`, `gpt-6.1-sol`, `gpt-6-luna`, `gpt-6-astra`.

You can set a pair for a path too. Otto uses the first path rule in the file that sets `reviewers` and matches a changed file. If none does, it uses the repository's `reviewers`, else its own pair.

You're billed for both reviewers at each model's actual usage, as with any review. If a model you name isn't available, Otto uses its own pair for that review and lists the problem on the **Otto Review** check.

## When `auto` runs one

In `auto` mode, Otto checks four things before the review starts. If any is true, the review is adversarial:

| Check | True when |
| - | - |
| `risky_change` | The change is risky: for example a design document, a migration together with code, several risk areas at once, or recent defects nearby. |
| `many_consumers` | A function, class or type the PR changes is used by at least `min_consumers` files the PR doesn't touch. |
| `breaking_contract` | The PR changes or removes a definition that files it doesn't touch still use, or ships a migration with code. |
| `security_risk` | The PR touches authentication, permissions, secrets or webhooks, its description names a security risk, or it adds an endpoint, removes a guard, builds SQL from strings, runs a process, or changes cookie, CORS or session settings. |

Tune them in `otto.yml`:

```yaml otto.yml theme={null}
version: 1
reviews:
  adversarial:
    mode: auto
    gate:
      many_consumers: { min_consumers: 5 } # default 10
      breaking_contract: false # don't use this check
  paths:
    - match: ['test/**', 'fixtures/**']
      adversarial:
        gate:
          security_risk: false # test code doesn't trigger the security check
    - match: ['libs/**']
      adversarial:
        gate:
          many_consumers: { min_consumers: 3 }
```

A path rule can turn a check off for its files or lower `min_consumers`. When rules disagree, the one asking for more scrutiny wins: a check the repository or another matching rule turns on stays on.

### Model-assisted gate

In workspaces where it's turned on, a small classification model also answers `risky_change`, `breaking_contract` and `security_risk`. It reads only the pull request's metadata: changed file paths, sizes and risk areas, the names of changed definitions and how many files use them, and the title and description with code removed. It never sees your code or the diff.

* It can turn on a check that Otto's own signals left off, once its probability reaches the check's `threshold`.
* It can turn off a `risky_change` or `breaking_contract` check only when it is very sure, and only if the check rests on soft signals. It never turns off a design document, a migration with code, a path `otto.yml` reviews at Deep or Max, a removed definition still in use, an open blocking finding, or anything `security_risk` found.
* If it's slow or unavailable, Otto's own signals decide.

`many_consumers` is always the count.

```yaml otto.yml theme={null}
version: 1
reviews:
  adversarial:
    gate:
      security_risk: { threshold: 0.3 } # default 0.4; risky_change and breaking_contract default 0.6
```

`threshold` is set for the whole repository only, not in `paths`.

#### With the change profile

In workspaces with the [change profile](https://docs.fullotto.app/reviews/change-profile.md) on, the gate reads the profile instead of asking these questions separately:

| Check | Turned on when |
| - | - |
| `risky_change` | The profile is at least 90% sure the change is high risk |
| `breaking_contract` | The profile is at least 90% sure the change affects code other files rely on |
| `security_risk` | The profile is at least 60% sure the change carries a security risk |

A `threshold` above those minimums still applies. A lower one has no effect: the profile is broader than the old per-check questions and would otherwise fire on most pull requests.

Everything else above holds:

* the same signals can never be turned off;
* a check fired on soft signals is turned off only when the profile is very sure;
* `security_risk` only ever adds;
* a check that a `paths` rule limits to some files uses Otto's own signals, because the profile classifies the whole pull request.

## How Otto picks the mode

**1. Each changed file gets a mode**

The path rules that match the file: `always` beats `auto` beats `never`. If
no rule sets one, `reviews.adversarial`, else your workspace's default
(`auto`).

**2. The pull request takes the strongest**

`always` if any file is `always`. Otherwise `auto` if any file is `auto`,
and then Otto's checks look only at those files. Otherwise no adversarial
review. [Ignored files](https://docs.fullotto.app/configuration/ignoring-files.md) never count.

## When it stays a single review

Even when `otto.yml` asks for one, a review stays single, and the **Otto Review** check says why, when:

* your workspace's credit balance is low and auto-refill is off: an adversarial review costs about both reviewers' costs together
* Otto is already running the most adversarial reviews it allows at once, for your workspace or overall
* your workspace has a fixed review model set by Otto's team

## Reference

| Field | Type | Default | Description |
| - | - | - | - |
| `reviews.adversarial` | string or map | *(workspace)* | `auto`, `always`, `off`, `true` (auto) or `false` (off), or a map with the fields below. |
| `reviews.adversarial.mode` | string | `auto` | `auto`, `always` or `off`. |
| `reviews.adversarial.reviewers` | list | *(Otto's pair)* | Exactly two reviewers, each a model name or `{ model, effort }`. |
| `reviews.adversarial.gate.<check>` | map or boolean | on | `false` (or `{ enabled: false }`) turns a check off. |
| `reviews.adversarial.gate.many_consumers.min_consumers` | integer | `10` | Files outside the PR that make a definition widely used (1-1000). |
| `reviews.adversarial.gate.<check>.threshold` | number | `0.6` / `0.4` | [Model-assisted gate](#model-assisted-gate) only: the probability (0-1) at which it turns the check on. `0.4` for `security_risk`. Not for `many_consumers`; not in `paths`. |
| `reviews.paths[].adversarial` | string or map | *(none)* | `never`, `auto`, `always`, or a map with `mode`, `reviewers` and `gate`. |

Problems with these settings never stop a review. Otto ignores the invalid part, uses its defaults, and lists the problem on the **Otto Review** check. An invalid `reviewers` list is ignored as a whole, and Otto's pair runs.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.