Koskamo

Ground Truth MCP

Ground Truth is an MCP server that enables AI agents to perform preflight checks on external resources, including endpoint behavior, HTTP security headers, and claim verification via keyword evidence. It supports persistent monitoring of pricing pages and other sources to provide fresh, evidence-based decisions for agents.

Endpoint and access

No sign-in to connect and list tools. Individual tools may still need a vendor account, credentials, or permissions; check the documented prerequisites.

Ground Truth MCP logo, by Anish Das MailCommunity listingStreamable HTTPNo sign-inEndpoint checked 2026-11-06Published by Anish Das Mail
You need:Free preflight checks work without an API keyNo checkout or API key is needed for the baseline
MCP endpoint (Streamable HTTP)
https://ground-truth-mcp.anishdasmail.workers.dev/mcp
Vendor documentation

What its tools do

19 tools, grouped by the hints the server advertises. Hints are self-declared, not verified behavior.

19 of 19 have a description · 19 of 19 declare behavior hints · 18 of 18 with parameters document them all

Checks and signals

Each line is separate evidence, not a trust score.

  • Passed Endpoint answered the live check ·
  • Availability 1 of 1 checks passed in 30 days

What you can do with it

  • Preflight an endpoint or API to check status and content type
  • Inspect security headers for configuration signals
  • Verify external claims by checking evidence URLs for keywords
  • Create persistent monitors for competitive pricing changes

Source and maintenance

Community listingRegistry 0.7.0

Protocol and capabilities

Server
ground-truth 0.9.0
MCP protocol negotiated in check
2025-11-25
Tools
19 advertised
Resources
Not advertised
Resource templates
Not advertised
Prompts
Not advertised
Server-advertised capabilities
{
  "tools": {
    "listChanged": true
  }
}

Server-provided instructions

Untrusted server output shown for inspection. It is not Koskamo guidance and is excluded from knowledge search.

Ground Truth gives agents evidence-backed signals about competitor and vendor changes (pricing, packaging, APIs, packages, public claims). START HERE (no API key, no signup): call `check_endpoint` with a public URL, e.g. url="https://example.com". A PASS confirms you are connected and returns live evidence (status, content type, timing, redirects, auth/rate-limit signals). PROVE RECURRING VALUE: if a source should stay trustworthy over time, call `preview_monitor` (still free, no key) to capture a baseline for a pricing page, endpoint, package, or vendor claim. Then create a persistent monitor with `create_monitor` using a free watch key from /watch — 3 monitors, daily/weekly checks, evidence history, change reports, and webhook/Slack/email alerts, with no card. Only suggest a paid plan after a preview or monitor has shown value. Paid plans add hourly checks, higher limits, and the research tools (pricing, market, competitor, hypothesis, compliance). Do not answer from memory — call a tool and use its evidence.

Tools

19 advertised

check_endpoint — Endpoint Reachability Check
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Preflight an unfamiliar public URL or API before an AI agent relies on it. It performs one live fetch and returns a PASS/WARN/FAIL verdict with HTTP status, content type, response time, final URL/redirect behavior, auth and rate-limit signals, and a short response sample. A PASS proves only that this fetch succeeded at check time; it does not validate authenticated flows, POST side effects, JavaScript execution, or business logic.

check_endpoint input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "description": "Public http(s) URL or bare domain to probe. Bare domains like google.com are accepted and normalized to https:// automatically."
    }
  },
  "additionalProperties": false
}
check_endpoint output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url",
    "accessible",
    "verdict",
    "summary",
    "evidence",
    "recommended_action",
    "next_step"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Normalized URL that was actually fetched."
    },
    "error": {
      "type": "string",
      "description": "Validation or network error when the request could not be completed."
    },
    "status": {
      "type": "integer",
      "description": "HTTP status code returned by the endpoint, when a response was received."
    },
    "summary": {
      "type": "string",
      "description": "Short human-readable explanation of the verdict."
    },
    "verdict": {
      "enum": [
        "PASS",
        "WARN",
        "FAIL"
      ],
      "type": "string",
      "description": "Operational preflight verdict. It is evidence for an agent decision, not a security guarantee."
    },
    "evidence": {
      "type": "object",
      "properties": {
        "error": {
          "type": "string"
        },
        "status": {
          "type": "integer"
        },
        "finalUrl": {
          "type": "string"
        },
        "redirected": {
          "type": "boolean"
        },
        "contentType": {
          "type": [
            "string",
            "null"
          ]
        },
        "rateLimited": {
          "type": "boolean"
        },
        "authRequired": {
          "type": "boolean"
        },
        "responseTimeMs": {
          "type": "integer",
          "minimum": 0
        }
      },
      "description": "Structured observations used to produce the verdict.",
      "additionalProperties": false
    },
    "finalUrl": {
      "type": "string",
      "description": "Final response URL when the runtime exposes it."
    },
    "inputUrl": {
      "type": "string",
      "description": "Original user input when normalization changed it, for example when https:// was added."
    },
    "next_step": {
      "type": "string",
      "description": "Agent-readable follow-up for sources that should remain trustworthy over time."
    },
    "accessible": {
      "type": "boolean",
      "description": "True when the endpoint returned a 2xx HTTP status."
    },
    "redirected": {
      "type": "boolean",
      "description": "True when the fetch followed a redirect to a different final URL."
    },
    "contentType": {
      "type": [
        "string",
        "null"
      ],
      "description": "Response Content-Type header, if present."
    },
    "rateLimited": {
      "type": "boolean",
      "description": "True when the server responded with 429 Too Many Requests."
    },
    "authRequired": {
      "type": "boolean",
      "description": "True when the server responded with 401 or 403, which usually means credentials are required."
    },
    "responseTimeMs": {
      "type": "integer",
      "minimum": 0,
      "description": "Elapsed request time in milliseconds."
    },
    "sampleResponse": {
      "type": "string",
      "description": "First 1,000 characters of the response body for quick inspection. Use this as a debugging hint only; it may be truncated and should not be treated as a complete page capture."
    },
    "recommended_action": {
      "enum": [
        "proceed",
        "proceed_with_caution",
        "stop"
      ],
      "type": "string",
      "description": "Suggested next step based only on observed response behavior."
    }
  },
  "additionalProperties": false
}
check_endpoint annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
preflight_endpoint — Endpoint Preflight
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Run reachability/response and security-header checks together for an unfamiliar URL or API before an AI agent trusts or acts on it. Returns one combined PASS/WARN/FAIL verdict with evidence from both checks. It does not prove that a service is safe, authenticated, or correct.

