SaaSCity

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

Beyond the readOnly/idempotent annotations, it discloses meaningful behavior: the tool also reads the homepage for deep pages, renders JavaScript when static HTML is insufficient, and explains that a verified badge makes the listing link dofollow. No contradiction with annotations exists.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Three compact sentences that front-load purpose, then detail scanning behavior, then state the meaningful consequence. There is no filler, repetition of annotations, or redundant schema 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 single-parameter, read-only tool with existing annotations and an output schema, the description covers the essential operational context: what gets scanned, the homepage fallback, and the dofollow implication. It is nearly complete, though it leaves detailed output interpretation to the 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?

With 100% schema description coverage for the single required url parameter, the baseline is 3. The description adds the conditional homepage-reading nuance, but does not introduce format or syntax guidance beyond what the schema already 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?

States a specific verb and resource: checking whether the SaaSCity badge is live on a site. It also describes observable behaviors (reading URL, homepage fallback, JS rendering), so an agent can clearly distinguish it from siblings like check_launch_readiness or get_listing.

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 the use case: verify badge liveness on a site. However, it does not explicitly state when to prefer this tool over alternatives or provide any exclusion criteria, leaving the selection logic mostly to the agent.

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, openWorldHint=true, and idempotentHint=true, so the safety profile is covered. The description adds genuine behavioral value beyond that: it discloses that og:image is actually fetched to confirm it loads (an outbound network side effect beyond the main URL), that it reads static HTML the way directory scrapers and link-preview bots do, and that it detects JS-empty pages. These are useful non-obvious behaviors an agent could not infer from annotations alone.

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 purpose is front-loaded, and the description is dense with information rather than padded. The long enumeration of checks is justified because it conveys the audit scope precisely and lets an agent match it to user intent. Slightly long as a single paragraph, but every clause earns its 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?

For a single-parameter tool with a rich output schema and safety annotations, the description is complete: it states the purpose, the full audit scope, the return shape (score, verdict, fix), and the reading behavior. Since an output schema exists, the description need not detail return fields, and the annotations cover the read-only/idempotent safety profile.

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 documents 'url' as the Homepage URL with the https:// prefix optional. The description reinforces that the URL should be a homepage and implies the audit targets that URL, but it adds no new format, constraint, or meaning 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 opens with a specific verb+resource pair ('Audit a product homepage before launching it') and then enumerates a concrete checklist (HTTPS, noindex, meta, og:image, canonical, etc.), leaving no doubt about what the tool does. None of the sibling tools (check_badge, get_listing, submit_project, etc.) perform auditing, so the scope is clearly differentiated.

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 'before launching it' gives clear usage context and timing. However, it does not name alternatives or state explicit when-not-to-use conditions. Since no sibling tool is a close substitute, the absence of explicit exclusions is acceptable, placing this at clear-context-without-exclusions rather than full alternative routing.

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 no safety disclaimer is needed. The description adds behavioral context beyond those: it returns only other listings in the same category and sorts them 'most upvoted first,' which an agent cannot infer from the schema or annotations alone.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two sentences with no filler: the first defines the tool's behavior and output ordering, and the second supplies a practical use case. Every word earns its place, and the most important 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?

The output schema is present, so return-value details are already specified. The description covers selection logic, ordering, and use case; the schema covers parameters; and annotations cover safety. Nothing essential is missing for an agent to invoke this tool correctly.

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

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

Schema description coverage is 100%: both 'slug' and 'limit' have descriptive text in the input schema. The description's 'given listing' implicitly refers to slug but adds no parameter semantics beyond what the schema already provides, so the baseline score of 3 applies.

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

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

The description states a specific outcome: 'Other SaaSCity listings in the same category as a given listing, most upvoted first.' It makes clear the resource (SaaSCity listings), the selection logic (same category), and the ordering, which distinguishes it from siblings like search_listings, get_listing, and get_leaderboard.

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 'Useful for competitor research and positioning' provides a clear use case, but the description does not explicitly guide the agent on when to choose this tool over related alternatives such as search_listings or get_listing. The usage guidance is implied by the definition rather than stated as a decision rule.

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

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

