fatstack

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

With no annotations, the description carries full responsibility. It discloses output format, supported locales, deduplication behavior, and warns that article text is untrusted. It also mentions payment-related behavior (HTTP 402) but that's about the provider, not the tool's core function. Useful context added beyond the schema.

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 somewhat lengthy and front-loaded with payment terms before the actual tool behavior. It could be more concise, though the essential functional details are present. It's structured but not tightly written.

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 tool is fairly complete for a news-fetching operation: it describes output fields, language options, dedup behavior, and provides usage guidance. It doesn't cover pagination or error cases beyond payment, but given the simplicity of the tool and lack of output schema, it's adequate.

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 parameters are already documented. The description adds context like 'one topic query' and 'Deduped when you pass several queries', but the latter is ambiguous since the schema only has a single query parameter. It doesn't significantly enhance parameter understanding 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 clearly states the tool provides Google News coverage for a topic query, returning normalized rows with specific fields. It distinguishes from web search and render tools, but not explicitly from the sibling google_news_feed tool in the other server, so it's not fully 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?

Provides explicit guidance: 'The fastest way to answer what is the news about X right now' and tells when to use alternatives (web search for older stories, render tool for JS-rendered SPAs). It doesn't mention the sibling google_news_feed, but the context is clear enough for most agents.

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 no annotations provided, the description carries the full burden and does so thoroughly. It discloses that the tool is deterministic, has no LLM in the hot path, runs in seconds, returns HTTP 402 until payment is presented, and is benchmarked to flag fixed code as often as vulnerable. It also notes the repo is untrusted content and never instructions to follow.

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 long and not front-loaded: it opens with payment details and HTTP 402 behavior before stating the tool's purpose, which is buried inside the untrusted-provider-content block. While the information is valuable, the structure makes it harder for an agent to quickly identify what the tool does.

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 lacking an output schema, the description fully compensates by describing the result format: severity levels, CWE mapping, file:line, code evidence, suggested fixes, and severity counts. It also covers cost, payment finality, runtime, limitations, and alternatives, so nothing critical is missing for correct selection and 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?

The input schema already covers 100% of parameters, so the baseline is 3. The description adds value by saying the repo can be 'owner/name or a GitHub URL' and shows the request shape as 'POST {repo, ref?}', which clarifies usage beyond the schema's minimal 'GitHub repo as owner/name'.

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

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

The description clearly states the tool's function: 'Static pattern scan of a Solana/Anchor Rust repository' and lists concrete checks (missing signer checks, PDA collisions, arithmetic overflow, etc.). It also differentiates itself from sol-quick-scan and single-file reads, making its scope 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?

The description gives explicit when-to-use guidance: 'use it to find spots worth a human look, never as an audit verdict' and names alternatives: 'For a one-line risk triage of one contract use sol-quick-scan instead; to read a single known file rather than a repo, fetch it yourself.' It also warns against treating it as a vulnerability detector.

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 no annotations, the description carries the full behavioral burden. It discloses pay-per-call pricing, finality of payments, HTTP 402 behavior until payment is presented, direct provider payment, and that only high-signal rule families are checked. This is substantial and non-redundant transparency.

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 structured and front-loaded with payment terms, then the functional listing. There is minor redundancy around payment finality ('payments are final', 'cannot be reversed', 'no refunds'), but every section contributes necessary information for using a paid tool.

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 paid tool with no annotations and no output schema, the description provides everything needed: price, payment behavior, input format, expected verdict values, counts, top findings with file:line, and routing to sol-audit. Nothing essential for correct selection or invocation 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?