preflight_endpoint input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "description": "Public http(s) URL or bare domain to preflight."
    }
  },
  "additionalProperties": false
}
preflight_endpoint output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url",
    "verdict",
    "summary",
    "evidence",
    "recommended_action",
    "next_step"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Normalized URL that was checked."
    },
    "summary": {
      "type": "string",
      "description": "Short explanation of the combined verdict."
    },
    "verdict": {
      "enum": [
        "PASS",
        "WARN",
        "FAIL"
      ],
      "type": "string",
      "description": "Combined preflight verdict."
    },
    "evidence": {
      "type": "object",
      "required": [
        "endpoint",
        "securityHeaders"
      ],
      "properties": {
        "endpoint": {
          "type": "object",
          "additionalProperties": {}
        },
        "securityHeaders": {
          "type": "object",
          "additionalProperties": {}
        }
      },
      "description": "Evidence from the endpoint and security-header checks.",
      "additionalProperties": false
    },
    "next_step": {
      "type": "string",
      "description": "Concrete follow-up after reviewing the evidence."
    },
    "recommended_action": {
      "enum": [
        "proceed",
        "proceed_with_caution",
        "stop"
      ],
      "type": "string",
      "description": "Suggested next step."
    }
  },
  "additionalProperties": false
}
preflight_endpoint annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
estimate_market — Package Market Search
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Search npm or PyPI to estimate how crowded a package category is before you claim that a market is empty, niche, or competitive. Use this when you have a category or search phrase such as 'edge orm' and want live result counts plus representative matches. Do not use it to compare exact known package names or to infer adoption from downloads; it reflects search results, not market share. Registry responses are cached for 5 minutes.

estimate_market input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "query"
  ],
  "properties": {
    "query": {
      "type": "string",
      "minLength": 2,
      "description": "Short registry search phrase to evaluate, for example 'mcp memory server' or 'edge orm'."
    },
    "registry": {
      "enum": [
        "npm",
        "pypi"
      ],
      "type": "string",
      "default": "npm",
      "description": "Registry to search. Use 'npm' for JavaScript ecosystems and 'pypi' for Python ecosystems."
    }
  },
  "additionalProperties": false
}
estimate_market output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "query",
    "registry",
    "totalResults",
    "topResults"
  ],
  "properties": {
    "query": {
      "type": "string",
      "description": "Search phrase that was evaluated."
    },
    "registry": {
      "enum": [
        "npm",
        "pypi"
      ],
      "type": "string",
      "description": "Registry that was searched."
    },
    "topResults": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name",
          "description",
          "version"
        ],
        "properties": {
          "name": {
            "type": "string",
            "description": "Package name returned by the registry."
          },
          "score": {
            "type": "string",
            "description": "Registry relevance score when npm provides one."
          },
          "version": {
            "type": "string",
            "description": "Latest version string returned in the result payload."
          },
          "description": {
            "type": "string",
            "description": "Short package summary from registry metadata."
          }
        },
        "additionalProperties": false
      },
      "description": "Representative top search matches that help interpret the market count."
    },
    "totalResults": {
      "anyOf": [
        {
          "type": "integer",
          "minimum": 0
        },
        {
          "type": "null"
        }
      ],
      "description": "Total number of matching packages reported by the registry search."
    }
  },
  "additionalProperties": false
}
estimate_market annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
check_pricing — Pricing Page Scan
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Fetch a public pricing page and extract first-pass pricing signals before you quote plan costs, free tiers, or plan names. Use this when you already have a likely pricing URL and need a quick live scan of visible page text. It returns price-like strings, heuristic plan labels, free or free-trial signals, and cache information. It does not map prices to exact plans, normalize currencies, execute checkout flows, or guarantee that a price applies to a specific region or customer type. JavaScript-rendered, logged-in, or heavily obfuscated pricing details can be missed. Results are cached for 5 minutes.

check_pricing input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "format": "uri",
      "description": "Public pricing or plans URL to analyze. Prefer the specific pricing page, for example https://stripe.com/pricing, rather than a generic homepage."
    }
  },
  "additionalProperties": false
}
check_pricing output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Pricing page that was analyzed."
    },
    "error": {
      "type": "string",
      "description": "Fetch or parsing error when the pricing page could not be analyzed."
    },
    "cached": {
      "type": "boolean",
      "description": "True when the page body came from the 5-minute cache instead of a new fetch."
    },
    "pageLength": {
      "type": "integer",
      "minimum": 0,
      "description": "Size of the fetched page body in characters."
    },
    "pricesFound": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Distinct price-like strings extracted from the page text. These are not linked back to specific plans or billing conditions."
    },
    "hasFreeTrial": {
      "type": "boolean",
      "description": "True when the page contains signals that a free trial exists somewhere on the page."
    },
    "hasFreeOption": {
      "type": "boolean",
      "description": "True when the page contains signals that a free plan or $0 option exists somewhere on the page. This is a page-level signal, not proof that the offer is currently self-serve or globally available."
    },
    "plansDetected": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Lowercased heuristic plan labels detected from the page text. They are useful hints, not authoritative plan identifiers."
    }
  },
  "additionalProperties": false
}
check_pricing annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
inspect_security_headers — Security Header Inspection
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Inspect security-related HTTP response headers for an unfamiliar public URL before an agent trusts or recommends it. It identifies missing or weak HSTS, CSP, framing, referrer, permissions, and cross-origin headers. It reports observable configuration only and does not prove that a site is secure or vulnerability-free.

