Smoke Run
Server Details
Free read-only teardown of a public site's money path, with the dollar at risk.
- Status
- Healthy
- Last Tested
- Transport
- Streamable HTTP · MCP 2025-11-25
- URL
- ChatGPT
- –
- Claude
- –
TDQS
Scored across 4 tools
Each tool has a distinct role: running a check, listing checks for an account, fetching the latest findings for a site, and mapping the revenue stack of a site. The closest pair is list_checks vs get_latest_findings, since both concern recent checks, but the account-wide vs single-site distinction is spelled out. get_money_system and run_revenue_check both analyze a public site, though one is a lightweight stack detection and the other a full teardown.
All four names follow a clean verb_noun snake_case pattern: get_latest_findings, get_money_system, list_checks, run_revenue_check. The verbs (get, list, run) accurately signal retrieval vs enumeration vs execution.
Four tools is on the lean side but within a reasonable range for a narrowly scoped revenue-path teardown service. Each tool earns its place except that there is no way to fetch an individual check by ID, which hints at an under-built surface rather than bloat.
The core loop (run_revenue_check -> get_latest_findings) is covered, plus discovery via get_money_system and history via list_checks. However, list_checks surfaces older checks with no corresponding tool to retrieve their findings, creating a dead end for anything but the most recent check per site; there is also no delete/cancel or account-level retrieval by ID.
Available Tools
4 toolsget_latest_findingsARead-onlyInspect
Returns the most recent revenue-path check for a given site, including its dollar-proof findings. Reads an account history, so it needs a Smoke Run API key. Returns an empty result when no check has been run for that site yet.
| Name | Required | Description | Default |
|---|---|---|---|
| siteUrl | Yes | A public website address, for example https://example.com. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the description is not carrying the safety burden. It still adds real operational context the annotations lack: it reads account history and therefore requires a Smoke Run API key, and it returns an empty result when no check exists for the site. It stops short of describing rate limits or what the findings payload contains beyond 'dollar-proof'.
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 short sentences, front-loaded with the return value and followed by the auth requirement and the empty-state edge case; each sentence carries distinct information. 'Reads an account history, so it needs a Smoke Run API key' is slightly indirect phrasing for the auth requirement but remains efficient.
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 read tool with annotations present and no output schema, the description covers what is returned, the auth prerequisite, and the no-data case, which is enough for correct invocation. The remaining gap is the shape of the findings payload, which the agent only learns at call time.
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?
Schema description coverage is 100%, so siteUrl is already documented with type, format example, and length bound; baseline 3 applies. The description reinforces that the parameter selects a single site's history but adds no syntax, normalization, or validation detail beyond the schema.
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 names a specific verb and resource (returns the most recent revenue-path check) plus the scope (for a given site) and the payload (dollar-proof findings). It implicitly distinguishes itself from list_checks and run_revenue_check by emphasizing 'most recent' and 'read', but it never names those siblings, so an agent must infer the boundary.
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?
Usage is implied rather than stated: 'most recent' suggests retrieval of existing results rather than triggering a new check, which points away from run_revenue_check, and the single-site scope points away from list_checks. There is no explicit when-to-use, when-not-to-use, or named alternative, and no prerequisite ordering (e.g., run a check first) beyond the empty-result note.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
get_money_systemARead-onlyInspect
Detects the revenue stack a public site runs on (payment processor, CRM or lead destination, email provider, booking tool, analytics and ad pixels) from its public page, and returns the funnel map. Free and needs no key. Each node notes what a connected check can verify end to end.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | A public website address, for example https://example.com. | |
| api_key | No | Optional. A Smoke Run API key. It lifts the free daily limit and is not required for a single check. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. The description adds context beyond them: the operation is free, keyless, and scoped to publicly reachable pages, plus a hint about a free daily limit being liftable via api_key (in the schema). It does not describe output shape beyond "funnel map," but that is largely the annotations' remaining gap rather than a contradiction.
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 sentences, front-loaded with the capability and immediately followed by value/return information. The closing clause about nodes noting what a connected check can verify is slightly abstract but earns its place by signaling the funnel map's cross-references.
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?
With no output schema, the description carries the burden of explaining what comes back, and it does so at a high level (a funnel map whose nodes link to verifiable checks). Combined with the schema's rate-limit note, an agent has enough to call this correctly, though the exact shape of the returned map remains unspecified.
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?
Schema coverage is 100%, including the url example and the api_key rate-limit explanation, so the schema does the heavy lifting. The description adds only that the target must be a public site, which is useful but marginal beyond the schema.
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?
States a concrete verb ("detects") and a well-scoped resource (the revenue stack / funnel map of a public site), and enumerates the detection categories (payment processor, CRM, email, booking, analytics, ad pixels). It stops short of naming which sibling to use instead, so it is clear but not sibling-differentiating.
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?
"Free and needs no key" gives a cost/auth signal that helps an agent decide whether to call it, and the url-based input implies the use case. But there is no explicit when-to-use versus run_revenue_check or get_latest_findings, so the routing decision is left to inference.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
list_checksARead-onlyInspect
Lists recent revenue-path checks for the authenticated account, newest first. An optional siteUrl narrows the list to one site.
| Name | Required | Description | Default |
|---|---|---|---|
| limit | No | Optional. Max rows. | |
| siteUrl | No | Optional. Narrow the list to one site. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds ordering (newest first) and account scoping, which is useful, but says nothing about how many results are returned by default, how the limit truncates history, or what a "check" record contains.
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, zero filler, with the ordering and scope front-loaded and the optional narrowing called out second. Nothing is redundant or buried.
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 zero-required-parameter, read-only list tool with full schema coverage and no output schema, the description covers what the tool returns at a high level (recent checks, newest first) and how to narrow it. The main remaining gap is that with no output schema it could hint at the shape of a returned check record.
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?
Schema description coverage is 100%, so both limit and siteUrl are already documented in the schema. The description restates siteUrl's filtering role without adding format, matching behavior, or default-value details beyond what the schema provides, so baseline 3 applies.
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?
"Lists recent revenue-path checks for the authenticated account, newest first" gives a specific verb (lists), a specific resource (revenue-path checks), the scope (authenticated account) and the ordering (newest first). It is clear on its own, but it never names or contrasts itself with siblings like run_revenue_check or get_latest_findings.
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?
Usage is only implied: an agent can infer this retrieves existing checks rather than executing one (run_revenue_check), but the description never states when to choose it over get_latest_findings or get_money_system. No exclusions, prerequisites, or alternative routing are given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
run_revenue_checkARead-onlyInspect
Runs a read-only, from-outside revenue-path teardown of a public website and returns a dollar-proof report. Free and needs no key. It loads the site as a visitor, follows the money path (landing, call to action, lead form, checkout reachability, analytics presence), and reports where revenue is at risk. Each finding carries a confidence label: confirmed means it was reproduced from outside, likely means it was inferred from the public page, and unverifiable from outside means only a connected check can confirm it. Dollar figures are a conservative monthly floor and attach only to confirmed or likely findings. It never submits a form and never completes a charge.
| Name | Required | Description | Default |
|---|---|---|---|
| url | Yes | A public website address, for example https://example.com. | |
| api_key | No | Optional. A Smoke Run API key. It lifts the free daily limit and is not required for a single check. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Beyond the readOnlyHint/openWorldHint annotations, it discloses what actually happens during execution: it loads the site as a visitor, walks the landing-to-checkout money path, and never submits a form or completes a charge. It also explains the confidence taxonomy (confirmed / likely / unverifiable) and the constraint that dollar figures attach only to confirmed or likely findings — exactly the behavioral context an agent needs before invoking an open-world crawler.
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?
The core operation is front-loaded in the first sentence and the confidence-label explanation is placed before the dollar-figure caveat that depends on it. Five sentences for a free-text-only schema is on the longer side, but each carries distinct information; only the 'Free and needs no key' clause mildly overlaps the schema's api_key note.
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, and the description compensates by describing the returned report, its finding structure, the confidence labels, and how dollar estimates are scoped. Combined with the safety caveats, an agent knows what it gets back and what the tool will not do, so nothing material is missing for a 2-parameter open-world tool.
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?
Schema description coverage is 100% and both parameters are already documented, including that api_key 'is not required for a single check'. The description's 'Free and needs no key' reinforces that but adds no syntax, format or validation meaning beyond the schema, so the baseline of 3 applies.
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 names a specific verb and resource: a read-only, outside-in 'revenue-path teardown of a public website' that returns a 'dollar-proof report'. That is far more specific than a tautology and clearly separates it from read-style siblings like get_latest_findings or list_checks, though it never names those siblings explicitly.
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 establishes useful preconditions ('Free and needs no key', runs 'from outside'), which implies this is the tool to reach for when you need a fresh assessment rather than a stored result. It never states when to prefer get_latest_findings, get_money_system or list_checks instead, so the routing decision is left to inference.
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.
4 tool updates
- First observed
get_latest_findings - First observed
get_money_system - First observed
list_checks - First observed
run_revenue_check
Related MCP Connectors
See what's wrong with a live website from the outside, with proof: uptime, DNS, HTTPS, leaked files.
Human-reviewed audit of a public website: bugs, passive security checks, UX. Order link for owners.
Free preflight and exact-price discovery for paid website and AI-agent audits.
How far AI agents get in real software, sign-up to pay. Read-only, no account at /api/mcp.
Related MCP Servers
- AlicenseAqualityAmaintenanceA free, read-only server that lets users diagnose production AI-agent risks: it flags over-privileged API keys from permission descriptions, scans code snippets for the signals that prevent duplicate execution, and explains guard patterns such as idempotency keys, approval gates, outboxes, and circuit breakers. It makes no network calls or writes, and rejects inputs that look like real secrets.3MIT
- AlicenseNot gradedqualityDmaintenanceRead-only observation of a single live URL: parses static HTML to report security posture, forms, links, accessibility signals, and leaks, with described fixes. SSRF-gated and safe, never executes JavaScript.123 npmMIT
- FlicenseAqualityAmaintenanceReads a small-business website like a customer would and shows where they get stuck. Every AI answer has to quote the page, and the server checks the quote before it counts.11-
- AlicenseBqualityCmaintenanceEnables read-only security assessment of a public MCP endpoint by sending initialize and tools/list requests and returning a 0–100 score covering transport, auth, overly broad tools, injection phrasing, and rug-pull definition changes, plus a 12-probe prompt-injection suite against a bot you own that flags leaked system prompts, tool dumps, secrets, exfiltration channels, and canary obedience.2MIT
Glama MCP Gateway
Add one secure layer between your agents and this server.