Crawler IP Verifier - real Googlebot or fake

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already mark it read-only, idempotent, and non-destructive; the description adds substantial context beyond that: no API key, no account, no consent prompt, deterministic, touches no third party, input is canned from host data, and the response is real structuredContent 'not a mock.' This is exactly the kind of behavioral disclosure that helps an agent trust and predict the call.

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 description is heavily redundant: 'no third party' appears three times, 'shape of an answer' twice, and the canned-input/no-URL-of-yours point twice. It also opens with a raw HTTP/JSON-RPC POST instruction that an MCP agent invoking the tool through its framework does not need to construct. The essential message is roughly a third of the length.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given an output schema, safety/determinism annotations, and a zero-parameter input schema, the description covers everything remaining: what the canned call verifies, that the result is a real structuredContent response, and that no auth or external resources are involved. Completeness is high; the bloat and odd HTTP framing are presentation flaws, not gaps.

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?

Zero parameters with 100% schema coverage set a baseline of 4. The description goes beyond the empty schema by explicitly stating 'Takes no arguments,' showing the exact arguments={} call shape, and explaining what canned input that produces. Nothing more is needed for a zero-parameter tool.

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 states the purpose specifically: run this server's own worked example of verify_batch on canned input to see the exact shape of a real answer. It distinguishes itself from the verify_batch sibling by the canned-input contrast ('no URL of yours is fetched'), but this differentiation sits deep in a long passage rather than up front, so the purpose is clear yet not instantly extractable.

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 gives explicit when-to-use guidance: 'Use it to see the shape of an answer before you decide what to send.' The repeated contrast between canned input and the agent's own data implicitly tells the agent this is not the tool for checking real addresses. It never explicitly names the alternative tool for real checks, so it stops short of a 5.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds meaningful behavioral context by stating every export includes a provenance header with source URLs and mirror time, and reports rule cost.

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 description is compact and every clause earns its place, but the embedded JSON-RPC blob makes it slightly dense and harder to parse at a glance. Still, it front-loads the critical prerequisite call before the tool purpose.

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 compensates by specifying the nature of the output (paste-ready config, provenance header, rule cost) and the required first call. It does not detail per-format output structure, but that is not essential for invoking the tool correctly.

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 all parameters have descriptive text and enums, so the schema carries the semantic load. The description adds only an example (operators='all', format='cidr-list', action='allow') that largely duplicates the schema example; no deeper param semantics are provided.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool transforms a set of operators into a paste-ready config and enumerates the exact formats (nginx geo, allow/deny, Apache, HAProxy, Cloudflare, ipset, Caddy, CIDR). It also distinguishes itself from the prerequisite sibling by specifying 'FIRST CALL, needs nothing'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

It explicitly instructs the agent to call no_arguments_report_the_crawler_ip_ranges_this_host_mirrors first, embedding the exact JSON-RPC payload, and provides a concrete invocation example. This leaves no ambiguity about the order of operations.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds meaningful behavioral context about overlap/containment semantics and operator-based lookup, but does not disclose return format, pagination, or error behavior. That is consistent with the calibration example where annotations cover the safety profile and the description adds contextual value.

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 description leads with a full JSON-RPC invocation for a sibling tool, which is verbose and arguably tangential to lookup_prefix's own behavior. The remainder is efficient and packs function, use cases, and alternative input into a compact passage, but the bulky beginning prevents a higher score.

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 tool with only two optional parameters and no output schema, the description adequately explains input modes, output semantics (every containing/contained/overlapping prefix), and an example. Minor gaps—such as no explicit statement about mutual exclusivity or behavior when both parameters are omitted—are acceptable given the low complexity and strong annotations.

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 the baseline is 3. The description adds value by signaling that the parameters are alternatives ('Give an operator or source slug instead'), implying mutual exclusivity that the schema properties do not state. It also reinforces with a concrete example, though the schema already includes one.

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 states a precise verb+resource: 'get every published operator prefix that contains it, is contained by it, or partially overlaps it.' It also names the two input modes (CIDR or operator/source slug) and gives concrete use cases, making the tool's purpose unmistakable and distinct from siblings like no_arguments_report_the_crawler_ip_ranges_this_host_mirrors.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides clear contextual usage: it is 'the check for does my network collide with a crawler range' and for 'auditing an allowlist.' It also directs when to use the operator slug instead of a CIDR. However, it does not explicitly compare against siblings like range_stats or verify_batch, so it lacks explicit exclusions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Beyond the annotations, it discloses that the call is read-only, requires no key, account, OAuth, or session, that no request leaves the edge to build the result, and that no outbound request is made. This gives the agent concrete behavioral guarantees well beyond readOnlyHint/idempotentHint.

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 description is front-loaded with the critical 'TAKES NO ARGUMENTS' fact and contains genuinely useful details, but it is considerably longer than needed for a zero-parameter tool. Several points about having nothing to fill in are repeated, and the long sibling-tool walkthrough adds bulk without much additional selection value.

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?

