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

# Set up Cursor end to end

> 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) 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](/frameworks#hot-reload-vs-rebuild) allows for quick changes.</Note>

Prompt for your coding agent:

```text
Set up Revyl and Cursor end to end for this repository.

Read https://docs.revyl.com/integrations/cursor/setup.md and follow it. It's the current Revyl guide for this, so prefer it over anything you remember about Revyl.

I'll connect Cursor and authorize Cursor proof runs in the dashboard myself. Set up the rest as the page says, then open one small pull request that changes something visible, and don't make it a draft.

You're done when the proof-of-changes check in the page's Verify the whole loop section passes, and you've told me how to run the other two.

Ask me before anything that needs my login or approval.
```

## 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#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
# 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](/agents#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](/security/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](/devices/auth-bypass) 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.

To keep a shared `main` or `staging` map current, see [Keep main or staging current](/atlas/explore-cli#keep-main-or-staging-current).

## 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), 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>