Annotations already provide readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds valuable behavioral context by warning that link type and price may be 'unknown' and should be treated as unverified rather than as free or dofollow. This goes beyond the annotations and helps the agent interpret results correctly.

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 two sentences with no fluff. The first sentence front-loads the action and criteria, the second covers the return type and a crucial data-quality caveat. Every sentence earns its place, and the structure is logical.

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 9 parameters and an existing output schema, the description covers the core purpose and adds a critical caveat about unverified values. It does not mention pagination, sorting, or result count, but these are handled by the schema parameters. The description is sufficiently complete for an agent to invoke the tool correctly, given the rich structured metadata.

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 documents all 9 parameters with descriptions and enums, achieving 100% coverage. The description does not add meaning to the parameters themselves; it merely lists some filter criteria already present in the schema. The 'unknown' caveat pertains to result values, not input semantics. Since coverage is high, the baseline of 3 is appropriate.

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

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

The description clearly states the tool filters startup/SaaS/AI directories by multiple criteria (category, DR, link type, price, badge swap) and returns submit URLs. The verb 'Filter' is specific and the resource is explicit. It does not explicitly contrast with sibling tools like find_alternatives or search_listings, but the purpose is unambiguous and not a tautology.

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 offers no guidance on when to use this tool versus alternatives. It does not mention any exclusions or contexts where another tool (e.g., recommend_launch_directories or get_launch_directory) would be more appropriate. The reader is left to infer usage from the filtering semantics alone.

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

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

Annotations already cover readOnlyHint=true, idempotentHint=true, and openWorldHint=false. The description adds behavioral detail by noting that input can be a domain or any URL, and that the human verdict may not exist ('where one exists'). This goes beyond the structured annotations without contradicting them.

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 two sentences with no filler. The core action is front-loaded, followed by a compact attribute list and a practical use case, making every sentence earn its 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?

Given a single well-documented parameter, an output schema, and annotations covering safety and idempotency, the description provides all needed context: what data is returned, how to identify the directory, and why to use the tool. Nothing critical 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% and the domain parameter's description is fully self-explanatory with examples. The description repeats 'by domain or URL' but adds no new semantic information beyond what the schema already 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 ('Look up one directory') and enumerates the exact data returned (Ahrefs DR, dofollow/nofollow, price, badge swap, submit URL, human verdict). This clearly differentiates it from siblings like find_launch_directories (plural) and recommend_launch_directories by emphasizing singular lookup and the vetting use case.

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 an explicit usage context: 'Use it to vet a directory before paying for a listing.' This tells the agent when to invoke it, but it does not name alternatives or state when not to use it, so it misses the full exclusion guidance required for 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 concrete behavioral detail: it returns the next 12 Mondays, remaining free-slot counts, and full/not-full status. It explains exactly what kind of data the caller will receive, even though the output schema is available.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

Two short, information-dense sentences. The first states the core output, and the second states the practical use case. Every word earns its place, with no repetition of the title or schema.

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 parameterless, read-only, idempotent tool with an output schema, the description is complete. It covers what the tool returns)Skip and why an agent would call it, leaving no missing behavior that the agent needs to invoke 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?

There are zero parameters, so the input schema already fully covers the calling contract. The baseline for a parameterless tool is 4; the description adds no unnecessary parameter commentary, which 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 identifies the resource: SaaSCity's launch-week queue over the next 12 Mondays, and specifies what the tool reports (free slots left and full weeks). This is a direct, unambiguous statement of the tool's function and distinguishes it from siblings like get_launch_directory.

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 final sentence gives an explicit use case: telling a founder when a free listing would go live. It does not name alternative tools or state when not to use it, but for a zero-parameter read-only queue listing, the intended context 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 declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds that results are 'most upvoted' and filterable by period/category, but it does not disclose pagination behavior, tie-breaking, or any other operational detail 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 one focused sentence that front-loads the resource and immediately states the filtering dimensions. There is no filler, repetition, or ambiguity-added wording.

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 read-only tool with zero required parameters, full schema coverage, an output schema, and safe annotations, the description is largely complete. A minor gap is that it does not reference sibling tools like get_launch_weeks to help with launch week semantics, but this is not essential 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 each parameter already has descriptions, defaults, and enums where applicable. The description adds only a light gloss — 'last 30 days' for the month period and optionality for category — which meets the baseline but does not substantially exceed the schema's own documentation.

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

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

