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

# Proof of Changes

> Have an agent exercise every pull request on a live device and report back before a human reviews it

Every time someone opens a pull request (PR), Revyl can install that PR's
build on a live device, run through the changed flows, and post a verdict —
ready, failed, or inconclusive — on the PR. Reviewers get a live look at
whether the change actually works before they read a line of code.

## What You'll See

Once it's on, every PR with a build gets one comment that updates as new
commits land (or, if you've configured it that way, the same block on the
PR description instead). It includes:

* A verdict per build target — **Ready**, **Ready with polish**, **Ready with issues**, **Failed**, or **Inconclusive**
  * **Ready**: The agent exercised the change on a device and found no open findings.
  * **Ready with polish**: The change works, with a low-severity polish finding to consider.
  * **Ready with issues**: The change works well enough to review, with a non-blocking issue to inspect.
  * **Failed**: The agent found an open blocker.
  * **Inconclusive**: Nothing useful was observed — for example the device never started, or setup blocked the run before the change could be exercised.
* A short write-up of what was exercised and what the app did
* A **Verification confidence** score from **1/5** to **5/5**, measuring how much of the changed behavior the agent exercised directly. Defects never lower the score — they land in the findings section instead.
* Screenshots of the moments that matter
* A link to the full session recording — no login required
* A **View proof logs** link, so you can watch the device live while the
  run is in progress and review its proof write-up in Revyl afterwards.
  The **Proof** section below **Run logs** shows the write-up, captioned
  screenshots, and report links on the same page. Select a screenshot to
  view it full size. The section updates when the run's write-up is available.
* A findings section. Successful runs with no findings say so explicitly and
  still link to Atlas scoped to the exercised build; confirmed problems link
  their screenshot-grounded annotation threads.

## Find Your Proof Runs

Open **Cloud Agents → Proof of Changes** to browse your organization's proof
history. The list includes both Revyl and Cursor runs, with the pull request,
tested commit, app/platform, and proof status. Open a run to view its existing
proof details; Cursor runs also offer **Open in Cursor** when the agent link is
available. Proof history requires Member access or higher. Inside an app, its
**Cloud Agents** page has the same **Proof of Changes** tab, limited to that
app's runs.

Open **Filters** on the right, then use **All repositories** to search repositories
with recorded proof runs and select one. Use **Load more** when additional
repositories are available. Historical repositories remain selectable even when
the GitHub integration is disconnected. The filter applies to the full proof
history, not just the visible page. In the same menu, use **Proofs per page**
to choose 10, 25, 50, or 100 results. Changing either control returns to the
first page. Select **All repositories** again, remove the repository chip under the
toolbar, or choose **Clear all** in the menu to clear the filter.
Page controls appear below the results when you scroll to the bottom.
From proof details, **Cloud Agents** in the header returns to Proof of Changes.
When the run's app is known, the header and sidebar switch to that app instead,
and **Cloud Agents** returns to that app's Proof of Changes tab.

Cloud Agents still opens on **Agents** by default. Selecting Proof of Changes
doesn't change your agent filters or start a new run.

## Getting Started

1. Connect your repo via the [Revyl GitHub App](/integrations/github)
2. Turn on Proof of Changes through the dashboard or enable
   `pr_review.proof_of_changes` in the project's `.revyl/config.yaml`:

```yaml theme={null}
pr_review:
  enabled: true
  build:
    kind: revyl
    profile: pull-request
  proof_of_changes:
    enabled: true
    harness:
      kind: revyl
```

The named profile must exist under `build.profiles`.

On your next pull request, Proof of Changes runs automatically.

The Revyl agent uses a bounded excerpt of the author-written portion of the
pull request description as supporting context for the change's intent,
expected behavior, and proposed test plan. The diff and your configured
`always_verify` checks remain authoritative.

If you cannot install the [Revyl GitHub App](/integrations/github) or you use a different SCM, you can use the Proof of Changes via Cursor Cloud guide to set up Proof of Changes without the App.

## Authentication and Session Prep

We recommend [bypassing authentication](/builds/auth-bypass-deeplinks) so
each run starts from a signed-in state. Set this up with the
[`session.auth_bypass`](/cli/device/auth-and-session-prep) field in your config.

To run a script before the device session starts — for example, seeding test
data — use the [`session.before_script`](/cli/device/auth-and-session-prep) field.

## Network Allowlisting

If your services restrict access by source IP, allow the following outbound
address for the Revyl proof agent (`harness.kind: revyl`):

| Source | IPv4 address | CIDR allowlist entry |
| - | - | - |
| Revyl proof sandbox | `52.8.130.100` | `52.8.130.100/32` |

This covers requests originating from the proof sandbox, including API calls
made by session-preparation scripts running there. The address is shared across
Revyl proof sandboxes, not dedicated to your organization. Keep your service's
normal authentication and authorization requirements in place.

<Note>
  Requests made by your app on an iOS or Android device originate from the
  device infrastructure, not the proof sandbox. This address does not cover
  device traffic, remote build runners, or Cursor Cloud Agents. Contact Revyl
  for the network requirements of those environments.
</Note>

## Advanced Configuration

You can set additional configuration parameters from the PR-review settings
dashboard, or under `pr_review.proof_of_changes` in `.revyl/config.yaml`.

By default, proof runs execute on the Revyl agent. To follow a run as a
Cursor Cloud Agent thread instead, connect a
[Cursor Cloud integration](/integrations/cursor/cloud-agents) and set
`harness.kind` to `cursor`. After publishing or committing that policy, run
`revyl config authorize-cursor-proof`.

| Field | Role |
| - | - |
| `enabled` | Turn proof runs on or off. |
| `harness.kind` | Which agent runs proofs: `revyl` (default) or `cursor`. |
| `harness.model_id` | Optional model for Cursor proof runs. |
| `always_verify` | Natural-language invariants verified on every run in addition to the diff. |
| `system_prompt` | Extra guidance prepended to proof runs. |

See the full `pr_review` field reference on the
[GitHub integration](/integrations/github#review-policy-fields) page.


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