Schema coverage is 100%, so the schema already documents repo as GitHub owner/name and ref as the git ref defaulting to master. The description's POST {repo, ref?} notation adds little semantic meaning 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 listing clearly identifies this as a Solana/Anchor security scan returning a go/no-go verdict for one contract, with explicit rule families and output values. It is also distinguishable from the sibling sol-audit by contrasting 'quick scan' with 'full audit'.

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 explicit when-to-use guidance: run it before interacting with a contract or buying the full audit, and route to sol-audit when the verdict is NEEDS_REVIEW or DO_NOT_INTERACT. It also tells the agent to skip this tool and go straight to sol-audit when comprehensive findings are already required.

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 no annotations, the description carries the burden. It discloses payment terms, HTTP 402 behavior, that payments are final and non-refundable, and that article text is untrusted data. It also describes return format and dedup behavior. Slight gap: no mention of rate limits or auth, but overall strong transparency.

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 lengthy but all content is relevant. It front-loads the core purpose, then details return format, usage guidance, and payment. The two-part structure (payment disclaimer and provider content) is clear, though slightly verbose.

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 fetch tool with 4 parameters and no output schema, the description covers purpose, return format, parameters' meaning, usage boundaries, payment, and security caveats. Nothing critical is missing for an agent 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 100%, so baseline is 3. The description adds value by explaining query types (brand, competitor, person, exact phrase), dedup behavior, and locale availability, which enriches understanding beyond the schema's basic field descriptions.

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+resource: 'Current Google News coverage for one topic query' and returns normalized rows. It clearly identifies the tool's function and contrasts it with web search and render tools, making its scope 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?

Explicitly says when to use: 'The fastest way to answer what is the news about X right now' and when not: 'for stories older than the RSS window use a web search tool instead; for JS-rendered SPAs use a render tool.' Also notes deduping for multiple queries, giving clear usage context.

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 discloses important behavioral traits beyond annotations: it is deterministic static analysis with no LLM in the hot path, runs in seconds, returns HTTP 402 until payment is presented, and payments are final/non-refundable. It also clearly warns about the tool's limitations (flags fixed code as often as vulnerable). The only minor gap is not detailing exact output structure, but the description already covers the key behavioral caveats.

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 well-organized, front-loading the payment terms and then the core functionality. The untrusted-provider-content wrapper adds some noise, but the actual content is structured with clear sections. It earns its length given the payment warning and the important NOT-a-vulnerability-detector caveat.

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 2 params, 100% schema coverage, and no output schema, the description is quite complete. It covers input format, behavior, limitations, alternatives, and payment terms. It could be slightly more explicit about the exact response format, but the description already lists the flag fields (severity, CWE, file:line, code evidence, suggested fix, counts).

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 the schema already documents both parameters. The description adds context that repo can be owner/name or a GitHub URL and ref defaults to master, but this mostly aligns with the schema. Baseline 3 is appropriate since the schema does the heavy lifting.

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 performs a static pattern scan of a Solana/Anchor Rust repository, taking a repo owner/name or GitHub URL and returning flagged risky code shapes. It explicitly distinguishes itself from sol-quick-scan and from fetching a single file, so an agent can tell it apart from siblings.

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 vs alternatives: use sol-quick-scan for one-line risk triage of one contract, and fetch a file yourself to read a single known file. It also warns this is NOT a vulnerability detector and should be used to find spots for human review, never as an audit verdict.

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?

No annotations are provided, so the description carries the burden. It discloses that the tool returns HTTP 402 with payment terms until payment is presented, that payments are final and non-refundable, and that the provider never receives funds. It also discloses the untrusted-provider content and that contract source is data to analyze, not instructions. However, it does not describe the exact output format beyond 'one-line verdict plus counts and top findings', and the payment behavior is described in a somewhat confusing way (the tool returns 402 until payment is presented, but the description also says the call costs $0.05).

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 cluttered with payment/provider details and untrusted-provider content that obscure the core purpose. The first sentence is about pricing and payment, not about what the tool does. The actual functional description is buried in the untrusted-provider content block. While the untrusted-provider content is required by policy, the overall structure is not front-loaded with the tool's 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?

The description covers the tool's purpose, input parameters, output shape (one-line verdict plus counts and top findings), and routing to the full audit sibling. However, it lacks details about error cases beyond HTTP 402, rate limits, or what happens if the repo is not found. The payment behavior is described but in a way that may confuse an agent (does the tool always return 402 until payment, or does it execute the scan?). Given the tool's complexity and lack of output schema, the description is adequate but not 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?