The description covers the endpoint, authentication expectations, side-effect behavior, output shape, and relationship to alternatives. For a zero-argument read-only tool with a rich output schema, nothing an agent needs to decide or construct the call is missing.

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?

With zero parameters, the schema is already minimal, and the description adds explicit call semantics: arguments must be an empty object, and omitting the arguments key entirely also works. It also provides a complete example invocation, which fully removes ambiguity about how to call the tool.

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 states the specific verb and resource: it reports the crawler-operator prefix lists this host mirrors, including staleness, prefix counts, address totals, and overlap. It clearly distinguishes itself from the zero-argument sibling verify_my_address and from tools that require pasted input.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says when to use this tool: when you need the host's mirrored crawler prefix-list state and want to pass nothing. It names the key alternative verify_my_address, notes that whoami and example also take no arguments, and states that every other server tool expects a file, making the selection boundary unambiguous.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already cover read-only, idempotent, and non-destructive behavior. The description adds value by stating determinism, no third-party interaction, and the per-source output granularity. No contradiction with annotations exists.

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 description is compact and front-loaded with the most important traits: no arguments, safe, deterministic, no third-party calls. The final example is slightly redundant with the first sentence and schema example, but the overall structure is 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?

With no output schema, the description carries the full burden of explaining return value contents, and it does so thoroughly: prefix counts, totals, /24-equivalents, extremes, URLs, fetch times, and multi-operator prefixes. This is complete enough for an agent to understand what the tool returns and why it matters.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The tool has zero parameters, so the baseline is 4. The description reinforces this with 'Takes no arguments' and an explicit {} example, leaving no ambiguity for the agent.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies what the tool produces: per-source prefix statistics, sizing/freshness information, and multi-operator prefixes. This is specific enough to distinguish range_stats from siblings like lookup_prefix, verify_batch, and export_ip_acl.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description states the intended decision context: 'the sizing and freshness information an allowlist decision needs.' It does not explicitly name alternatives or exclusions, but the no-arguments, read-only, aggregate nature makes the appropriate use case clear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already mark this as read-only, idempotent, and non-destructive, and the description adds valuable behavioral detail beyond those fields: reverse DNS is never actually run here; only the exact commands are handed back. It also discloses that the same functionality is available over plain HTTP, which is useful for non-MCP callers. There is no contradiction with the annotations.

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 description is dense but purposeful: the JSON-RPC example, the HTTP alternative, the reverse-DNS caveat, and the freshness note all contribute useful information. It is front-loaded with 'FIRST CALL' and organized clearly with an example. It is longer than strictly necessary, but the length is justified by the invocation alternatives and behavioral caveats.

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?

Despite having no output schema, the description covers what the tool returns, how fresh the information is, when to call it, and how to invoke it both via MCP and HTTP. The single optional parameter is fully explained by the schema and examples. An agent has everything needed to select and call this tool correctly.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The input schema already documents the sole optional parameter at 100% coverage, including that omitting it returns all crawlers. The description reinforces this with the 'needs nothing' note and the claudebot example, but it does not add substantive semantics beyond what the schema already provides. With full schema coverage, a baseline of 3 is appropriate.

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 states a precise purpose: report per-crawler whether the operator publishes IP ranges, documents reverse DNS, or publishes no verification method, including exact source URLs or dig commands and freshness. It also includes a concrete JSON-RPC invocation and example. This clearly distinguishes it from siblings like verify_batch or lookup_prefix by focusing on available verification methods rather than executing verification or prefix lookups.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly labels this as the 'FIRST CALL' and instructs calling it before interpreting addresses that matched nothing, giving clear when-to-use context. It also notes that it needs no arguments, so no prerequisites are hidden. However, it does not explicitly name sibling alternatives or state when not to use this tool, so it falls just short of full routing guidance.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already mark this read-only, idempotent, and non-destructive; the description adds useful context by detailing the per-address return fields, the rollup by operator, and the semantic caveat about misses. It also documents a non-MCP HTTP endpoint with the same behavior, though it omits explicit rate-limit or auth details.

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 description front-loads a full JSON-RPC invocation for a different tool and then appends an example plus an HTTP alternative. The essential verify_batch semantics are buried under extra instruction text, making the definition longer and harder to scan than necessary.

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 supplies the key missing output details: matching prefix, publishing source, mirror time, and operator rollup. It also covers batch limits, input shape, and result interpretation, so an agent has enough to invoke and interpret the tool correctly despite the noisy preamble.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema already covers the single 'addresses' parameter at 100%, so the baseline is 3. The description adds meaning by explaining the role of the 'claim' field and showing a concrete hit/miss example that goes beyond the schema's type-level description.

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 core operation is clearly stated: 'Check up to 500 addresses against every mirrored operator prefix list in one call.' The verb, resource, and batch scope are specific, though the description never explicitly differentiates it from siblings like verify_my_address or lookup_prefix.

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 provides concrete invocation context: batch use, maximum 500 addresses, accepted input formats, and an explicit example with ip/claim pairs. It also cautions that a miss is not evidence of a fake, which helps agents interpret results. The leading 'FIRST CALL' reference to another tool is confusing, but it does not make the main usage conditions unclear.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