The description names a specific resource — 'SaaSCity's most upvoted launches' — and the exact scope dimensions: current week, last 30 days, all time, and optional category. This clearly distinguishes the leaderboard tool from sibling search/list tools like search_listings or get_listing.

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 context for use: retrieve ranked launches by selecting a period and optionally a category. It does not explicitly name alternatives or state when not to use it, but the scope is unambiguous enough that an agent can decide appropriately.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, so the agent knows it's a safe, read-only call. The description adds that it retrieves a 'live' listing, implying the listing must be live, and it specifies the exact fields returned and the slug format, which provides useful behavioral context beyond the annotations. The description does not contradict annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence, concise and front-loaded with 'One live SaaSCity listing by slug', immediately stating the purpose and parameter. It lists the return fields efficiently without excessive detail. It's slightly dense but earns its length.

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

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

For a read-only, single-parameter tool with a rich output schema and annotations covering safety, the description is complete: it specifies the input (slug), the output fields, and the nature of the data ('live'). It doesn't mention pagination or error cases, but those are less critical given the tool's simplicity and the annotations.

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

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

Schema coverage is 100%, as the schema fully describes the 'slug' parameter, including its meaning and format. The description also mentions the slug is the last part of the URL, which adds a little context, but since the schema already covers it, the description adds minimal extra semantics.

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 fetches a single SaaSCity listing by slug, and enumerates the fields returned. It distinguishes from siblings by specifying 'One live listing' and 'by slug', though it doesn't explicitly contrast with search_listings or get_leaderboard, so it's clear but not fully differentiated.

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 when you need a specific listing's details by slug, but it doesn't explicitly state when to use this versus search_listings (e.g., for filtering or searching) or get_leaderboard. It says 'One live ... by slug', which implies direct access, but no explicit guidance on alternatives or when not to use 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?

Annotations already declare readOnlyHint and idempotentHint, and the description adds valuable behavioral context beyond them: the offers are 'real prices' (not estimates or placeholders), and payment is restricted to a human on the claim page. This meaningfully informs the agent that the tool is safe to call but cannot complete transactions, which is critical behavioral information.

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 tightly packed sentences cover the product tiers, their benefits, and the key human-payment constraint without any filler. The most decision-relevant details are front-loaded and every clause earns its 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?

With no parameters, an output schema present, and annotations covering safety and idempotency, the description carries exactly the remaining contextual load. It explains what the offers are, what they include, and the critical human-only payment constraint, so an agent has enough to know when and how to use 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?

The tool has zero parameters, so there is no parameter-level semantic burden. The description still enriches the output expectations by naming the offer categories and what each provides, which helps the agent interpret results even though no input schema exists.

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?

Description states a specific verb and resource: get listing offers from SaaSCity, and names the actual offer tiers (free queue, Quick Pass, Premium). It also clarifies what each tier buys (queue position, dofollow link, launch post), making the tool's purpose unambiguous and distinct from sibling tools like get_listing or check_badge.

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 clearly implies the tool is informational and tells the agent that payment cannot be completed through the API ('Only a human can pay, on the claim page'). This gives practical context for when to use it versus attempting a purchase or expecting a mutable action, though it does not explicitly name sibling alternatives or exclusion conditions.

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 annotations already declare readOnlyHint=true, idempotentHint=true, and openWorldHint=false, covering the safety and idempotency profile. The description adds meaningful behavioral context beyond the annotations: it specifies that the tool has two mutually exclusive input paths (claim token vs slug) and that the response varies by mode (draft statuses vs live listing fields). This clarifies that the tool is not a simple lookup but a mode-dependent status reporter, which is not evident from the annotations or schema alone. No contradiction with annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, compact sentence that front-loads the core purpose ('where a submission stands') and then efficiently enumerates the two modes and their respective statuses. Every clause adds value: the mode distinction, the specific statuses, and the parameter-to-mode mapping. There is zero waste, and the structure makes the dual nature of the tool immediately apparent.

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 the tool has an output schema (indicated by the 'has output schema: true' signal) and the description already covers the modes and returned fields, the description is largely sufficient for an agent to call it correctly. It lacks a few niceties: it doesn't explicitly say the parameters are optional and mutually exclusive (though it's implied by the description and schema), and it doesn't mention what happens if neither is provided (e.g., an error). However, for a status-check tool with a lightweight schema and clear annotations, these are minor gaps. The description is complete for the primary use cases.

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

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