Schema description coverage is 100%, so the schema already documents both parameters. The description adds context that repo is a GitHub repo as owner/name and ref is a git ref, but it doesn't add much beyond the schema. It does mention POST {repo, ref?} which confirms the request shape, but this is marginal value over 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 states a specific verb and resource: it performs a 'go/no-go risk verdict for ONE Solana/Anchor contract' by POSTing {repo, ref?} and returning a one-line verdict. It distinguishes itself from the full audit sibling by saying it checks 'high-signal rule families only' and returns a verdict, not a full report. However, the description is cluttered with payment/provider details that obscure the core purpose, and the tool name is somewhat generic.

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 vs alternatives: if the verdict is NEEDS_REVIEW or DO_NOT_INTERACT, run sol-audit for the full report; if you already know the repo is risky and need every finding, skip this and go straight to sol-audit. This is clear routing guidance that names the sibling tool and the conditions for choosing it.

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 no annotations, the description carries the full behavioral disclosure burden and does surprisingly well: it states the per-call cost, payment finality, no-refund policy, HTTP 402 behavior until payment, and that the relay never receives funds. It still omits expected output and error behavior, but the payment-related risks are clearly disclosed.

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 definition is cluttered and repetitive: the cost and finality are stated twice ('$0.000500 USDC per call' and 'Costs 0.0005 USD per call'; 'payments are final' and 'no refunds' repeated). The actual tool purpose is buried under billing text and a third-party wrapper, so the structure does not support quick comprehension.

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 gives essential payment mechanics and a one-line purpose, but it is incomplete for a paid tool with no output schema. It does not explain the meaning of two parameters, what the returned plain-English output looks like, or how an agent is expected to present payment. More context is needed before an agent can invoke it correctly and safely.

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%, and only 'expression' has an example ('0 9 * * 1-5'). The description adds useful context that expression supports 5-field and 6-field seconds, but it says nothing about 'verbose' or 'dayOfWeekStartIndexZero', leaving two of three parameters semantically opaque.

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 functional statement is present: 'Turns a cron expression into plain English, with 5-field and 6-field (seconds) support and validation.' That gives a specific verb, resource, and scope. However, it is buried inside an untrusted-provider-content block after extensive payment boilerplate, so the purpose is clear but not front-and-center.

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?

No explicit when-to-use guidance or alternatives are given. The description implies 'use this when you need to explain a cron expression,' but it never states selection criteria, excludes other tools, or describes prerequisites. The payment details and HTTP 402 behavior do not help an agent decide when to invoke this tool.

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 discloses important behavioral traits beyond the schema: per-call cost, finality of payments, non-refundability, HTTP 402 until payment is presented, and the relay role of Fatstack. With no annotations, this is valuable transparency about the tool's monetization and failure mode. It does omit success-path details like response format, but the most consequential behavioral risks are covered.

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 opens with billing details rather than purpose, and repeats 'final/no refunds' content in both the trusted narrative and the untrusted block. The substantive functional description is deferred to an untrusted section, which is poor front-loading. Several sentences are consumed by payment context without earning their place for tool selection.

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 no annotations, the description must supply output, error, and usage context itself. It provides payment/partial-warning behavior but does not explain the success response, how to present payment after a 402, or the practical meaning of header detection/delimiter inference. This is incomplete for an agent deciding whether and how to call 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 description coverage is 50%, leaving the required 'csv' and 'header' params without schema descriptions. The untrusted listing loosely maps to parameters ('header detection' → header, 'delimiter inference' → delimiter, 'type coercion' → dynamicTyping), but it is untrusted and not authoritative. The description adds a little meaning but does not fully compensate for the schema's gaps.

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 trusted portion of the description is entirely payment terms and never states what the tool does. The only functional statement—'Parses RFC 4180 CSV into JSON rows'—appears inside <untrusted-provider-content>, which is explicitly flagged as third-party data, not instructions. The tool name and input schema make the purpose clear by inference, but the authoritative description itself is functionally vague.

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?