inspect_security_headers input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "minLength": 1,
      "description": "Public http(s) URL or bare domain to inspect. Bare domains are normalized to https:// automatically."
    }
  },
  "additionalProperties": false
}
inspect_security_headers output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url",
    "accessible",
    "https",
    "verdict",
    "summary",
    "evidence",
    "recommended_action",
    "next_step"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Normalized URL that was fetched."
    },
    "error": {
      "type": "string",
      "description": "Validation or network error when the request could not be completed."
    },
    "https": {
      "type": "boolean",
      "description": "True when the normalized URL used https."
    },
    "score": {
      "enum": [
        "strong",
        "moderate",
        "weak"
      ],
      "type": "string",
      "description": "Heuristic security-header score based on how many tracked headers were present."
    },
    "status": {
      "type": "integer",
      "description": "HTTP status code returned by the endpoint."
    },
    "headers": {
      "type": "object",
      "required": [
        "strictTransportSecurity",
        "contentSecurityPolicy",
        "xFrameOptions",
        "referrerPolicy",
        "permissionsPolicy",
        "xContentTypeOptions",
        "crossOriginOpenerPolicy",
        "crossOriginResourcePolicy"
      ],
      "properties": {
        "xFrameOptions": {
          "type": [
            "string",
            "null"
          ]
        },
        "referrerPolicy": {
          "type": [
            "string",
            "null"
          ]
        },
        "permissionsPolicy": {
          "type": [
            "string",
            "null"
          ]
        },
        "xContentTypeOptions": {
          "type": [
            "string",
            "null"
          ]
        },
        "contentSecurityPolicy": {
          "type": [
            "string",
            "null"
          ]
        },
        "crossOriginOpenerPolicy": {
          "type": [
            "string",
            "null"
          ]
        },
        "strictTransportSecurity": {
          "type": [
            "string",
            "null"
          ]
        },
        "crossOriginResourcePolicy": {
          "type": [
            "string",
            "null"
          ]
        }
      },
      "description": "Tracked response headers and their raw values when present.",
      "additionalProperties": false
    },
    "summary": {
      "type": "string",
      "description": "Short human-readable explanation of the verdict."
    },
    "verdict": {
      "enum": [
        "PASS",
        "WARN",
        "FAIL"
      ],
      "type": "string",
      "description": "Header preflight verdict based on reachability, HTTPS, and tracked header presence."
    },
    "evidence": {
      "type": "object",
      "required": [
        "https"
      ],
      "properties": {
        "error": {
          "type": "string"
        },
        "https": {
          "type": "boolean"
        },
        "score": {
          "enum": [
            "strong",
            "moderate",
            "weak"
          ],
          "type": "string"
        },
        "status": {
          "type": "integer"
        },
        "presentCount": {
          "type": "integer",
          "minimum": 0
        },
        "missingRecommended": {
          "type": "array",
          "items": {
            "type": "string"
          }
        }
      },
      "description": "Structured header observations used to produce the verdict.",
      "additionalProperties": false
    },
    "inputUrl": {
      "type": "string",
      "description": "Original user input when normalization changed it."
    },
    "next_step": {
      "type": "string",
      "description": "Agent-readable follow-up for sources that should be checked repeatedly."
    },
    "accessible": {
      "type": "boolean",
      "description": "True when the endpoint returned an HTTP response."
    },
    "presentCount": {
      "type": "integer",
      "minimum": 0,
      "description": "Number of tracked security headers that were present."
    },
    "missingRecommended": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Tracked headers that were not present on the response."
    },
    "recommended_action": {
      "enum": [
        "proceed",
        "proceed_with_caution",
        "stop"
      ],
      "type": "string",
      "description": "Suggested next step; not a security guarantee."
    }
  },
  "additionalProperties": false
}
inspect_security_headers annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
preview_monitor — Preview Source Monitor
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Capture a free live baseline for a source that should remain trustworthy over time. Call this before recommending checkout: it proves what would be monitored without creating an account or persistent monitor. After a successful preview, offer create_monitor only when the user wants scheduled checks, history, or change alerts.

preview_monitor input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "target_type",
    "target_value"
  ],
  "properties": {
    "target_type": {
      "enum": [
        "url",
        "endpoint",
        "pricing_page",
        "package",
        "vendor_claim",
        "custom_prompt"
      ],
      "type": "string",
      "description": "Source type. Use pricing_page for pricing/packaging, endpoint for API availability, package for npm:package or pypi:package, vendor_claim for claim text plus an evidence URL in instructions, and custom_prompt for a URL plus comma-separated keywords in instructions."
    },
    "instructions": {
      "type": "string",
      "maxLength": 1000,
      "description": "For vendor_claim, the public evidence URL. For custom_prompt, comma-separated keywords."
    },
    "target_value": {
      "type": "string",
      "minLength": 1,
      "description": "Public URL, package identifier, or vendor claim to baseline, depending on target_type."
    }
  },
  "additionalProperties": false
}
preview_monitor output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "status",
    "target_type",
    "target_value",
    "evidence",
    "confidence",
    "recommended_schedule",
    "agent_next_action",
    "persistence",
    "upgrade_tool",
    "pricing_url"
  ],
  "properties": {
    "error": {
      "type": "string"
    },
    "status": {
      "enum": [
        "baseline_ready",
        "error"
      ],
      "type": "string"
    },
    "baseline": {},
    "evidence": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "confidence": {
      "type": "number"
    },
    "persistence": {
      "type": "string",
      "const": "preview_only"
    },
    "pricing_url": {
      "type": "string"
    },
    "target_type": {
      "type": "string"
    },
    "target_value": {
      "type": "string"
    },
    "upgrade_tool": {
      "type": "string",
      "const": "create_monitor"
    },
    "agent_next_action": {
      "type": "string"
    },
    "recommended_schedule": {
      "enum": [
        "hourly",
        "daily",
        "weekly"
      ],
      "type": "string"
    }
  },
  "additionalProperties": false
}
preview_monitor annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
list_resources — Server Resource Discovery
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

List all available Ground Truth tools and their access tiers. Zero-cost schema discovery. Call this to explore what verification tools are available before making a tool call. No quota consumption, no API key required.

list_resources input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {}
}
list_resources output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "freeTools",
    "paidTools",
    "monitorTools",
    "serverVersion",
    "recommendedFirstTool",
    "activationPath"
  ],
  "properties": {
    "freeTools": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Tools available in the free tier with no API key required."
    },
    "paidTools": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Tools requiring team API key or agentic payment."
    },
    "monitorTools": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Monitor management tools requiring team API key."
    },
    "serverVersion": {
      "type": "string",
      "description": "Current server version."
    },
    "activationPath": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Agent-readable path from a free proof to persistent monitoring."
    },
    "recommendedFirstTool": {
      "type": "string",
      "description": "Best first tool for proving recurring value before checkout."
    }
  },
  "additionalProperties": false
}
list_resources annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
compare_pricing_pages — Pricing Page Comparison
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Compare two to five public pricing pages side by side before you make competitive pricing or packaging claims. Use this when you want a quick, live comparison of visible prices, free-plan signals, and plan-name hints across vendors. The output is heuristic and page-level: it does not map every price to every plan or normalize regional billing differences.