The schema already provides 100% coverage of both parameters with descriptions (slug for live listing, claim_token for draft token). However, the description adds crucial semantic value: it explains the relationship between the parameters and the tool's modes, and clarifies that they are mutually exclusive (implicitly, since only one is used per call). It also connects claim_token to the submit_project tool, which is not in the schema. This goes beyond the schema's simple field descriptions, but it doesn't detail parameter formats (e.g., exact regex for slug or token), so it's not a perfect 5.

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 opens with a clear subject ('Where a SaaSCity submission stands') and divides the tool's scope into two distinct modes: drafts by claim token and live listings by slug. It names the specific statuses returned for each mode (unclaimed, claimed and in review, or expired for drafts; launch week, badge, link type, points for live listings), which goes beyond a generic phrase like 'get status'. It does not explicitly differentiate from siblings such as get_listing or check_badge, but the focus on 'where a submission stands' (a status lifecycle) distinguishes it from a generic listing fetch.

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 clearly states when to use the tool: to check the status of a submission, either for a draft (using claim token) or a live listing (using slug). It implies the alternative: if you need details of a listing beyond status (e.g., content, media), you might use get_listing; if you need to check badge eligibility, use check_badge. However, it does not explicitly list exclusions or say 'do not use this for X'. The context is clear enough for an agent to route correctly, but it lacks explicit 'when not to use' warnings.

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 adds meaningful behavioral context beyond the readOnlyHint/idempotentHint annotations: results are human-curated, include verdicts even for not-worth-paying options, and contain metrics like Ahrefs DR, link type, and price. This tells the agent the nature and limitations of the recommendations.

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 with no filler. The first sentence states the core value, the second explains what each pick includes, and the third gives usage guidance. It is front-loaded and every sentence earns its 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?

Given that all parameters are optional, the output schema exists, and annotations already cover safety/idempotency, the description provides enough context for an agent to decide when and how to use the tool. It covers scope, curation, output characteristics, and the relationship to a sibling tool.

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

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

Schema description coverage is 100% and both parameters are already documented with defaults and enum meanings. The description doesn't add parameter-level details, but it reinforces the product-type context and implies the inclusion of pricing information. 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 identifies a specific action: recommending hand-picked launch directories for a product type, with the output grouped by submission timing. It also distinguishes itself from find_launch_directories by calling itself the curated starting point and the sibling the broader option.

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

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

It explicitly says 'Start here' and directs users to find_launch_directories when they want to go wider across all 1,666 sites. This provides a clear decision rule for when to use this tool versus the main alternative.

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 the search criteria and return fields, but does not disclose additional behavioral details such as pagination behavior or any operational limits. This is adequate but not rich beyond annotations.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is compact and front-loaded with the core action, followed by return value hints and a use case. It is not bloated, though the enumeration of returned fields is somewhat redundant given the output schema exists. Still, each sentence contributes meaningfully.

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 read-only search tool with full parameter documentation, an output schema, and safety annotations, the description supplies enough context to understand what the tool does and when it is useful. It does not explicitly address all sibling overlaps, but that is not necessary for basic 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%, so the schema fully documents all five parameters, including enums, defaults, and constraints. The description's mention of 'keyword and/or category' maps to query and category, but adds little beyond what the schema already provides. The baseline of 3 applies.

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

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

The description clearly identifies a specific verb ('Search'), a resource ('products listed on SaaSCity'), and the main filter dimensions ('keyword and/or category'). It is understandable on its own, but it does not explicitly differentiate itself from sibling tools like get_listing or find_alternatives, so it stops short of a 5.

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 concrete use case: market research ('what else exists in this space?') before a launch. That provides clear contextual guidance, though it does not state when not to use this tool or name an alternative, so it lacks explicit exclusions.

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

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

The description discloses the key side-effect profile: it creates an inert draft, returns a claim URL, requires human sign-in and confirmation, publishes nothing, charges nothing, and is subject to human review. This goes well beyond the sparse annotations and tells the agent exactly what will and won't happen.

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 with no filler; the core action and workflow are front-loaded, and eligibility constraints are placed at the end. Every sentence earns its 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?

For a human-in-the-loop submission tool, the description covers the draft state, claim URL, confirmation step, review process, cost, and refusal criteria. The presence of an output schema means return-value documentation is already handled elsewhere.

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 all eight parameters. The description adds non-obvious validation semantics for website_url by refusing free subdomain hosts and already-listed domains, which is meaningful 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 first sentence uses a specific verb and resource ('List a product on the SaaSCity launch directory') and clearly distinguishes this creation workflow from read-only siblings like get_listing and search_listings. The rest of the description reinforces that this is the submission action, not a status or search 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?

The description makes the submission context clear: it is the tool for creating a draft listing and requires human confirmation. It does not explicitly name alternatives like get_submission_status for follow-up checks, but the workflow is unambiguous enough that an agent would not confuse it with the read-only siblings.

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