No guidance is given on when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. The payment text and untrusted listing imply CSV-to-JSON conversion, but there is no explicit 'use this when...' direction, and sibling differentiation is absent.

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 no annotations, the description carries the full burden. It transparently discloses that the tool is paid (0.001 USDC), payments are final, and that it returns HTTP 402 until payment is presented. It also explains that Fatstack relays the quote and never receives funds. This is more disclosure than typical. The only omission is the exact nature of the 'server-side call metadata', but the core behavior is well covered.

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 lengthy and not front-loaded. It begins with cost details, then repeats payment information, and only later (in the untrusted-provider-content block) states the actual purpose. There is redundancy (cost mentioned multiple times) and the core function is buried. A more concise, purpose-first structure would be more effective.

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 echo tool with one parameter and no output schema, the description covers the payment prerequisite and the 402 behavior, which is crucial. However, the phrase 'with server-side call metadata' is vague—it does not explain what metadata is included or in what format. Since there is no output schema, this ambiguity is a notable gap, though the overall behavior is mostly clear.

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 describes the single parameter 'payload' as 'Any JSON object to echo back.' The description's phrase 'Returns the JSON object you sent' adds no new semantic detail beyond what the schema provides. With 100% schema coverage, the baseline of 3 applies; the description does not compensate with additional parameter guidance.

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 returns the JSON object sent, unchanged, with server-side call metadata. This is a specific verb+resource combination that distinguishes it from the unrelated sibling tools (news feeds, audits, converters). The core purpose is unambiguous even though it is buried in payment details.

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 mentions the payment requirement and that HTTP 402 is returned until payment, which is a condition of use. However, it does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention any exclusions. Since siblings are unrelated, the lack of explicit usage scenarios is a minor gap but still leaves the agent without clear decision criteria beyond the basic function.

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 no annotations provided, the description carries full responsibility for behavioral disclosure. It reveals critical traits: it drops scripts and styles, does not fetch external content, costs $0.001 USD in USDC, payments are final and non-refundable, and it returns HTTP 402 until payment. This goes well beyond typical transparency.

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 verbose and redundant: payment details appear twice (once in the main description and again in the untrusted-provider content), and the core purpose is buried after a lengthy technical payment notice. The essential 'Converts HTML to Markdown' sentence appears only at the end, making it poorly 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?

The description covers the main functionality, payment terms, and key behaviors (dropping scripts/styles, not fetching). However, it leaves the two optional parameters unexplained and does not describe the output format or error behavior. Given the low schema coverage, this is a notable gap that prevents full understanding.

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 description coverage is only 33% (only 'html' has a description). The tool description does not mention 'bulletMarker' or 'headingStyle' at all, and the enums and defaults are self-explanatory only to someone already familiar with Markdown. The description fails to compensate for the low schema coverage, adding no meaning beyond the raw enum values.

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 'Converts an HTML fragment or document to Markdown' with a specific verb and resource, and adds 'Takes HTML you supply; it does not fetch anything,' which clearly distinguishes it from URL-fetching sibling tools like url-metadata. This is a precise, unambiguous purpose.

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 phrase 'Takes HTML you supply; it does not fetch anything' clearly implies that the tool is appropriate when HTML content is already available, not when a URL needs to be retrieved. However, it does not explicitly name alternative tools or state when not to use it, so guidance is implicit rather than explicit.

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 discloses significant behavioral traits beyond the schema: the tool costs 0.001 USD per call, payments are final and non-refundable, and it returns HTTP 402 until payment is presented. It also clarifies that the provider never receives funds and relays a quote. This is valuable context for an agent deciding whether to invoke the 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?

The description is somewhat bloated with payment terms and untrusted-provider content, but the core functional sentence is clear and front-loaded. The payment details are necessary for behavioral transparency but could be more concise. The untrusted-provider wrapper adds noise.

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 validation tool with 3 parameters and no output schema, the description covers the core function, supported drafts, and critical payment behavior. It doesn't describe the return format, but the description says it returns every error with its instance path, which is sufficient for an agent to understand the outcome.

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 67%: 'data' and 'schema' have descriptions, but 'draft' only has an enum and default. The description adds the supported draft versions (2020-12, 2019-09, draft-07), which maps to the 'draft' parameter, but it doesn't add much 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 states a specific verb and resource: 'Validates a JSON document against a JSON Schema' and lists supported drafts. It clearly distinguishes the tool's function from siblings like regex-test or csv-to-json, though it doesn't explicitly name a sibling 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?