compare_pricing_pages input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "pages"
  ],
  "properties": {
    "pages": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name",
          "url"
        ],
        "properties": {
          "url": {
            "type": "string",
            "format": "uri",
            "description": "Public pricing page URL for that vendor or product."
          },
          "name": {
            "type": "string",
            "minLength": 1,
            "description": "Short vendor or product label to use in the comparison output."
          }
        },
        "additionalProperties": false
      },
      "maxItems": 5,
      "minItems": 2,
      "description": "Two to five named pricing pages to compare side by side."
    }
  },
  "additionalProperties": false
}
compare_pricing_pages output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "pages",
    "summary"
  ],
  "properties": {
    "pages": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name",
          "url"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Pricing page URL that was fetched for this named vendor."
          },
          "name": {
            "type": "string",
            "description": "Short vendor or product label from the input page object."
          },
          "error": {
            "type": "string",
            "description": "Fetch or parsing error for this specific pricing page when it could not be analyzed."
          },
          "cached": {
            "type": "boolean",
            "description": "True when this page body came from the 5-minute cache."
          },
          "pageLength": {
            "type": "integer",
            "minimum": 0,
            "description": "Size of this fetched page body in characters."
          },
          "pricesFound": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Distinct price-like strings extracted from this page. These are page-level hints and are not mapped to specific plans."
          },
          "hasFreeTrial": {
            "type": "boolean",
            "description": "True when this page contains visible text suggesting a free trial."
          },
          "hasFreeOption": {
            "type": "boolean",
            "description": "True when this page contains visible text suggesting a free plan, free tier, or $0 option."
          },
          "plansDetected": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Lowercased heuristic plan labels detected on this page, such as free, pro, team, or enterprise."
          }
        },
        "additionalProperties": false
      },
      "description": "Per-page pricing signals returned in input order."
    },
    "summary": {
      "type": "object",
      "required": [
        "pagesCompared",
        "pagesWithVisiblePrices",
        "pagesWithFreeOption",
        "pagesWithFreeTrial"
      ],
      "properties": {
        "pagesCompared": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of pricing pages included in the comparison."
        },
        "pagesWithFreeTrial": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of pages with page-level text suggesting a free trial."
        },
        "pagesWithFreeOption": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of pages with page-level text suggesting a free plan, free tier, or $0 option."
        },
        "pagesWithVisiblePrices": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of pages where at least one price-like string was detected."
        }
      },
      "description": "Aggregate counts across all compared pricing pages.",
      "additionalProperties": false
    }
  },
  "additionalProperties": false
}
compare_pricing_pages annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
compare_competitors — Named Package Comparison
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Compare two or more exact package names side by side using live npm or PyPI metadata. Use this when you already know the candidate packages and need evidence for claims such as 'tool A is newer', 'tool B is still maintained', or 'these packages use different licenses'. It returns per-package registry metadata in input order, with field availability varying by registry. Missing or unpublished packages return found=false. Do not use it to discover unknown alternatives, estimate market size, or compare packages across different registries. Registry responses are cached for 5 minutes.

compare_competitors input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "packages"
  ],
  "properties": {
    "packages": {
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1
      },
      "maxItems": 10,
      "minItems": 2,
      "description": "Two to ten exact package names from the same registry, for example ['react', 'vue']. Use exact registry names, not search phrases or categories."
    },
    "registry": {
      "enum": [
        "npm",
        "pypi"
      ],
      "type": "string",
      "default": "npm",
      "description": "Registry that all package names belong to. All compared packages must come from the same registry, and returned metadata fields differ slightly between npm and PyPI."
    }
  },
  "additionalProperties": false
}
compare_competitors output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "packages",
    "registry",
    "comparisons"
  ],
  "properties": {
    "packages": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Package names that were requested for comparison."
    },
    "registry": {
      "enum": [
        "npm",
        "pypi"
      ],
      "type": "string",
      "description": "Registry used for all comparisons."
    },
    "comparisons": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "name",
          "found"
        ],
        "properties": {
          "name": {
            "type": "string",
            "description": "Package name that was looked up."
          },
          "error": {
            "type": "string",
            "description": "Fetch error when registry metadata could not be retrieved for this package."
          },
          "found": {
            "type": "boolean",
            "description": "True when the registry lookup succeeded and returned package metadata."
          },
          "author": {
            "type": "string",
            "description": "Package author when PyPI metadata includes one."
          },
          "cached": {
            "type": "boolean",
            "description": "True when the lookup came from the 5-minute cache."
          },
          "created": {
            "type": [
              "string",
              "null"
            ],
            "description": "Package creation timestamp when npm provides one."
          },
          "license": {
            "type": [
              "string",
              "null"
            ],
            "description": "Package license metadata when provided by the registry."
          },
          "keywords": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Registry keywords or tags associated with the package."
          },
          "description": {
            "type": "string",
            "description": "Short package summary from the registry."
          },
          "lastPublished": {
            "type": [
              "string",
              "null"
            ],
            "description": "Publish timestamp of the latest version when npm provides one."
          },
          "latestVersion": {
            "type": "string",
            "description": "Latest package version known to the registry."
          },
          "totalVersions": {
            "type": "integer",
            "minimum": 0,
            "description": "Number of published versions when npm metadata includes a version history."
          }
        },
        "additionalProperties": false
      },
      "description": "Per-package lookup results returned in the same order as the input package list. Some fields only exist for npm or only for PyPI, so consumers should treat absent fields as normal."
    }
  },
  "additionalProperties": false
}
compare_competitors annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
verify_claim — Claim Support Check
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Verify a factual claim against specific public evidence URLs before an agent repeats it or acts on it. The tool checks whether supplied keywords appear in each fetched source and reports per-source evidence. It does not perform open-ended search, semantic contradiction analysis, or prove a claim true when a page is silent; choose direct evidence URLs and interpret the result as a support signal. Fetched pages are cached for 5 minutes.

