Build an AI Agent That Monitors Websites for Changes

An agent that only takes a screenshot when you ask it to is stuck in the present. It can tell you what a page looks like right now, but it has no memory of what that page looked like an hour ago, so it cannot tell you that anything changed. To build an agent that notices a pricing page moved or a status page flipped red, it needs something that checks on its own schedule and remembers the last result.

That is what Rendex Watch adds to the Rendex MCP server: eight watch_*tools that let an agent create a monitor, read its run history, and react to a change, all in the same conversation it already uses to capture screenshots. This is AI agent website monitoring without a cron job, a diffing library, or a second service the agent has to call out to. Every tool and field below is verified against the MCP server's source.

Prerequisites

An MCP client that can call tools: Claude Desktop, Claude Code, Cursor, Windsurf, or a custom agent loop.
A Rendex API key. The free tier includes one watch on a daily check, no card required.
The Rendex MCP server, connected locally over stdio or remotely at mcp.rendex.dev.

Step 1: Connect the Rendex MCP server

Add the server to your client's MCP config. The local, stdio version works with Claude Desktop, Claude Code, Cursor, and Windsurf:

mcp config

{
  "mcpServers": {
    "rendex": {
      "command": "npx",
      "args": ["-y", "@copperline/rendex-mcp"],
      "env": {
        "RENDEX_API_KEY": "YOUR_API_KEY"
      }
    }
  }
}

Restart the client and check its tool list. Alongside rendex_screenshot and rendex_extract, you should see watch_create, watch_test, watch_list, watch_get, watch_run, watch_runs, watch_update, and watch_delete. Full setup for every client, including the OAuth connector flow for Claude and ChatGPT, is in the MCP docs.

Step 2: Have the agent create a watch

Instead of writing the request body yourself, tell the agent what to monitor in plain language, for example "watch status.northwind.dev and let me know if the status changes." The agent fills in a watch_create call from the key fields: the url, how often to check (intervalMinutes), and how it should decide something changed (diffMode: a pixel diff, a text diff, or both).

watch_create call

{
  "url": "status.northwind.dev",
  "name": "Northwind status page",
  "intervalMinutes": 30,
  "diffMode": "both",
  "threshold": 0.02,
  "notifyEmail": "you@northwind.dev"
}

An active watch captures its baseline immediately, so the first result comes back in the same call. The threshold is a noise floor for the visual diff (0 to 1): the default 0.01 flags any visible change, while something like 0.06 only flags a change that moves a large share of the page. intervalMinutes has a plan floor: daily on Free, down to every 5 minutes on Enterprise, and watch_create rejects anything tighter than yours allows. Before committing to a scope, an agent can dry-run it with watch_test, which renders the config once and reports whether the page is reachable without creating a watch or charging anything.

Step 3: Poll run history and read what changed

A watch checks itself on schedule, so an agent does not have to sit in a loop waiting. When the user asks "has anything changed on the status page," the agent reads the run history instead:

watch_runs result (items[0])

{
  "id": "a7e1c4...",
  "watchId": "8f3c...",
  "status": "completed",
  "changed": true,
  "diffScore": 0.048,
  "diffPixels": 51200,
  "beforeUrl": "https://rendex.dev/i/...signed",
  "afterUrl": "https://rendex.dev/i/...signed",
  "diffOverlayUrl": "https://rendex.dev/i/...signed",
  "cropUrl": "https://rendex.dev/i/...signed",
  "aiSummary": "Status flipped to Partial Outage",
  "textDiff": { "summary": "banner text changed" }
}

changed is the first thing worth checking: if it is false, there is nothing to report and the agent can stop there. If it is true, cropUrl is the crop-to-change image, the fastest way for an agent (or a human) to see what moved without scanning a full-page screenshot, backed by the full beforeUrl, afterUrl, and diffOverlayUrl frames. aiSummary is a ready-made sentence on Pro and Enterprise plans; on other plans the agent composes its own line from diffScore and textDiff instead. Put together, that is enough for an agent to turn a raw diff into something like this:

AI agent website monitoring: before, after, and overlay diff frames of a status page the agent read from a watch_runs result — What an agent assembles from a watch_runs result: the before, after, and overlay frames plus a one-line summary

Step 4: Check right now instead of waiting

Sometimes the user wants certainty before the next scheduled check, for example right after they hear a competitor changed pricing. watch_run forces an immediate check for one credit and returns a queued run; the agent then polls watch_runs until that run's status moves from queued to completed and reads changed the same way as Step 3. To change the watch itself later, such as tightening the interval or turning on a webhook, watch_update edits it in place and only re-baselines if the scope (URL, selector, or viewport) actually changed.

For a one-off capture that is not part of an ongoing watch, for example "show me what this page looks like right now," reach for rendex_screenshot instead; the AI agent screenshots use case covers that side of the same MCP server.

Troubleshooting

watch_create rejects intervalMinutes. Each plan has a floor (daily on Free, down to 5 minutes on Enterprise). Round up to your plan's floor or upgrade.
webhookUrl or aiSummary gets rejected. Webhooks need Starter or above; the AI-written aiSummary line needs Pro or above. notifyEmail works on every plan.
Watch keeps firing on noise. Raise threshold, or scope the watch to one element with selector in renderParams instead of diffing the whole page.
Not sure what a config will capture. Run watch_test first, or try the Preview a Website Watch tool in the browser before wiring it into an agent.

Ship it

An agent with watch_* access can set up its own monitoring instead of you writing a cron job and a diff script yourself: it creates the watch, reads the run history, and decides what is worth telling you about. For the full change-detection model, plan limits, and the REST and SDK surface behind these tools, see the Rendex Watch launch post and the Watch API reference. New accounts get a free watch and a free render allowance, enough to wire up the whole loop before you pay anything. Create an account and give your agent something to watch.