The description implies usage context: use this tool when you need to validate a JSON document against a JSON Schema and get every error with its instance path. It does not explicitly state when not to use it or name alternatives, but the context is reasonably 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It discloses pricing, finality of payments, no-refund policy, and the HTTP 402 behavior until payment is presented. However, it does not describe the output format or explicitly state that the tool is read-only, so it is not fully transparent.

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 repetitive and not front-loaded: payment terms are stated twice, and the actual purpose is buried inside an untrusted-provider block at the end. The core 'Lints Markdown...' sentence is the most valuable part but arrives late and is wrapped in third-party content.

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 two-parameter tool with no output schema and no annotations, the description should explain both parameters and the return shape. It covers purpose and payment behavior but omits parameter semantics, expected output, and any usage constraints beyond cost. This is incomplete for an agent deciding whether and how to call it.

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 0%, so the description must compensate. It implies that the `markdown` parameter is the text to lint, but it never names parameters or explains `maxLineLength`. The mention of 'long lines' is the only indirect hint at line-length configuration, which is insufficient for an agent to confidently set 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?

The untrusted-provider listing clearly states 'Lints Markdown for trailing whitespace, hard tabs, long lines, heading jumps, missing image alt text, bare URLs and unclosed code fences.' This is a specific verb plus resource with enumerated behaviors. It distinguishes the tool from its unrelated siblings and leaves no doubt about what it does.

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 implies usage whenever Markdown needs linting, but it does not explicitly state when to use it, when not to use it, or mention alternatives. Since none of the sibling tools are Markdown linters, the lack of alternative routing is less damaging, but the guidance is still only implicit.

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 no annotations, the description carries the full burden. It does disclose the payment requirement, HTTP 402 behavior, and that payments are final/non-refundable, plus the return of matches with groups and offsets. However, it omits behaviors like handling invalid regex, flag effects, limit semantics, and error responses, leaving significant gaps in behavioral disclosure.

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 cluttered with repeated payment information, a security notice tag, and legal disclaimers, while the actual functional purpose is a single sentence embedded in an untrusted-provider-content block. The structure is not front-loaded; the agent must wade through payment terms before reaching a clear statement of what the tool does.

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 regex-testing tool, the description is incomplete. It does not explain the format of returned matches or offsets, how flags alter behavior, what limit controls, or any error handling. With no output schema, these details are critical for correct invocation. The payment info is over-specified while functional details are under-specified.

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 0%, so the description must compensate. It only hints at 'pattern' and 'text' via 'regular expression' and 'sample text,' fully omitting 'flags' and 'limit.' No description of allowed patterns, max lengths, or defaults is provided beyond the schema's own constraints. This is insufficient for a tool with four 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?

The description includes 'Tests a JavaScript regular expression against sample text and returns every match with its groups and offsets,' which specifies a clear verb, resource, and outcome. It distinguishes the tool from siblings like csv-to-json or url-metadata, though the functional purpose is buried within payment and third-party content, slightly reducing clarity.

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 no guidance on when to use this tool versus alternatives, no explicit use cases, and no 'when-not' conditions. The payment-heavy text might imply caution but does not steer an agent toward or away from this tool in comparison to others. Usage context is absent.

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 no annotations, the description carries the full burden and does so strongly: it discloses per-call cost, final/non-refundable payments, direct provider payment, HTTP 402 until payment is presented, and that the relay never receives funds. It also states that processing runs locally on n-gram models and no external service sees the text.

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 readable and front-loads important payment terms, but it repeats cost and final-payment details across the main text and the untrusted-provider block. Some sentences, such as the redundant 'Language detect' heading and repeated payment warnings, do not earn their place.

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

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

The description covers cost, payment mechanics, HTTP 402 behavior, local privacy, and the high-level return type, which is good for a tool with no annotations. However, it omits explicit topN semantics and the exact returned structure, leaving some uncertainty about optional parameter behavior and output format.

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 low at 33%, yet the description adds little parameter-level meaning beyond what the schema already provides. It does not explain that topN controls how many ranked candidates are returned, and the minLength explanation largely duplicates the schema's existing 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 description clearly states a specific function: 'Detects the language of a text sample and returns ranked ISO 639-3 candidates with confidence.' This gives a concrete verb, resource, and result type, and clearly distinguishes it from the unrelated sibling tools.

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 intended use is implied through 'Detects the language...' and contextual notes like local execution and minLength refusal, but there is no explicit 'use when' or 'do not use when' guidance. No alternatives are named, though the sibling set does not contain a comparable language tool.

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 no annotations, the description carries the full behavioral burden, and it does well by disclosing payment requirements, HTTP 402 behavior, finality of payments, and the fact that Fatstack never receives the funds. It also states conversion accuracy characteristics such as exact factors and correct temperature offset handling. It does not describe output format or error behavior, which prevents a higher score.

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 reasonably sized but repeats payment terms in both the outer text and the untrusted-provider content. The core functionality is buried inside the untrusted-provider block, and the opening is dominated by payment and trust disclaimers rather than the tool's primary 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?