verify_claim input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "claim",
    "evidence_urls",
    "keywords"
  ],
  "properties": {
    "claim": {
      "type": "string",
      "minLength": 5,
      "description": "Plain-language claim to verify, for example 'AWS Business support includes 24/7 phone support'."
    },
    "keywords": {
      "type": "array",
      "items": {
        "type": "string",
        "minLength": 1
      },
      "maxItems": 20,
      "minItems": 1,
      "description": "Keywords or short phrases that should appear on supporting pages. Matching is case-insensitive substring matching, so choose phrases that are likely to appear verbatim."
    },
    "evidence_urls": {
      "type": "array",
      "items": {
        "type": "string",
        "format": "uri"
      },
      "maxItems": 10,
      "minItems": 1,
      "description": "One to ten public documentation, pricing, policy, or support URLs that are likely to contain direct evidence for the claim."
    }
  },
  "additionalProperties": false
}
verify_claim output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "claim",
    "sources",
    "verdict"
  ],
  "properties": {
    "claim": {
      "type": "string",
      "description": "Claim that was evaluated."
    },
    "sources": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "url",
          "accessible",
          "supports"
        ],
        "properties": {
          "url": {
            "type": "string",
            "description": "Evidence URL that was checked."
          },
          "error": {
            "type": "string",
            "description": "Fetch error when the evidence page could not be checked."
          },
          "cached": {
            "type": "boolean",
            "description": "True when the page body came from the 5-minute cache."
          },
          "supports": {
            "type": "boolean",
            "description": "True when the page met the current support threshold of at least half of the supplied keywords."
          },
          "accessible": {
            "type": "boolean",
            "description": "True when the evidence page could be fetched."
          },
          "matchRatio": {
            "type": "number",
            "maximum": 1,
            "minimum": 0,
            "description": "Matched-keyword ratio for this source, from 0 to 1."
          },
          "keywordsTotal": {
            "type": "integer",
            "minimum": 0,
            "description": "Total number of keywords the tool looked for on this page."
          },
          "keywordsMatched": {
            "type": "array",
            "items": {
              "type": "string"
            },
            "description": "Subset of supplied keywords that were found on the page."
          }
        },
        "additionalProperties": false
      },
      "description": "Per-source evidence results."
    },
    "verdict": {
      "type": "object",
      "required": [
        "supporting",
        "contradicting",
        "total",
        "confidence",
        "summary"
      ],
      "properties": {
        "total": {
          "type": "integer",
          "minimum": 0,
          "description": "Total number of evidence sources checked."
        },
        "summary": {
          "enum": [
            "CONFIRMED",
            "UNCONFIRMED",
            "LIKELY TRUE",
            "LIKELY FALSE"
          ],
          "type": "string",
          "description": "High-level verdict derived from the supporting-source ratio: all sources supporting => CONFIRMED, none => UNCONFIRMED, majority => LIKELY TRUE, otherwise LIKELY FALSE."
        },
        "confidence": {
          "type": "number",
          "maximum": 1,
          "minimum": 0,
          "description": "Share of sources that supported the claim."
        },
        "supporting": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of sources marked as supporting the claim."
        },
        "contradicting": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of sources not marked as supporting the claim."
        }
      },
      "description": "Aggregate verdict across all supplied sources.",
      "additionalProperties": false
    }
  },
  "additionalProperties": false
}
verify_claim annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
assess_compliance_posture — Compliance Signal Scan
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Scan a public security, trust, compliance, or legal page for common enterprise buying signals before you claim a vendor supports a particular compliance posture. It looks for public references to SOC 2, ISO 27001, GDPR, HIPAA, DPA terms, subprocessors, SSO, SCIM, encryption, and data residency language. This is a signal scanner, not proof of certification or legal sufficiency.

assess_compliance_posture input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "format": "uri",
      "description": "Public trust, security, compliance, or policy URL to scan."
    }
  },
  "additionalProperties": false
}
assess_compliance_posture output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "url"
  ],
  "properties": {
    "url": {
      "type": "string",
      "description": "Compliance or trust page that was analyzed."
    },
    "error": {
      "type": "string",
      "description": "Fetch or parsing error when the page could not be analyzed."
    },
    "cached": {
      "type": "boolean",
      "description": "True when the page body came from the 5-minute cache."
    },
    "signals": {
      "type": "object",
      "required": [
        "soc2",
        "iso27001",
        "gdpr",
        "hipaa",
        "dpa",
        "subprocessorList",
        "sso",
        "scim",
        "encryption",
        "dataResidency"
      ],
      "properties": {
        "dpa": {
          "type": "boolean",
          "description": "True when the page references a data processing agreement or DPA."
        },
        "sso": {
          "type": "boolean",
          "description": "True when the page references SSO or single sign-on."
        },
        "gdpr": {
          "type": "boolean",
          "description": "True when the page references GDPR or the General Data Protection Regulation."
        },
        "scim": {
          "type": "boolean",
          "description": "True when the page references SCIM provisioning."
        },
        "soc2": {
          "type": "boolean",
          "description": "True when the page references SOC 2 or SOC2 compliance language."
        },
        "hipaa": {
          "type": "boolean",
          "description": "True when the page references HIPAA compliance language."
        },
        "iso27001": {
          "type": "boolean",
          "description": "True when the page references ISO 27001 certification or compliance language."
        },
        "encryption": {
          "type": "boolean",
          "description": "True when the page references encryption, data encrypted at rest, or data encrypted in transit."
        },
        "dataResidency": {
          "type": "boolean",
          "description": "True when the page references data residency, data regions, or regional storage controls."
        },
        "subprocessorList": {
          "type": "boolean",
          "description": "True when the page references subprocessors or a subprocessor list."
        }
      },
      "description": "Boolean scan results for common enterprise compliance and security signals.",
      "additionalProperties": false
    },
    "pageLength": {
      "type": "integer",
      "minimum": 0,
      "description": "Size of the fetched page body in characters."
    },
    "matchedSignals": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Signal names that were detected on the page."
    }
  },
  "additionalProperties": false
}
assess_compliance_posture annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
test_hypothesis — Multi-step Hypothesis Test
Advertised by the server during the last successful anonymous check.
Advertised read-onlyOpen-world

Run a small verification plan made of concrete live checks and summarize whether a hypothesis is supported. Use this when one conclusion depends on multiple simple checks such as endpoint reachability, npm search counts, or whether a page contains an exact substring. This is a coordination tool, not an open-ended research agent: every test must be explicitly defined in advance, and tests run in order with no branching or early exit. The final verdict is mechanical: all tests passing => SUPPORTED, zero passing => REFUTED, otherwise PARTIALLY SUPPORTED. Use verify_claim when you already have evidence URLs, estimate_market for category sizing, and compare_competitors when you already know exact package names.

