> ## 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.

# Use Cursor Cloud Agents to verify your Apps

> Connect Revyl and Cursor end to end, so pull requests get proven automatically and Cursor Agents can verify their own changes

Revyl verifies code changes in two ways: the [Cursor Plugin](/integrations/cursor/plugin) lets a Cursor Cloud Agent drive a live Revyl device to iterate on code changes, and the [Cursor Cloud Integration](/integrations/cursor/cloud-agents) uses the Cursor Cloud Agent harness to review a pull request and provide evidence that the change does what it claims to do. Using both together gives you a full verification loop.

<Note>To iterate live on code changes with the Cursor Plugin, it is recommended to use **React Native** or **Expo** projects because [hot reloading support](/builds/frameworks/index#hot-reload-vs-rebuild) allows for quick changes.</Note>

## What you'll have at the end

* The ability to hand Cursor Cloud Agents coding tasks and have them confirmed and built without the need for local development.
* Pull requests with proof that the changes are as intended, alongside live simulator/emulator devices to manually confirm changes.
* Auth bypass and IP allowlisting configured, if your app needs either to reach the screens under test.

## Prerequisites

* A Revyl account with the [GitHub integration](/integrations/github) connected to your repository
* Builds running on every Pull Request
* A Cursor account that can launch Cloud Agents

## Configure GitHub proof of changes

### 1. Connect Cursor Cloud Agents

Get a Cursor API key and connect it under **Integrations > Cursor**. Follow
[Cloud Agents setup](/integrations/cursor/cloud-agents#setup) for the exact
steps — a personal key runs agents as you, a team default key works for
everyone in your org.

### 2. Connect the GitHub integration

Follow the [GitHub integration](/integrations/github) instructions to connect Revyl to your repo.

Proof of changes needs a preview build to prove. Follow [Configure PR previews](/integrations/github#configure-pr-previews) for instructions on building your application, or [use your own CI](/integrations/github#use-your-own-ci) and upload a build on every PR.

### 3. Point proof of changes at Cursor

Turn on [proof of changes](/integrations/github#proof-of-changes), then set
the harness to Cursor instead of Revyl's own agent:

* In the dashboard, open the repository's PR-review settings and set the
  **Agent** selector to **Cursor**.
* Click **Authorize Cursor proof runs**. This records that proof runs act
  under your Cursor connection — your connection needs access to the
  repository in Cursor itself, or the authorize step is blocked.

See [Choose which agent proves the change](/integrations/github#choose-which-agent-proves-the-change)
for the full config, authorization, and fallback behavior.

### 4. Open a PR

Open a GitHub pull request. Revyl will execute a Revyl Remote Build and leave a comment on the PR with a live preview link and evidence of the change.

## Configure live agent verification

### 1. Install the Revyl plugin from the Cursor Cloud Marketplace

Install the Revyl plugin so a Cursor Cloud Agent can run and verify your app on a
live Revyl device while you're coding. Follow [Plugin setup](/integrations/cursor/plugin#setup), including the `REVYL_API_KEY` runtime secret and the network allowlist for Cursor Cloud Agents.

### 2. Implement a feature

Ask Cursor Cloud Agent to implement a feature or make changes to the code. Add `Verify the changes with Revyl.` to your prompt so that after the coding changes, Cursor uses Revyl to spawn a cloud device and verify the changes.

### 3. Add AGENTS.md guidance

Once that works, add guidance to your AGENTS.md or CLAUDE.md file so your agent always uses Revyl to verify changes automatically:

```markdown wrap theme={null}
# Agent Guidance
## Revyl Verification

When developing or changing a feature in this repo, use the Revyl dev loop to verify the behavior on a device before finishing.

- Read and follow the local `revyl-cli-dev-loop` skill guidance before running Revyl commands.
- Verify the user-visible outcome with device evidence, such as `revyl device screenshot`, `revyl device report --json`, or explicit interaction through `revyl device instruction`.
- Summarize Revyl verification in the final response: what path was exercised, what evidence was captured, and any issues or limitations. If Revyl cannot be run, state the concrete blocker and the fallback verification used.
```

See [Add Pull Request Guidance](/guides/verify-agent-loop#add-pull-request-guidance) to also have it include Revyl evidence in the PR body.

## Recommended improvements

### 1. Allowlist Revyl's IP addresses if your app rate-limits or CAPTCHAs

If your backend, WAF, or CAPTCHA provider blocks or challenges traffic by IP reputation or volume, it may block traffic as Revyl navigates your app. [Allowlist Revyl's IP addresses](/guides/allowlist-ip-addresses) so those runs aren't blocked partway through.

### 2. Enable auth bypass if your app needs sign-in

If the screens you want proven or explored sit behind a login, add
[auth bypass deep links](/builds/auth-bypass-deeplinks) so both proof runs and
Atlas-launched Cursor agents can reach a signed-in state without automating
every login screen. Without this, a proof run or cloud agent may get stuck on
your login screen instead of verifying the actual change. See [Prepare the session](/integrations/github#prepare-the-session) to configure auth bypass with proof runs.

## Verify the whole loop

* **Proof of changes**: open a pull request with a small change and confirm a
  Cursor Cloud Agent comments its findings, with an **Open in Cursor** link
  and a recording of the run.
* **Cloud Agent Conversations**: open an app's [Atlas](/atlas/index), pick a
  screen, and send it to Cursor. Confirm the conversation shows up under
  **Cloud Agents** with related resources attached.
* **Plugin**: in a Cursor Agent chat, ask "Run this app on a Revyl device" and
  confirm it returns a live viewer and device-backed evidence.

<Check>
  Once all three check out, pull requests opened from Cursor get proven
  automatically, and Cursor Agents can verify their own changes on a real
  device without leaving the editor.
</Check>