The description covers the essential conversion categories, payment flow, and temperature exception, but it omits return-value details, accepted unit identifiers, and how `precision` is used. Given the lack of an output schema and only 25% parameter coverage, an agent would need additional discovery to use the tool fully 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?

Input schema coverage is only 25%, and the description does not meaningfully compensate. It does not explain the `to`, `value`, or `precision` parameters beyond the schema, and it does not enumerate accepted unit strings beyond the example already present for `from`.

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 description clearly states the tool 'Converts between length, mass, volume, time, digital-storage and temperature units', which names a specific verb and resource. It also adds a useful behavioral distinction by noting temperature handles offsets correctly, and no sibling tool performs a similar function.

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

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

The description gives clear context that the tool is for unit conversion and lists the supported categories, so an agent can infer when to use it. It does not explicitly state when not to use it or name alternatives, but no sibling tool is a unit-conversion alternative, so the absence of exclusions is acceptable.

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 no annotations, the description fully carries the disclosure burden. It reveals the paid nature, exact cost, recipient, finality/no-refunds, HTTP 402 gating, relay arrangement, single-fetch limitation, and that page content is not stored. This is far richer behavioral context than most tool descriptions provide.

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 repetitive and heavily padded with billing language: the cost appears twice and 'payments are final/no refunds' appears twice. The core functional sentence is buried inside an untrusted-provider content block after a lengthy payment warning, so it is not front-loaded or tightly structured.

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 tool with no output schema and no annotations, the description covers the essential operational context: return fields, single-fetch behavior, no content storage, and payment/402 behavior. It is not fully complete because it does not explain how a payment should actually be presented or describe the response shape beyond field names.

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 schema already describes 'url' as 'A public http(s) URL.' The description adds that only one URL is fetched and that it must be public, but it does not provide meaningful new parameter-level semantics 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 clearly states a specific verb and resource: 'Fetches one public URL you supply and returns its title, description, canonical URL and OpenGraph tags.' It also adds a sharp boundary with 'Single fetch only — it does not crawl, follow links, or store page content,' which distinguishes it from broader scraping behavior. The tool name and listing agree on the exact function.

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 explicit when-not-to-use context: it is a single-fetch tool that does not crawl, follow links, or store page content. That tells an agent this is not the choice for multi-page or bulk scraping. It stops short of 5 because it does not name a specific sibling/alternative to route to when those broader behaviors are needed.

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 no annotations, the description fully discloses the monetary side effect: exact cost, chain, recipient address, finality, no refunds, and HTTP 402 until payment. It also explains the provider relationship. This is exceptional behavioral disclosure for a paid 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?

The main description repeats payment terms that the untrusted listing also states ('no refunds', cost per call), and it front-loads payment details instead of the tool's function. The added payment facts are relevant, but the redundancy and lack of purpose-first structure make it less concise.

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 generator, the description covers cost, payment flow, and the core function, but no output schema exists and the description never states the response shape (e.g., array of strings). The payment workflow is described but not how to complete payment after the 402. This is adequate but incomplete.

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 0%, so the description must compensate for all three parameters. It explains 'compact hex or uppercase' (format/uppercase) but never addresses count or the 'hyphenated'/'urn' enum values. The schema's defaults and maximum are not reinforced in prose.

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 listing content states 'Generates a batch of cryptographically random UUIDv4s, optionally as compact hex or uppercase,' giving a specific verb and resource. However, the main description itself only discusses payment and HTTP 402, so the purpose is clear only if the agent reads the untrusted listing; it is not misleading but not fully owned by the tool description.

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?

No sentence says when to use this tool instead of another or when not to use it. The only context is payment behavior and a generic generation statement; no exclusions or alternatives are provided.

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