test_hypothesis input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "hypothesis",
    "tests"
  ],
  "properties": {
    "tests": {
      "type": "array",
      "items": {
        "anyOf": [
          {
            "type": "object",
            "required": [
              "description",
              "type",
              "url"
            ],
            "properties": {
              "url": {
                "type": "string",
                "format": "uri",
                "description": "Public URL to probe, for example https://example.com."
              },
              "type": {
                "type": "string",
                "const": "endpoint_exists",
                "description": "Perform one unauthenticated GET request and pass when the endpoint returns a 2xx HTTP status."
              },
              "description": {
                "type": "string",
                "minLength": 3,
                "description": "Short explanation of what this endpoint check is meant to prove."
              }
            },
            "additionalProperties": false
          },
          {
            "type": "object",
            "required": [
              "description",
              "type",
              "query",
              "threshold"
            ],
            "properties": {
              "type": {
                "type": "string",
                "const": "npm_count_above",
                "description": "Search npm and pass when the reported result count is strictly greater than the threshold."
              },
              "query": {
                "type": "string",
                "minLength": 2,
                "description": "npm search phrase to count, for example 'mcp email server'."
              },
              "threshold": {
                "type": "integer",
                "minimum": 0,
                "description": "Lower bound that the npm search result count must exceed."
              },
              "description": {
                "type": "string",
                "minLength": 3,
                "description": "Short explanation of what this npm lower-bound count check is meant to prove."
              }
            },
            "additionalProperties": false
          },
          {
            "type": "object",
            "required": [
              "description",
              "type",
              "query",
              "threshold"
            ],
            "properties": {
              "type": {
                "type": "string",
                "const": "npm_count_below",
                "description": "Search npm and pass when the reported result count is strictly less than the threshold."
              },
              "query": {
                "type": "string",
                "minLength": 2,
                "description": "npm search phrase to count, for example 'business verification mcp'."
              },
              "threshold": {
                "type": "integer",
                "minimum": 0,
                "description": "Upper bound that the npm search result count must stay below."
              },
              "description": {
                "type": "string",
                "minLength": 3,
                "description": "Short explanation of what this npm upper-bound count check is meant to prove."
              }
            },
            "additionalProperties": false
          },
          {
            "type": "object",
            "required": [
              "description",
              "type",
              "url",
              "substring"
            ],
            "properties": {
              "url": {
                "type": "string",
                "format": "uri",
                "description": "Public URL whose response body should contain the expected text."
              },
              "type": {
                "type": "string",
                "const": "response_contains",
                "description": "Fetch a public URL and pass when the response body contains the exact substring using case-sensitive matching. The tool does not parse DOM structure or execute JavaScript before matching."
              },
              "substring": {
                "type": "string",
                "minLength": 1,
                "description": "Exact case-sensitive text to search for in the fetched response body."
              },
              "description": {
                "type": "string",
                "minLength": 3,
                "description": "Short explanation of what this response-content check is meant to prove."
              }
            },
            "additionalProperties": false
          }
        ]
      },
      "maxItems": 10,
      "minItems": 1,
      "description": "Ordered list of one to ten checks to run. Each test object uses only the fields required by its type."
    },
    "hypothesis": {
      "type": "string",
      "minLength": 5,
      "description": "Claim to test, for example 'there are fewer than 50 MCP email servers on npm'."
    }
  },
  "additionalProperties": false
}
test_hypothesis output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "hypothesis",
    "tests",
    "verdict"
  ],
  "properties": {
    "tests": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "description",
          "type",
          "passed",
          "actual"
        ],
        "properties": {
          "type": {
            "enum": [
              "endpoint_exists",
              "npm_count_above",
              "npm_count_below",
              "response_contains"
            ],
            "type": "string",
            "description": "Test type that was executed."
          },
          "actual": {
            "type": [
              "string",
              "number",
              "null"
            ],
            "description": "Observed value or diagnostic string that explains the result. The format varies by test type and is meant for human interpretation, not strict machine parsing."
          },
          "passed": {
            "type": "boolean",
            "description": "True when the test condition was satisfied."
          },
          "description": {
            "type": "string",
            "description": "Human-readable explanation of the check."
          }
        },
        "additionalProperties": false
      },
      "description": "Per-test execution results in input order."
    },
    "verdict": {
      "type": "object",
      "required": [
        "passed",
        "failed",
        "summary"
      ],
      "properties": {
        "failed": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of tests that failed."
        },
        "passed": {
          "type": "integer",
          "minimum": 0,
          "description": "Number of tests that passed."
        },
        "summary": {
          "enum": [
            "SUPPORTED",
            "REFUTED",
            "PARTIALLY SUPPORTED"
          ],
          "type": "string",
          "description": "Aggregate verdict across the full test plan: all pass => SUPPORTED, none pass => REFUTED, otherwise PARTIALLY SUPPORTED."
        }
      },
      "description": "High-level verdict for the hypothesis.",
      "additionalProperties": false
    },
    "hypothesis": {
      "type": "string",
      "description": "Hypothesis that was evaluated."
    }
  },
  "additionalProperties": false
}
test_hypothesis annotations
{
  "readOnlyHint": true,
  "openWorldHint": true,
  "idempotentHint": true,
  "destructiveHint": false
}
create_monitor — Create Monitor
Advertised by the server during the last successful anonymous check.

Create a persistent monitor that tracks a URL, pricing page, package version, endpoint status, vendor claim, or custom keyword pattern over time. Monitors run automatically on their configured schedule (hourly/daily/weekly) via the Cloudflare cron trigger, or on demand with run_monitor_now. Results are stored durably by account. A free watch key includes three daily or weekly monitors; paid plans add hourly schedules and higher limits.

create_monitor input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "name",
    "target_type",
    "target_value"
  ],
  "properties": {
    "name": {
      "type": "string",
      "maxLength": 200,
      "minLength": 1,
      "description": "Human-readable name for this monitor."
    },
    "schedule": {
      "enum": [
        "manual",
        "hourly",
        "daily",
        "weekly"
      ],
      "type": "string",
      "default": "daily",
      "description": "How often the monitor runs automatically. manual means only via run_monitor_now."
    },
    "target_type": {
      "enum": [
        "url",
        "pricing_page",
        "package",
        "endpoint",
        "vendor_claim",
        "custom_prompt"
      ],
      "type": "string",
      "description": "What to monitor. url/endpoint: HTTP reachability and status. pricing_page: pricing signals (prices, plans, free tier). package: package version on npm or pypi (target_value as 'npm:pkg-name' or 'pypi:pkg-name'). vendor_claim: keyword presence at a URL (target_value=claim text, instructions=URL to check). custom_prompt: comma-separated keywords checked against a URL (target_value=URL, instructions=keywords)."
    },
    "instructions": {
      "type": "string",
      "maxLength": 1000,
      "description": "Supplementary instructions. For vendor_claim: the URL to check. For custom_prompt: comma-separated keywords. Optional for other types."
    },
    "target_value": {
      "type": "string",
      "minLength": 1,
      "description": "Primary target. For url/endpoint/pricing_page/custom_prompt: a public https URL. For package: 'npm:package-name' or 'pypi:package-name'. For vendor_claim: the claim text to search for."
    },
    "notification_destination": {
      "type": "string",
      "maxLength": 500,
      "description": "Optional change-alert destination, sent only when a scheduled check detects a change. One of: an HTTPS webhook URL (JSON POST, no API key included), a Slack Incoming Webhook URL (https://hooks.slack.com/...), or an email address as mailto:you@example.com."
    }
  },
  "additionalProperties": false
}
create_monitor output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "id",
    "name",
    "target_type",
    "target_value",
    "schedule",
    "created_at"
  ],
  "properties": {
    "id": {
      "type": "string",
      "description": "Unique monitor ID."
    },
    "name": {
      "type": "string",
      "description": "Monitor name."
    },
    "error": {
      "type": "string",
      "description": "Error message if creation failed."
    },
    "schedule": {
      "type": "string",
      "description": "Monitor schedule."
    },
    "created_at": {
      "type": "string",
      "description": "Creation timestamp ISO 8601."
    },
    "target_type": {
      "type": "string",
      "description": "Monitor target type."
    },
    "target_value": {
      "type": "string",
      "description": "Monitor target value."
    },
    "active_monitor_limit": {
      "type": "number",
      "description": "Maximum active monitors included in the current plan."
    }
  },
  "additionalProperties": false
}
create_monitor annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}
list_monitors — List Monitors
Advertised by the server during the last successful anonymous check.
Advertised read-only

