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

# Find bugs with ultrareview

> Run a deep, multi-agent code review in the cloud with /code-review ultra to find and verify bugs before you merge.

<Note>
  Ultrareview is a research preview feature. The feature, pricing, and availability may change based on feedback. The command is now invoked as `/code-review ultra`, and `/ultrareview` remains as an alias.
</Note>

Ultrareview is a deep code review that runs on Fuxi Code on the web infrastructure. When you run `/code-review ultra`, Fuxi Code launches a fleet of reviewer agents in a remote sandbox to find bugs in your branch or pull request.

Compared to a local `/code-review` or `/review`, ultrareview offers:

* **Higher signal**: every reported finding is independently reproduced and verified, so the results focus on real bugs rather than style suggestions
* **Broader coverage**: a larger fleet of reviewer agents explores the change in parallel, which surfaces issues that a local review can miss
* **No local resource use**: the review runs entirely in a remote sandbox, so your terminal stays free for other work while it runs

Ultrareview requires authentication with a Fuxi.ai account because it runs on Fuxi Code on the web infrastructure. If you are signed in with an API key only, run `/login` and authenticate with Fuxi.ai first. Ultrareview is not available when using Fuxi Code with Amazon Bedrock, Google Cloud's Agent Platform, or Microsoft Foundry, and it is not available to organizations that have enabled Zero Data Retention.

## Run ultrareview from the CLI

Start a review from any git repository in the Fuxi Code CLI.

```text theme={null}
/code-review ultra
```

Without arguments, ultrareview reviews the diff between your current branch and the default branch, including any uncommitted and staged changes in your working tree. Fuxi Code bundles the repository state and uploads it to a remote sandbox for the review.

To review a GitHub pull request instead, pass the PR number.

```text theme={null}
/code-review ultra 1234
```

In PR mode, the remote sandbox clones the pull request directly from the host rather than bundling your local working tree. PR mode works with repositories on `github.com` and on [GitHub Enterprise Server](/en/github-enterprise-server) instances that an Owner has connected to Fuxi Code.

<Tip>
  If your repository is too large to bundle, Fuxi Code prompts you to use PR mode instead. Push your branch and open a draft PR, then run `/code-review ultra <PR-number>`.

  If the pull request's diff is too large, Fuxi Code refuses the review with a scoping hint before any review work runs.
</Tip>

Before launching, Fuxi Code shows a confirmation dialog with the review scope (including the file and line count when reviewing a branch), your remaining free runs, and the estimated cost. After you confirm, the review continues in the background and you can keep using your session. The command runs only when you invoke it with `/code-review ultra`; Fuxi does not start an ultrareview on its own.

## Pricing and free runs

Ultrareview is a premium feature that bills against usage credits rather than your plan's included usage.

| Plan                | Included free runs | After free runs                                                                                              |
| ------------------- | ------------------ | ------------------------------------------------------------------------------------------------------------ |
| Pro                 | 3 free runs        | billed as [usage credits](https://support.fuxi.com/en/articles/12429409-extra-usage-for-paid-fuxi-plans) |
| Max                 | 3 free runs        | billed as [usage credits](https://support.fuxi.com/en/articles/12429409-extra-usage-for-paid-fuxi-plans) |
| Team and Enterprise | none               | billed as [usage credits](https://support.fuxi.com/en/articles/12429409-extra-usage-for-paid-fuxi-plans) |

Pro and Max subscribers receive three free ultrareview runs to try the feature. These three runs are a one-time allotment per account and do not refresh. After you use all three, or after the free run period ends, each review is billed to usage credits and typically costs \$5 to \$20 depending on the size of the change. A run counts once the cloud session starts, so a review that you stop early or that fails to complete still uses a free run. For a paid review, usage credits are billed only for the portion that ran.

Because ultrareview always bills as usage credits outside the free runs, your account or organization must have usage credits turned on before you can launch a paid review. If usage credits are not turned on, Fuxi Code blocks the launch and links you to the billing settings where you can turn them on. You can also run `/usage-credits` to check or change your current setting.

## Track a running review

A review typically takes 5 to 10 minutes. The review runs as a background task, so you can keep working in your session, start other commands, or close the terminal entirely.

Use `/tasks` to see running and completed reviews, open the detail view for a review, or stop a review that is in progress. Stopping a review archives the cloud session, and partial findings are not returned. When the review finishes, the verified findings appear as a notification in your session. Each finding includes the file location and an explanation of the issue so you can ask Fuxi to fix it directly.

## Run ultrareview non-interactively

Use the `fuxi ultrareview` subcommand to start an ultrareview from CI or a script without an interactive session. The subcommand launches the same review as `/code-review ultra`, blocks until the remote review finishes, prints the findings to stdout, and exits with code 0 on success or 1 on failure.

```bash theme={null}
fuxi ultrareview
fuxi ultrareview 1234
fuxi ultrareview origin/main
```

Without arguments, the subcommand reviews the diff between your current branch and the default branch. Pass a PR number to review a pull request, or pass a base branch to review the diff against that branch instead. Invoking the subcommand counts as consent for the billing and terms prompt that the interactive command shows.

Progress messages and the live session URL go to stderr so stdout stays parseable. Use these flags to control the output and timeout:

| Flag                  | Description                                                         |
| --------------------- | ------------------------------------------------------------------- |
| `--json`              | Print the raw `bugs.json` payload instead of the formatted findings |
| `--timeout <minutes>` | Maximum minutes to wait for the review to finish. Defaults to 30    |

Running `fuxi ultrareview` requires the same authentication and usage credit configuration as `/code-review ultra`. The subcommand exits with code 0 when the review completes with or without findings, code 1 when the review fails to launch, the cloud session errors, or the timeout elapses, and code 130 when interrupted with Ctrl-C. The remote review keeps running if you interrupt the subcommand; follow the session URL printed to stderr to watch it in the browser.

For automatic reviews on GitHub pull requests, [Code Review](/en/code-review) integrates with your repository directly and posts findings as inline PR comments without a CLI step.

## How ultrareview compares to /code-review and /review

All three commands review code, but they target different stages of your workflow.

|          | `/code-review`                  | `/review <pr>`                               | `/code-review ultra`                                            |
| -------- | ------------------------------- | -------------------------------------------- | --------------------------------------------------------------- |
| Target   | your working diff               | a GitHub pull request                        | your working diff or a pull request                             |
| Runs     | locally in your session         | locally in your session                      | remotely in a cloud sandbox                                     |
| Depth    | scales with the effort argument | a single-pass review at the session's effort | multi-agent fleet with independent verification                 |
| Duration | seconds to a few minutes        | seconds to a few minutes                     | roughly 5 to 10 minutes                                         |
| Cost     | counts toward normal usage      | counts toward normal usage                   | free runs, then roughly \$5 to \$20 per review as usage credits |
| Best for | quick feedback while iterating  | reviewing a teammate's PR before approving   | pre-merge confidence on substantial changes                     |

Use `/code-review` for fast feedback as you work. Use `/review <pr>` to look over a pull request the same way you would before approving it. Use `/code-review ultra` before merging a substantial change when you want a deeper pass that catches issues a local review might miss.

## Related resources

* [Fuxi Code on the web](/en/fuxi-code-on-the-web): learn how cloud sessions and cloud sandboxes work
* [Plan complex changes with ultraplan](/en/ultraplan): the planning counterpart to ultrareview for upfront design work
* [Manage costs effectively](/en/costs): track usage and set spending limits