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

Annotations only declare readOnlyHint and idempotentHint, so the description carries the meaningful behavioral burden. It discloses the fixed port allowlist, that arbitrary ranges are rejected, that it is strictly rate-limited, and the abuse-guard intent — none of which the annotations or schema convey.

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?

Four sentences, all substantive and front-loaded with the core behavior before the guard rails. The inline port enumeration slightly duplicates the schema enum, but it contextualizes the allowlist restriction, so waste is minimal.

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 simple read-only diagnostic with full annotation coverage and a fully described two-parameter schema, the description covers purpose, constraints, and intent well. The only minor gap is that the return format (per-port open/closed results) is not mentioned, though no output schema exists.

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%, with both parameters documented and ports constrained by an enum plus default and maxItems. The description's port list largely restates the enum rather than adding new syntax or format detail, 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?

States a specific verb ('Checks'), the resource ('common service ports'), the mechanism ('TCP connect'), and the scope ('on a host'). It is clearly distinguishable from siblings like skuuy_check_security_headers and skuuy_resolve_dns, which operate on different dimensions.

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?

Explicitly states the intended use ('diagnosing your own deployments and firewall/NAT traversal') and an explicit exclusion ('not for scanning third parties'). This is a clear when/when-not statement with no competing sibling to route away from.

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 and idempotentHint=true, so the safety profile is covered. The description adds useful behavioral scope (full redirect chain, TLS issuer/expiry/days remaining), but doesn't disclose rate limits, auth needs, or the shape/limits of the returned audit (e.g. how many headers are checked).

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 fairly dense sentences that front-load the core purpose and then the fields audited. Slightly list-heavy but every element earns its place and there's no filler.

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 usefully previews the three audit dimensions the agent will get back. It does not explain output structure or error behavior (e.g. invalid URL, TLS failure), which would push it higher, but it is complete enough for correct invocation.

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 fully documented in the schema (url as https:// URL, follow_redirects with 10-hop limit). The description mentions redirect chain but adds no syntax or format detail beyond the schema. Baseline 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 enumerates a specific verb (audits) and resource (a URL's security posture) with three named sub-audits: security headers with examples, redirect chain, and TLS certificate health with issuer/expiry details. This distinguishes it clearly from siblings like skuuy_read_url (fetches content) and skuuy_resolve_dns (DNS only).

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 clear context for use – 'pre-deploy checks or auditing any site's hardening' – which tells the agent when to reach for it over read_url. No explicit when-not-to-use or named alternatives, so it falls 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=false and idempotentHint=false, so the write/non-idempotent nature is covered. The description adds genuinely useful behavior beyond that: the inbox self-destructs after a TTL with a default of 30 minutes. It does not mention auth requirements, but the ephemerality disclosure is the key trait for this tool.

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 tight sentences: purpose first, critical behavior (self-destruct/TTL) second, companion-tool routing third. Every sentence carries distinct information with no filler.

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?

No output schema exists, so the description ideally should state what the agent gets back (e.g., the generated inbox address) — it does not. It also lacks any auth/permission context. Given the tool is simple (2 params) the omission is a gap but not crippling.

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 50% (prefix documented, ttl_minutes not). The description restates the TTL default of 30 minutes, reinforcing that parameter's meaning, but says nothing about the prefix parameter or formatting of the generated local part. Baseline 3 is appropriate given partial schema coverage.

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

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

States a specific verb and resource ('Creates a disposable email inbox') and immediately scopes the use case to sign-ups and verifications. It also names the sibling it works with (skuuy_read_inbox), so an agent can place it among the other skuuy tools without opening a schema.

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

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

The description gives a clear usage context (sign-ups, verifications) and explicitly routes the agent to skuuy_read_inbox for polling mail and OTPs. It stops short of stating when NOT to use this tool or what alternative exists for a permanent mailbox, so it is clear context without 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?

Annotations only supply readOnlyHint=false and idempotentHint=false; the description adds that bins are ephemeral and auto-deleted after TTL, which is real behavioral context. It also implicitly explains non-idempotence (each call produces a new bin URL). Return payload isn't spelled out, keeping it short of a 5.

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 tight sentences, front-loaded with what is created and the URL format, followed by usage and lifecycle. Every sentence carries information; no filler.

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?

No output schema exists, yet the description conveys the essential return artifact (the bin URL) and points to skuuy_get_bin_requests for reading captured requests. Minor gap: it doesn't state what the create response itself returns beyond the implied URL.

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% and the single ttl_minutes parameter is fully documented in the schema (range, default, request/body limits). The description's 'Auto-deleted after TTL' merely restates schema semantics without adding syntax or edge-case meaning, 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?

States a specific verb (Creates) and resource (ephemeral webhook-catcher URL), including the concrete URL shape bin.skuuy.com/w/<id> and the payload captured (full headers and body). It clearly separates itself from the sibling that inspects results, skuuy_get_bin_requests.

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?

Explicitly names the use case and example callers (Stripe, GitHub, your own API) 'while debugging' and routes the agent to skuuy_get_bin_requests for inspection. No when-not guidance is given, but the context is 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 only declare readOnlyHint=false and idempotentHint=false, so the description adds real value: the ephemeral URL lifecycle, automatic TTL expiration, and a concrete free-tier rate limit of 25 drops/day. It omits auth requirements and what happens on mirroring failures, keeping it below 5.

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 tightly packed sentences: definition first, usage scenario second, constraint third. Every sentence earns its place with no redundancy.

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

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

For a six-parameter mutation tool with no output schema, the description conveys purpose, the transmitted artifact, and the TTL/rate-limit behavior. It does not describe the return payload shape beyond 'download URL', leaving a small gap.

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 all six parameters, including the ttl enum and required content-or-url pairing, are already documented. The description only restates the base64/remote-URL duality, adding no syntax or format 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?

States a specific verb pair (uploads/mirrors), the resource (inline file via base64 or remote URL), and the outcome (ephemeral public download URL). This clearly separates it from siblings like skuuy_paste (text) and skuuy_read_url (reading), letting an agent route correctly without opening a schema.

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?

Explicitly says when to use it: transferring files, charts, CSVs, logs, or binaries between agents/subagents/users without spending tokens on inline data. That is clear context, but it names no when-not condition or explicit alternative among the many siblings, so it stops short of a full 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 only declare readOnlyHint and idempotentHint, so the description usefully adds that the secret is 'processed ephemerally in memory, never logged or stored' and that sending it constitutes opt-in — real behavioral context beyond structured data. It stops short of details like rate limits or whether secrets are cached per-connection.

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?

Purpose is front-loaded in the first sentence, followed by the privacy contract and compatibility note. Each sentence carries distinct information, though the parenthetical marketing for the browser vault is slightly promotional.

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

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

There is no output schema, so the description carries the burden of explaining what a caller receives — yet it never says the response contains the OTP or the remaining validity window. Inputs and privacy are well covered; the return contract is the notable hole.

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 50% schema coverage, the description compensates: it specifies the secret is base32 and that 'spaces/dashes tolerated', and the RFC 6238 reference contextualizes digits/period/algorithm defaults. The digits and algorithm parameters themselves remain undocumented in prose, though their enums and defaults are self-explanatory.

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 specific verb and resource ('Generates a time-based one-time password (RFC 6238 TOTP) from a base32 secret') and pins the standard, which none of the sibling utilities (hash_encode, rpc, resolve_dns) do. An agent can tell instantly this is the TOTP generator rather than a generic crypto helper.

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 explains the opt-in model: 'By sending the secret you opt in to server-side generation' and names the zero-knowledge alternative (the browser vault). It does not describe when to prefer a sibling tool or any exclusion conditions, but the context for choosing this tool is 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 establish readOnlyHint and idempotentHint, so safety is covered. On top of that the description discloses two traits the schema cannot: the body is truncated at 1 MB, and results may lag edge KV propagation by roughly 3-5 seconds. That timing caveat is genuinely useful for an agent deciding when to retry.

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?

A single dense sentence plus one parenthetical, with the core purpose front-loaded and the poll-timing caveat placed where it matters. Nothing reads as filler.

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?

No output schema exists, and the description compensates by enumerating the return fields (method, headers, query params, body) and the 1 MB cap. The one gap is pagination: with limit/offset in the schema and a potentially unbounded request stream, the description should say how to retrieve captures beyond the first page.

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 only 33%: bin_id is documented in the schema, but limit and offset are bare integers with no description of pagination behavior. The description adds no meaning for these parameters either, so an agent gets no guidance on page size defaults, max limits, or how to page through captures.

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 specific verb (Lists) and resource (HTTP requests captured by a webhook bin), and names the skeleton that produced it (skuuy_create_webhook_bin). It also enumerates what a captured request contains, so an agent can distinguish it from skuuy_read_inbox and the other sibling read tools at a glance.

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?

Explicitly says to poll this after triggering the callback being debugged, with a concrete ~3-5 second KV propagation window, and ties it to skuuy_create_webhook_bin as the prerequisite. It doesn't name a specific alternative tool to use instead, so it falls just short of the when/when-not/alternatives bar.

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 and idempotentHint, so safety is covered; the description adds the hosted-mode nuance (returns the caller's connecting IP rather than public egress) and discloses the detection categories returned. It omits auth requirements and whether the result is cached, but adds real context beyond 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?

Three short sentences, front-loaded with the return value, then usage, then the parameter fact. Every clause carries information; nothing is redundant.

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 has to describe the return payload, and it does so at the field-category level (IP, geolocation, ASN/ISP, proxy/datacenter flags). Exact response shape and error modes are unspecified, but for a zero-parameter read tool this is close to complete.

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, so the baseline is 4. The description affirmatively states 'No parameters needed', which confirms to the agent that an empty object is correct and no filtering arguments exist.

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 specific verb and resource ('Returns the caller's public egress IP address') and enumerates the payload (geolocation, ASN/ISP, datacenter/proxy detection). The resource is unique among siblings (resolve_dns, check_ports, list_proxies), so an agent can differentiate it without opening any schema.

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?

Gives two concrete use cases: verifying which IP/country traffic exits from, and confirming a VPN/proxy is active. There is no explicit when-not or named alternative, but the sibling set is disjoint enough that the intent is 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 declare readOnlyHint=true and idempotentHint=false. The description adds value by calling the utilities 'one-shot', noting cryptographically random password generation (which explains the non-idempotent flag), and providing a security caveat for MD5.

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 tight sentences with the operation list front-loaded and a single, earned parenthetical warning. No filler or repetition.

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 definition is largely complete for a simple utility tool: parameters are fully covered by schema and safety is covered by annotations. It does not specify the return format (e.g., hex digest for SHA-256, decoded string for base64_decode), which is a minor gap given no output schema exists.

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 schema already documents all parameters. The description only enumerates operations that match the enum and adds no extra syntax, format, or usage detail beyond what the schema provides.

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?

State a specific verb and resource: 'hashing/encoding utilities' with an enumerated list of operations. Siblings are network-oriented tools, so this is clearly distinct without needing to name an alternative.

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?

Explicitly warns that MD5 is for legacy checksum verification only and not for security, which is a clear when-not guidance. However, it does not explain when to choose SHA-256 vs SHA-512 or when to prefer base64 encode vs decode beyond the operation enum.

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 and idempotentHint, so the safety profile is covered; the description adds real behavioral value beyond that — periodic health-checking, per-entry last_checked freshness, and the unreliability caveat with retry advice. It stops short of describing result shape or pagination semantics.

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 sentences, front-loaded with what the tool returns and followed by filters and a caveat. No filler, though the anonymity-tier gloss repeats schema text that could have been trimmed.

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 usefully notes that each entry includes last_checked so freshness can be judged, and covers the filter surface. Pagination behavior (limit/offset defaults and max) and the return envelope are left to the schema, which is acceptable for a list 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 71%, so the schema already carries most parameter meaning. The description restates protocol/country/anonymity/max-latency filters and glosses L1/L2/L3, but the tier explanation largely duplicates the enum description and it omits limit/offset semantics. Baseline 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?

States a specific verb (Lists) and resource (tested-live public proxies) plus scope (HTTP/HTTPS/SOCKS4/SOCKS5, 150+ countries) and the health-check guarantee. No sibling deals with proxies, so an agent can instantly identify this as the proxy-source tool.

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?

Gives concrete consumption guidance ('always implement retry/fallback' because free proxies are unreliable) and enumerates the filtering axes, but offers no explicit when-to-use/when-not framing against an alternative. Clear context, no exclusions, which fits a 4.

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?

With annotations only declaring readOnlyHint=false and idempotentHint=false, the description adds genuinely useful behavior: ephemerality via TTL-based deletion, a 'zero-script secure viewer', and a concrete rate limit ('Free tier: 25 pastes/day'). It does not state auth requirements or whether the paste can be deleted early, but the quota disclosure goes beyond what the annotations provide and is consistent with a non-read-only, non-idempotent create.

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 tight sentences plus a quota line; the core verb and artifact are front-loaded, and the quota constraint is a fact an agent needs before calling. No filler or restatement of the name.

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 6-parameter tool with full schema coverage and no output schema, the description covers purpose, usage contexts, durability, and quota. The notable gap is that with no output schema, it never says what the caller receives back (presumably a shareable URL) or how long that URL remains valid to share.

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 ttl, format, language, and burn_after_reading are already fully documented in the schema. The description only loosely gestures at these ('syntax highlighting' hints at language, 'ephemeral' at ttl) without adding format, defaults, or enum meaning the schema lacks, so the 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?

The description gives a specific verb ('Creates') and a well-defined resource ('ephemeral, cleanly-rendered shareable text or Markdown paste page'), which is easy to separate from siblings like drop_file or create_temp_inbox. It stops short of explicitly naming or contrasting with any sibling, so it lands at clear-but-not-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?

'Use this when sharing code snippets, logs, prompt templates, or long markdown reports with users or other agents without formatting loss' is an explicit, concrete when-to-use statement with example payloads. There is no when-not guidance and no named alternative (e.g., drop_file for binary files), so it falls one step 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 and idempotentHint, so safety is covered. The description adds real behavioral detail beyond them: messages come with plain-text bodies plus auto-extracted 4-8 digit OTP codes and action links, and the tool is meant to be polled rather than called once.

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 with zero padding: what it reads, what the output contains, and when to call it. The most decision-relevant information comes first.

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

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

There is no output schema, so the description carries the return-value burden and does so by naming the body, OTP codes, and action links. The only gap is paging/result-limit behavior, which is left entirely to the schema.

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 only 33% – inbox_id is documented but limit and offset are not, and the description never mentions paging at all. The description reinforces where inbox_id comes from, but does not compensate for the undocumented pagination parameters.

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 specific verb and resource (reads messages in a temp inbox) and anchors it to the sibling that creates that resource, skuuy_create_temp_inbox. No other sibling involves inbox reading, so the tool is unambiguous.

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?

"Poll this after triggering a verification email" gives an explicit triggering condition and implies repeated invocation. It does not name an alternative tool or state a when-not-to-use case, but the workflow context is clear enough to act on.

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 only declare readOnlyHint and idempotentHint, yet the description discloses cleaning behavior (ads, cookie banners, nav chrome, script tags stripped), best-effort JS rendering, a zero-log privacy guarantee, and the honest limits around paywalls and CAPTCHAs. That is substantial behavioral context beyond the structured fields.

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 front-loaded sentences with no filler, leading with what the tool returns. Minor redundancy from "best-effort" appearing twice, but each clause still carries information.

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 and only a single sentence on the return payload, the description does well by stating the markdown/cleaned output explicitly. The main remaining hole is the undocumented format and timeout parameters, which an agent must infer from the schema alone.

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 33% – only url is documented, while format (enum markdown/text) and timeout_s (5-60s default 20) carry no descriptive text. The description does not compensate: "returns clean markdown" hints at the format default but never explains the text option or the timeout bound.

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?

"Fetches any public URL and returns clean markdown" is a precise verb+resource+output statement. It cleanly separates this content-retrieval tool from siblings like skuuy_resolve_dns, skuuy_check_ports, or skuuy_get_egress_ip, which are network probes rather than page readers.

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 "Honest scope" sentence gives an explicit exclusion: hard anti-bot challenges/interactive CAPTCHA are not bypassed, and soft paywalls/JS pages are best-effort. It stops short of naming an alternative tool for those blocked cases, so routing is only partly resolved.

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 and idempotentHint, lowering the burden. The description still adds real value: it discloses the two execution modes, the global edge PoP fan-out behavior, and that DNSSEC validation status is included. It does not discuss rate limits, caching, or failure behavior, but it is well above the annotation baseline.

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 tight sentences: core purpose first, then the mode-selection rule keyed to 'locations', then the record-type and DNSSEC surface. No filler and the most decision-relevant information is front-loaded.

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 return-shape burden and does so reasonably: it describes both the single-lookup result and the propagation matrix. It could say more about matrix structure or DNSSEC status values, but for a read-only resolver with only one required parameter, an agent has enough to call it 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 coverage is 67%, with 'domain' and 'locations' documented in the schema. The description adds meaning beyond the schema by explaining what 'locations' actually produces (a propagation matrix across edge PoPs) and by enumerating the full set of supported record types that the 'types' enum allows. Only the practical limit/format nuances of the arrays are left implicit.

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 specific verb and resource ('Resolves DNS records for a domain') and immediately distinguishes the two operational modes: single edge-resolver lookup versus propagation matrix. An agent can predict both the purpose and the two distinct result shapes without opening the schema.

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?

Explicitly ties the 'locations' parameter to a use case ('useful to verify DNS changes propagated worldwide'), which is genuine when-to-use guidance. It lacks any when-not or exclusion guidance (e.g., when to prefer a sibling tool or when NOT to use many locations), 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?

Beyond the readOnlyHint and idempotentHint annotations, the description adds substantive behavioral context: zero-logging, no authentication required, a concrete rate limit (2,500 calls/day/IP, shared via the MCP server), and server-side rejection of write methods. This is exactly the kind of detail an agent needs to call the tool safely and avoid hitting quota or method errors.

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 front-loaded paragraph that states purpose first, then operational details. Every sentence carries useful information (no-key access, chain list, quota, write rejection), though the chain enumeration is redundant with the schema and could be trimmed.

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 moderate-complexity read-only RPC proxy with full schema coverage and existing annotations, the description covers what an agent needs: scope, chain set, auth model, rate limits, and method restrictions. Return values are standard JSON-RPC responses and require no separate output schema.

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 schema already documents chain, method, and params with examples. The description repeats the chain list and method examples but adds no new syntax, format, or constraint information beyond what the schema provides, so the 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?

The description states a specific verb and resource ('Sends a read-only JSON-RPC call through the Skuuy Private RPC Relay') and enumerates the exact scope: 12 named EVM chains. It is immediately distinguishable from siblings like resolve_dns or hash_encode, which serve unrelated utility purposes.

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 clear context (zero-log, no API key, no signup, free tier) and an explicit exclusion: write methods like eth_sendRawTransaction are rejected server-side. However, it does not frame when an agent should pick this tool over other data-access approaches, though no direct sibling alternative exists.

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 safe read-only, idempotent, open-world behavior, so the bar is lower. The description adds real value by disclosing the directory size (41 APIs), that most need no API key, and that results are continuously health-verified by edge probes — none of which is in 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?

Front-loaded with the use case, then the scope, then the return fields. Three dense sentences with no filler, though the return-field enumeration could arguably be tightened.

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 no output schema, the description compensates by naming exactly what each result contains (name, purpose, category, auth requirement, docs link, sample endpoint). Combined with 100% param coverage, an agent has everything needed to call and interpret the 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 coverage is 100%, so every parameter is already documented in the schema itself. The description's example keywords ('weather', 'crypto prices') echo the query and category parameters but add no format or syntax guidance beyond what the schema provides. Baseline 3.

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 specific verb (Searches) and resource (Skuuy's live directory of public APIs) with scope (41 health-checked APIs, no key required for most). Clearly distinguishes it from the other skuuy utility siblings like resolve_dns or check_ports, which serve unrelated tasks.

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?

Gives a concrete triggering condition ('Use this when you need a free public REST API for a task') and enumerates example domains (weather, crypto prices, geocoding, news, AI models). No explicit alternatives or exclusions are named, but the context is unambiguous for a search tool.

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