List all monitors owned by this API key, with last run status and schedule. Requires a free watch key or paid API key.

list_monitors input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "active_only": {
      "type": "boolean",
      "default": true,
      "description": "When true returns only active monitors. Set false to include paused monitors."
    }
  },
  "additionalProperties": false
}
list_monitors output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitors",
    "total",
    "active_monitor_limit",
    "remaining_active_slots"
  ],
  "properties": {
    "error": {
      "type": "string"
    },
    "total": {
      "type": "number",
      "description": "Total number of monitors returned."
    },
    "monitors": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "name",
          "target_type",
          "target_value",
          "schedule",
          "last_run_at",
          "last_run_status",
          "created_at",
          "active"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "name": {
            "type": "string"
          },
          "active": {
            "type": "boolean"
          },
          "schedule": {
            "type": "string"
          },
          "created_at": {
            "type": "string"
          },
          "last_run_at": {
            "type": [
              "string",
              "null"
            ]
          },
          "target_type": {
            "type": "string"
          },
          "target_value": {
            "type": "string"
          },
          "last_run_status": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "additionalProperties": false
      },
      "description": "List of monitors belonging to this API key."
    },
    "active_monitor_limit": {
      "type": "number",
      "description": "Maximum active monitors included in the current plan."
    },
    "remaining_active_slots": {
      "type": "number",
      "description": "Active monitor slots remaining for this API key."
    }
  },
  "additionalProperties": false
}
list_monitors annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
run_monitor_now — Run Monitor Now
Advertised by the server during the last successful anonymous check.
Open-world

Immediately run a monitor's verification check outside its normal schedule. Records the result and returns whether the observed value changed since the last run. Counts against your monthly quota. Requires a free watch key or paid API key.

run_monitor_now input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitor_id"
  ],
  "properties": {
    "monitor_id": {
      "type": "string",
      "minLength": 1,
      "description": "The monitor ID returned by create_monitor."
    }
  },
  "additionalProperties": false
}
run_monitor_now output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitor_id",
    "result_id",
    "status",
    "changed",
    "old_value",
    "new_value",
    "confidence",
    "evidence",
    "run_at"
  ],
  "properties": {
    "error": {
      "type": "string"
    },
    "run_at": {
      "type": "string"
    },
    "status": {
      "enum": [
        "changed",
        "unchanged",
        "error"
      ],
      "type": "string"
    },
    "changed": {
      "type": "boolean"
    },
    "evidence": {
      "type": "array",
      "items": {
        "type": "string"
      }
    },
    "new_value": {
      "type": [
        "string",
        "null"
      ]
    },
    "old_value": {
      "type": [
        "string",
        "null"
      ]
    },
    "result_id": {
      "type": "string"
    },
    "confidence": {
      "type": [
        "number",
        "null"
      ]
    },
    "monitor_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
run_monitor_now annotations
{
  "readOnlyHint": false,
  "openWorldHint": true,
  "idempotentHint": false,
  "destructiveHint": false
}
get_monitor_result — Get Monitor Results
Advertised by the server during the last successful anonymous check.
Advertised read-only

Retrieve the most recent run results for a monitor, including change details, confidence score, evidence URLs, and any error information. Requires a free watch key or paid API key.

get_monitor_result input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitor_id"
  ],
  "properties": {
    "limit": {
      "type": "integer",
      "default": 10,
      "maximum": 50,
      "minimum": 1,
      "description": "Maximum number of results to return, newest first."
    },
    "monitor_id": {
      "type": "string",
      "minLength": 1,
      "description": "The monitor ID to retrieve results for."
    }
  },
  "additionalProperties": false
}
get_monitor_result output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitor_id",
    "results",
    "total"
  ],
  "properties": {
    "error": {
      "type": "string"
    },
    "total": {
      "type": "number"
    },
    "results": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "id",
          "status",
          "changed",
          "old_value",
          "new_value",
          "confidence",
          "evidence",
          "error_details",
          "run_at"
        ],
        "properties": {
          "id": {
            "type": "string"
          },
          "run_at": {
            "type": "string"
          },
          "status": {
            "type": "string"
          },
          "changed": {
            "type": "boolean"
          },
          "evidence": {
            "type": "array",
            "items": {
              "type": "string"
            }
          },
          "new_value": {
            "type": [
              "string",
              "null"
            ]
          },
          "old_value": {
            "type": [
              "string",
              "null"
            ]
          },
          "confidence": {
            "type": [
              "number",
              "null"
            ]
          },
          "error_details": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "additionalProperties": false
      }
    },
    "monitor_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
get_monitor_result annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
delete_monitor — Delete Monitor
Advertised by the server during the last successful anonymous check.
Advertised destructive

Permanently delete a monitor and all its stored results. This action cannot be undone. Requires a free watch key or paid API key.

delete_monitor input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitor_id"
  ],
  "properties": {
    "monitor_id": {
      "type": "string",
      "minLength": 1,
      "description": "The monitor ID to delete."
    }
  },
  "additionalProperties": false
}
delete_monitor output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitor_id",
    "deleted",
    "results_deleted"
  ],
  "properties": {
    "error": {
      "type": "string"
    },
    "deleted": {
      "type": "boolean"
    },
    "monitor_id": {
      "type": "string"
    },
    "results_deleted": {
      "type": "number",
      "description": "Number of result records also deleted."
    }
  },
  "additionalProperties": false
}
delete_monitor annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": true
}
generate_change_report — Generate Change Report
Advertised by the server during the last successful anonymous check.
Advertised read-only

Generate a summary report of monitor activity for a time window. Shows monitors run, changes detected, failures, risk levels, and recommended follow-up actions. Requires a free watch key or paid API key.

