Austin Oaks Page Watch
Server Details
Watch a public web page for changes when your agent cannot stay running. Hourly checks, signed diffs
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP
- URL
TDQS
Scored across 3 tools
Each tool has a clearly distinct lifecycle role: watch_url creates a monitor, check_changes polls and consumes the change status, and unwatch_url stops the monitor. There is no overlap or ambiguity between them.
All tool names follow a consistent verb_noun pattern: watch_url, unwatch_url, check_changes. The verb clearly indicates the action and the noun indicates the target, making the set predictable and easy to navigate.
Three tools is exactly the right size for this focused server: create a watch, check a watch, and remove a watch. Each tool earns its place with no redundant functionality.
The tool set covers the full lifecycle of page monitoring: starting a monitor, retrieving its status and diff later, and canceling it. There are no dead ends or missing core operations for the stated purpose.
Available Tools
3 toolscheck_changesCheck a watched page for changesARead-onlyIdempotentInspect
Ask whether a watched page changed since you last checked, using the token from watch_url. Returns the monitor status, checks remaining, changed_since_last_poll, and the latest signed change record with a line diff excerpt. Safe to call from any later run; calling it marks the changes as seen.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | How many recent change records to include. | |
| token | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotation Contradiction: The description states 'calling it marks the changes as seen,' which implies a state-changing side effect, while annotations declare readOnlyHint=true. This is a direct and material contradiction. Although the description otherwise discloses return fields and safety, the conflicting side-effect statement makes behavioral transparency fail.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Three concise sentences cover the core operation, expected return fields, safety, and the important side-effect of marking changes as seen. The most important information is front-loaded and every sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
There is no output schema, so the description usefully enumerates the key return values: monitor status, checks remaining, changed_since_last_poll, and the latest signed change record with a line diff excerpt. It does not explain how limit affects the returned records or what happens with invalid tokens, but the essential calling context is covered.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The description adds crucial meaning to the token parameter by stating it comes from watch_url, which the schema does not explain. The limit parameter is already documented in the input schema with a clear description and default. This compensates for the 50% schema description coverage.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's function: ask whether a watched page changed since the last check, using a token. It also distinguishes the check action from its sibling tools watch_url and unwatch_url by focusing on the polling/status behavior.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context: it is meant to be used with a token from watch_url and is safe to call from later runs. It does not explicitly say when not to use it or name sibling alternatives, but the usage context is strong enough for an agent to select it appropriately.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
unwatch_urlStop watching a pageADestructiveIdempotentInspect
Stop a monitor by token. Remaining checks are forfeited.
| Name | Required | Description | Default |
|---|---|---|---|
| token | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already mark the operation destructive and idempotent; the description adds a concrete consequence beyond that: 'Remaining checks are forfeited.' This tells the agent what is lost on invocation, though it does not mention response behavior or post-stop state.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Two short sentences convey purpose and consequence with no filler. The main action is front-loaded and the additional side-effect sentence earns its place.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter, no-output-schema tool, the description is nearly complete: it states the operation, the parameter's role, and the key side effect. It would be more complete with an explicit pointer to watch_url as the source of the token or a note on when stopping is appropriate, but annotations cover idempotency and destructiveness.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema gives only 'token' as a required string with no description (0% coverage). The description identifies token as the monitor identifier ('Stop a monitor by token'), which is the essential meaning, but it does not explain token format or where to obtain it.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific action and resource: 'Stop a monitor by token.' The title 'Stop watching a page' reinforces this, and the operation is clearly the inverse of the sibling watch_url, making it easy to distinguish.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description gives clear context for when to use the tool: when a monitor should be stopped. It does not explicitly name alternatives or exclusions, but the action is unambiguous and the sibling tools naturally suggest the related start/check operations.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
watch_urlWatch a web page for changesAInspect
Start watching a public web page for changes when you cannot stay running yourself. Use when a task needs to know whether a page changed since you last looked, and you will not be alive to check: a price, a status page, a job listing, a policy, a schedule, a document.
Give it a URL. It takes a first snapshot now, then re-fetches every 3600 seconds, extracts the visible text deterministically, and records a signed change record whenever the text hash changes. You get back a token; call check_changes with it later, from any run, to learn whether the page changed and see the diff.
Free: 3 monitors per caller, 168 hourly checks each (about seven days). More checks or more monitors are sold per call over x402 on the HTTP route POST /v1/watch.
It will NOT render JavaScript, log in, use proxies, or bypass bot protection. A page that blocks plain fetches is reported BLOCKED and your remaining checks are kept and can be moved to another URL. No language model is involved; no 'meaningful change' guessing.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | Public http(s) URL to watch. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description goes far beyond the sparse annotations (readOnlyHint false, openWorldHint true). It discloses the mechanics: initial snapshot, re-fetch every 3600 seconds, deterministic text extraction, hashed change records, and a returned token. It also covers limitations (no JS/login/proxies/bot bypass), failure behavior (BLOCKED reported), and cost model, giving the agent a full picture of what invoking this tool entails.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Though longer than many descriptions, every sentence earns its place: purpose, mechanics, token usage, quota/cost, limitations, and failure handling are all covered. The most important usage context is front-loaded, and the limitations are grouped at the end. No filler or redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's asynchronous nature and the absence of an output schema, the description is complete: it explains the single input (url), what happens immediately (snapshot), what happens over time (polling), what the agent receives (token), how to consume results (check_changes), applicable quotas, and edge cases (BLOCKED, remaining checks). An agent can invoke this tool correctly and understand the follow-up steps without needing additional information.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The schema already documents url as 'Public http(s) URL to watch,' so baseline is 3. The description adds meaningful constraints by explaining that the URL must be plain-fetchable without JavaScript, login, proxies, or bot-protection bypass, and that pages blocking plain fetches return BLOCKED. This sharpens what 'public' means for choosing a valid parameter value.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb and resource: 'Start watching a public web page for changes when you cannot stay running yourself.' It clearly distinguishes this from siblings by explaining that check_changes is the follow-up call to retrieve diffs, and unwatch_url is the likely stop operation. The tool's role as the initiation step in a watch workflow is unmistakable.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
It explicitly states the condition for use: 'Use when a task needs to know whether a page changed since you last looked, and you will not be alive to check.' It gives concrete examples (price, status page, job listing) and points to the companion tool check_changes for later retrieval. This provides clear guidance on when to select this tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
3 tool updates
- First observed
check_changes - First observed
unwatch_url - First observed
watch_url
Related MCP Connectors
Evidence-bearing public webpage monitoring with hashes, diffs, signed webhooks, REST, and MCP.
Monitor public pages with source URLs, timestamps, hashes, text diffs and signed webhooks. One daily monitor is free for 30 days; the $9, 30-day pass adds five monitors at a 15-minute minimum interval, 15,000 checks and change history. No auto-renewal. Public connection supports preflight and offer tools; obtain a key on the website (POST /v1/keys/free for the free tier) and pass api_key to monitor tools. Public text/HTML/JSON/XML up to 3 MB; no browser rendering or login bypass. Hosted commercial service; engine and source remain private.
Give an AI agent eyes on the web: turn any feed, page, or stream into deduplicated change events.
Recurring agent jobs that run on our servers and ping you only when the result changed.
Related MCP Servers
- FlicenseNot gradedqualityAmaintenanceEnables evidence-bearing change monitoring for public text pages, providing normalized diffing, SHA-256 hashing, and signed webhook notifications.-
- FlicenseNot gradedqualityCmaintenanceEnables monitoring of website changes through contracts, with automatic extraction, semantic diffing, and healing, triggering alerts and actions via email, Slack, or Telegram.-
- AlicenseNot gradedqualityDmaintenanceEnables tracking web page changes, detecting content modifications with structured diffs and snapshot history through MCP tools.MIT
- FlicenseNot gradedqualityCmaintenanceEnables AI assistants to monitor web pages for content changes and receive alerts when changes occur.-