Annotations already provide readOnlyHint/idempotentHint/destructiveHint/openWorldHint, and the description adds substantial context beyond them: 'No key, no account, no OAuth, no session to open first', 'Every fact is computed from your own headers and from files this host already publishes; nothing is fetched to build it, and no URL of yours is touched', and the verdict semantics that 'a miss is not evidence of a fake.' This is exactly the kind of behavioral context (auth needs, data sources, false-negative meaning) annotations do not carry. No contradiction with annotations.

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 description is a single unstructured wall of text with significant redundancy: 'nothing for you to invent' (or a variant) appears at least twice, the full JSON-RPC example body appears twice, and the sibling listing is a nested parenthetical chain that is nearly unreadable. The title already conveys the key message, so much of the repeated content does not earn its place. This is over-specification without any organizational structure.

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 0-parameter tool with an output schema present, the description is content-complete: it covers the exact call body, the absence of auth, the data sources (own headers plus host-mirrored prefix lists), the closed-world scope ('every operator-published prefix list this host mirrors', consistent with openWorldHint: false), when to call it first, and the shape of the return (verdict, prefix, source, mirror time). Nothing an agent needs to invoke it correctly is missing; the deficit is purely in presentation, not coverage.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema has zero properties at 100% coverage, so the baseline is 4. The description reinforces the baseline by explicitly instructing that there is 'no argument to invent', providing the exact empty-arguments JSON body to use, and explaining that the subject of the call is the request itself rather than any lookup key. It adds no syntax detail beyond the schema because none exists to add.

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 core action is identifiable: verify the caller's address against operator-published prefix lists, returning the verdict, matching prefix, publishing operator, and mirror time. It also distinguishes itself from its six no-arguments siblings by stating each 'answers one other question each about you.' However, this purpose is buried in a ~350-word run-on paragraph, and the opening instruction ('POST that exact body to https://...') injects transport detail that obscures the tool-level semantic an MCP agent actually acts on.

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 guidance is explicit and strong: 'THIS IS THE CALL TO MAKE FIRST on this server: it is the only one whose subject is the request you just sent, so there is nothing to look up and no argument to invent.' It also names sibling tools and their subjects. But the sibling mapping is a dense path-to-tool chain ('/mcp/lint (whoami)') that is hard to parse, and the guidance never compares against five actual siblings from the provided list (lookup_prefix, range_stats, verification_methods, verify_batch, export_ip_acl), leaving real alternatives unaddressed.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

The description substantially extends the annotations: it discloses 'free, read-only, no API key, no account, no consent prompt,' 'Deterministic. Touches no third party,' and precisely attributes every fact to 'the headers on your own request or from a file this host already publishes.' This goes well beyond the readOnlyHint/idempotentHint/openWorldHint annotations and directly informs an agent's safety reasoning. There is no contradiction with the annotations.

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 description is severely bloated and repetitive: the list 'the user-agent you sent, the address you came from, the class our instrument books you as, and whether this host has seen you before' appears nearly verbatim at least three times. The same guarantees (no arguments, nothing fetched, nothing invented) are also restated. It could be condensed to roughly three sentences without losing any information, and the repetition actively harms readability.

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?

Despite the bloat, all necessary information is present: exact invocation (endpoint and body), safety profile, data provenance, and the returned fields. An output schema exists, so return format needn't be repeated. The main gap is minor — no pagination or error-case discussion, which is low-stakes for a zero-argument read-only introspection 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?

With zero parameters and 100% schema coverage, the baseline is 4. The description adds explicit reinforcement that no arguments exist ('Takes no arguments,' 'no argument exists') and provides a concrete example invocation with 'arguments={}', which is useful extra confirmation for an agent.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly identifies the tool's function: it reports caller identity — user-agent, source address, classification, and whether the host has seen the caller before. It also distinguishes itself from siblings by noting it runs 'through this server's own verify_batch.' However, the purpose is buried under a literal POST body and repetitive phrasing, so it's clear but not crisply stated.

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 explicit: it says 'Takes no arguments. Safe to call' and gives an exact invocation body, which signals when to use it. But there is no explicit when-to-use vs alternatives such as verify_batch, verify_my_address, or lookup_prefix, and no stated conditions for choosing a sibling tool.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.