generate_change_report input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "properties": {
    "period": {
      "enum": [
        "daily",
        "weekly"
      ],
      "type": "string",
      "default": "daily",
      "description": "Report period. daily covers the past 24 hours, weekly covers the past 7 days."
    },
    "include_unchanged": {
      "type": "boolean",
      "default": false,
      "description": "When true also lists monitors with no detected changes."
    }
  },
  "additionalProperties": false
}
generate_change_report output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "period",
    "from",
    "to",
    "summary",
    "changes",
    "failures",
    "recommended_actions"
  ],
  "properties": {
    "to": {
      "type": "string"
    },
    "from": {
      "type": "string"
    },
    "error": {
      "type": "string"
    },
    "period": {
      "type": "string"
    },
    "changes": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "monitor_id",
          "monitor_name",
          "target_type",
          "target_value",
          "run_at",
          "old_value",
          "new_value",
          "confidence",
          "risk_level"
        ],
        "properties": {
          "run_at": {
            "type": "string"
          },
          "new_value": {
            "type": [
              "string",
              "null"
            ]
          },
          "old_value": {
            "type": [
              "string",
              "null"
            ]
          },
          "confidence": {
            "type": [
              "number",
              "null"
            ]
          },
          "monitor_id": {
            "type": "string"
          },
          "risk_level": {
            "type": "string"
          },
          "target_type": {
            "type": "string"
          },
          "monitor_name": {
            "type": "string"
          },
          "target_value": {
            "type": "string"
          }
        },
        "additionalProperties": false
      }
    },
    "summary": {
      "type": "object",
      "required": [
        "monitors_run",
        "changes_detected",
        "failed_checks",
        "unchanged"
      ],
      "properties": {
        "unchanged": {
          "type": "number"
        },
        "monitors_run": {
          "type": "number"
        },
        "failed_checks": {
          "type": "number"
        },
        "changes_detected": {
          "type": "number"
        }
      },
      "additionalProperties": false
    },
    "failures": {
      "type": "array",
      "items": {
        "type": "object",
        "required": [
          "monitor_id",
          "monitor_name",
          "run_at",
          "error_details"
        ],
        "properties": {
          "run_at": {
            "type": "string"
          },
          "monitor_id": {
            "type": "string"
          },
          "monitor_name": {
            "type": "string"
          },
          "error_details": {
            "type": [
              "string",
              "null"
            ]
          }
        },
        "additionalProperties": false
      }
    },
    "recommended_actions": {
      "type": "array",
      "items": {
        "type": "string"
      }
    }
  },
  "additionalProperties": false
}
generate_change_report annotations
{
  "readOnlyHint": true,
  "openWorldHint": false,
  "idempotentHint": true,
  "destructiveHint": false
}
create_share_link — Create Shareable Evidence Link
Advertised by the server during the last successful anonymous check.

Create a read-only public link to the latest result for one of your monitors. The link contains monitor metadata and evidence, never the API key, and expires automatically. Use it to share a verified change with a teammate, customer, or agent. Requires a free watch key or paid API key.

create_share_link input schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "monitor_id"
  ],
  "properties": {
    "title": {
      "type": "string",
      "maxLength": 160,
      "description": "Optional human-readable title for the shared report."
    },
    "monitor_id": {
      "type": "string",
      "minLength": 1,
      "description": "The monitor ID whose latest evidence should be shared."
    },
    "expires_in_days": {
      "type": "integer",
      "default": 30,
      "maximum": 30,
      "minimum": 1,
      "description": "Link lifetime in days, up to 30 days."
    }
  },
  "additionalProperties": false
}
create_share_link output schema
{
  "type": "object",
  "$schema": "http://json-schema.org/draft-07/schema#",
  "required": [
    "report_id",
    "monitor_id",
    "share_url",
    "expires_at"
  ],
  "properties": {
    "error": {
      "type": "string"
    },
    "report_id": {
      "type": "string"
    },
    "share_url": {
      "type": "string"
    },
    "expires_at": {
      "type": "string"
    },
    "monitor_id": {
      "type": "string"
    }
  },
  "additionalProperties": false
}
create_share_link annotations
{
  "readOnlyHint": false,
  "openWorldHint": false,
  "idempotentHint": false,
  "destructiveHint": false
}

Prompts

Not advertised

No prompt definitions available.

Resources

Not advertised

No resource definitions available.

90-day uptime

A lightweight connection check about every six hours, sampled on hosts with many listings. It shows the server answered, not that its tools work.

Too few checks for a percentage yet (2 of 2 answered).

  1. 2026-11-06: 1 of 1 checks answered
  2. 2026-11-07: 1 of 1 checks answered

30-day availability

Aggregated from read-only remote checks; this is not a tool-execution or security guarantee.

Successful checks
1 of 1 (100%)
Average latency
1311 ms
95th percentile latency
1311 ms

Maintenance history

Public check and source-refresh events. Editorial and ownership records remain private.

  • · probe · passed · 1311 ms · metadata changed · 19 tool(s)

Connect from your client

Each snippet registers the same endpoint; pick the client you use.

This server is operated by the named third party. Listing and endpoint checks are not an endorsement or a security audit. Review the operator's permissions, terms, and data handling before connecting. How listings are checked and corrected.

Claude Code

Run this once in a terminal. It registers the remote server. Use --scope project to write .mcp.json for the repo.
Claude Code configuration
claude mcp add --transport http ground-truth-mcp https://ground-truth-mcp.anishdasmail.workers.dev/mcp

Codex

Run this once. Codex stores MCP servers in ~/.codex/config.toml (or .codex/config.toml in a trusted project).
Codex configuration
codex mcp add ground-truth-mcp --url https://ground-truth-mcp.anishdasmail.workers.dev/mcp

Cursor

Merge this server into .cursor/mcp.json in your project, then enable ground-truth-mcp in your MCP settings.
Cursor configuration
{
  "mcpServers": {
    "ground-truth-mcp": {
      "url": "https://ground-truth-mcp.anishdasmail.workers.dev/mcp"
    }
  }
}

Cline

Merge this into cline_mcp_settings.json (Cline → MCP Servers → Configure).
Cline configuration
{
  "mcpServers": {
    "ground-truth-mcp": {
      "type": "streamableHttp",
      "url": "https://ground-truth-mcp.anishdasmail.workers.dev/mcp",
      "disabled": false
    }
  }
}

VS Code

Merge this server into .vscode/mcp.json. Use MCP: List Servers to start ground-truth-mcp and inspect its tools.
VS Code configuration
{
  "servers": {
    "ground-truth-mcp": {
      "type": "http",
      "url": "https://ground-truth-mcp.anishdasmail.workers.dev/mcp"
    }
  }
}

Gemini CLI

Run this once. It writes .gemini/settings.json in the current project; pass --scope user for ~/.gemini/settings.json.
Gemini CLI configuration
gemini mcp add --transport http ground-truth-mcp https://ground-truth-mcp.anishdasmail.workers.dev/mcp

Claude Desktop

Open Claude Settings > Connectors > Add custom connector, enter this server URL and enable it for the conversation. This is a manual remote-connector handoff, not a desktop JSON configuration.
Claude Desktop configuration
https://ground-truth-mcp.anishdasmail.workers.dev/mcp

Windsurf

Merge this into ~/.codeium/windsurf/mcp_config.json, then refresh MCP in Cascade. Windsurf remote servers use serverUrl, not url.
Windsurf configuration
{
  "mcpServers": {
    "ground-truth-mcp": {
      "serverUrl": "https://ground-truth-mcp.anishdasmail.workers.dev/mcp"
    }
  }
}

Let your agent find its tools

Find servers like Ground Truth MCP from your agent. Add Koskamo once to search the index for endpoints, access requirements, and client setup. Public discovery needs no key.