VerifiedDR

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

Annotations already mark the tool as readOnlyHint=true and openWorldHint=false, conveying safety and non-open-world behavior. The description adds value by detailing the exact data returned (e.g., plan, quota, searches) and the recommended preceding role, which helps the agent understand the tool's position in a workflow.

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: the first lists the returned data in a compact format, the second gives a clear usage directive. Every word is necessary and no extraneous information is included. It is highly efficient and 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?

For a zero-parameter, read-only tool with no output schema, the description is complete. It specifies the exact data returned (plan, tracked-question space, AI searches, quota, entitlements), implies the output is a summary of these items, and provides workflow context. No additional information is needed for the agent to use the tool correctly.

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

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

The input schema has zero parameters and 100% schema description coverage, so the baseline is 3. The description does not add parameter-level detail because none exist. It reinforces that the tool requires no arguments, but that is already clear from the schema. No additional semantic value is provided 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 explicitly lists the specific data returned (plan, tracked-question space, completed AI searches, remaining API quota, plan entitlements) and clearly indicates it is an account usage and quota tool. It is distinct from all sibling tools, none of which deal with account-wide usage.

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 explicit timing guidance: 'Call this before adding questions or running a scan.' This instructs the agent on when to invoke the tool. It does not mention when not to use it or alternatives, but given the tool's unique purpose, the guidance is clear and actionable.

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?

Discloses side effects and constraints beyond the minimal annotations: 'Counts against the account-wide prompt budget' and 'Non-global locations need a paid plan' are useful behavioral traits. The note about self-branding being allowed and testing direct recall adds nuance. 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 front-loaded with the main action in the first sentence, followed by two short, information-dense sentences about constraints. No fluff or repetition; 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 creation tool with 3 parameters and no output schema, the description covers purpose, constraints, side effects, and plan requirements. It does not mention return values or behavior on duplicate prompts, but these are not critical for a straightforward add operation given the schema coverage.

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

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

Schema covers all parameters with clear descriptions, but the description adds the 8-300 character constraint on prompt and clarifies location implications (paid plan for non-global). This enriches parameter semantics beyond the schema, so it exceeds the baseline of 3.

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

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

The description clearly states 'Add one question to a site's AI visibility tracking' with a specific verb, resource, and scope. It distinguishes from sibling tools like remove_ai_visibility_prompt and add_tracked_keyword by focusing on adding a single question to AI visibility tracking.

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 clear context: character limits (8-300), allowance for self-branding and direct recall, account-wide prompt budget impact, and paid plan requirement for non-global locations. However, it does not explicitly compare to alternatives like import_ai_visibility_prompts for bulk operations, so it stops short of full guidance.

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

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

The description adds valuable behavioral context beyond annotations: it snapshots difficulty (a combined action) and mentions per-site caps. No annotation contradictions; annotations are readOnlyHint=false, destructiveHint=false, properly reflected.

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 concise sentences with no filler. Purpose is front-loaded; every sentence contributes meaningful information.

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

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

No output schema exists, but the description does not explain return values or confirm if the keyword was added. Also lacks details like prerequisites (e.g., site must exist). Adequate but not fully 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 coverage is 100%, so baseline is 3. The description provides minor clarification for the 'site' parameter ('as a slug or hostname') but adds limited semantic meaning beyond 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?

Description explicitly states 'Add a keyword target to one of your sites and snapshot its difficulty.' It uses specific verbs and resources, distinguishing itself from sibling tools like list_tracked_keywords or remove_tracked_keyword.

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?

Mentions 'Per-site keyword cap applies,' providing a constraint and implicit warning. However, it lacks explicit guidance on when to use this tool versus alternatives like keyword_difficulty or keyword_suggestions.

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 confirms the readOnlyHint and adds meaningful behavior beyond annotations: the check is stored, requires prior submit_site with siteCheck:true, and returns 404 for unsubmitted domains or until a report exists. It also explains the output verdict composition, making behavior well understood.

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 dense sentences, front-loaded with purpose, followed by constraints and usage. Every sentence carries informative value without fluff.

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

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

With no output schema, the description compensates by explaining the verdict categories ('real/suspicious/shell/unreachable') and plain-language reasons. It covers preconditions and use cases adequately, though it omits details on how verdicts are calculated or any timing expectations beyond 'until a report exists'.

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

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

The input schema fully describes the domain parameter, but the description adds crucial nuance: despite the schema saying 'nobody has to have submitted it', the tool is 'listed-sites-only' and returns 404 for unsubmitted domains. This clarifies the actual operational constraint, though it introduces slight tension with the schema wording.

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 'Stored fraud check for a submitted site' and enumerates specific components (homepage shell detection, domain age, organic-keyword footprint versus backlink profile, spam score) leading to a verdict. This clearly differentiates it from sibling tools like get_domain_rating or verify_site.

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?

Explicit use case is given: 'Use it to vet link targets, exchange candidates, and outreach prospects before trading anything.' It also states an exclusion ('returns 404 for unsubmitted domains'), clarifying when not to use. It does not name alternative tools, but the 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=true, so the safety profile is covered. The description adds valuable behavioral detail by specifying exactly what dimensions are compared (score delta, gained/lost mentions, new/dropped sources, brands), which goes beyond the annotation and helps set expectations.

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, front-loaded with the primary action, and every word earns its place. It lists the comparison dimensions efficiently and adds the timestamp provenance in the second sentence without fluff.

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

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

Given no output schema, the description sufficiently outlines the expected return categories (score delta, mentions, sources, brands). It could be more detailed about return format or edge cases, but for a read-only diff tool with strong annotations, it provides enough context for an agent to know what to expect.

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%, with each parameter described. The description adds extra meaning by clarifying that the from/to timestamps should originate from get_ai_visibility history, which is not explicitly stated in the schema. This helps the agent connect the tool to its data source.

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 begins with 'Compare two stored AI visibility runs' which uses a specific verb and resource, immediately distinguishing it from related tools like get_ai_visibility or run_ai_visibility_scan. It enumerates the exact comparison outputs (score delta, gained/lost mentions, sources, brands), making the tool's function 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 implies usage by stating its purpose, but does not explicitly address when to choose this tool over siblings like get_ai_visibility or run_ai_visibility_scan. It provides some context by noting timestamps come from get_ai_visibility history, but lacks explicit exclusions or alternative tool guidance.

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

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

The description does not disclose behavioral traits such as side effects, irreversibility, or confirmation of acceptance. Annotations provide no safety hints, so the description should compensate but fails to.

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 with no wasted words. However, it is almost tautological with the title 'Accept assignment', slightly diminishing its value.

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

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

For a simple mutation tool with no output schema, the description should mention return behavior or effects. It only states the action, leaving the agent uncertain about what happens post-acceptance.

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 describes the 'placementId' parameter as coming from 'earn_assignments'. The tool description adds no additional meaning beyond this, so baseline score 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 'Accept an assigned placement' clearly states the action and resource, distinguishing it from the sibling tool 'earn_decline_assignment'. It is specific and direct.

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 provided on when to use this tool versus alternatives like 'earn_decline_assignment' or prerequisites. The description lacks any conditional usage information.

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 declare readOnlyHint=true, confirming safe read operation. The description adds insight into the returned data (URL, anchor, brief, payout, deadline), but does not disclose any additional behavioral traits like pagination or ordering. Given the tool's simplicity, this is adequate.

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?

Single sentence providing all necessary information without any filler or redundancy. The key details are 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?

For a zero-parameter list tool with no output schema, the description fully explains what the tool returns (target URL, anchor, buyer's brief, payout, deadline). No additional context is needed given the tool's simplicity.

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 and schema coverage is 100%, so there is no need for parameter documentation. Baseline score of 4 applies as the description is not required to add parameter meaning.

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 tool's title 'List assignments' and description 'Placements assigned to your websites — target URL, anchor, the buyer's brief, payout, deadline' clearly state the verb (list) and resource (assignments/placements), with specific fields that distinguish it from sibling tools like earn_accept_assignment or earn_earnings.

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 use for viewing active assignments, and sibling tools like earn_accept_assignment and earn_decline_assignment suggest when to use alternatives, but no explicit when-to-use or when-not-to-use guidance is provided.

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 indicate non-readOnly and non-destructive, which the description complements by stating it's free and expected. This adds useful behavioral context 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 extremely concise and front-loaded, with no wasted words.

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 simple tool (2 parameters, 1 required), the description provides sufficient context. No output schema is present, but return values are straightforward.

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 description does not add extra meaning to parameters; it relies on the schema for parameter details.

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 action (decline) and the resource (assigned placement). It implicitly distinguishes from sibling 'earn_accept_assignment' by its opposite action.

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 notes that declining is 'free and expected,' providing context on when it's appropriate. However, it does not explicitly mention when not to use it or compare with alternatives.

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 annotation, the description details the exact fields returned (pending, due, paid, threshold), adding valuable context about the tool's output.

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

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

A single sentence effectively communicates the tool's purpose and output, with no wasted words.

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

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

For a zero-parameter, read-only tool, the description fully covers what the tool does and what it returns, making it 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?

No parameters exist, so the baseline of 4 applies; the description adds no parameter info because none are needed.

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 retrieves publisher earnings (pending, due, paid, payout threshold) in USD cents, distinguishing it from sibling tools that manage sites or assignments.

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 for checking earnings without specifying when not to use or alternatives, but given its simplicity and zero parameters, the context is clear enough.

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?

Discloses refusal condition (acceptTerms=true) and outcome (pending approval). Annotations already indicate non-read-only and non-destructive; description adds meaningful behavioral context 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?

Two sentences: first states purpose, second adds critical usage warning. Front-loaded and no unnecessary words.

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?

Describes core behavior and key constraint. With full schema coverage and no output schema, the description is sufficient for an agent to understand the tool's impact and prerequisites.

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 covers 100% of parameters with descriptions. The tool description adds only a hint that 'site' should be a verified website, which is useful but not extensive.

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 action (Join) and resource (publisher network). 'with one verified website' adds scope. It is distinct from sibling tools like earn_accept_assignment or earn_sites.

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

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

Explicitly warns that acceptTerms must be true and to confirm with the user. Describes pending state. However, does not explicitly state when not to use this tool or mention alternatives.

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 provide readOnlyHint=false and destructiveHint=false, indicating modification but not destruction. The description adds context on the behavior of paused (stops new work) and removed (leaves network), which goes beyond the schema enum descriptions.

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 (13 words), efficiently conveying the tool's action and all three status options with no redundancy or filler. Front-loaded with the action.

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 status setter with no output schema, the description covers the tool's function and the meaning of each status. It does not mention prerequisites (e.g., membership in a network), but this is acceptable for such a tool.

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

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

Schema coverage is 100%, baseline is 3. The description adds meaning by explaining what each status does (paused, removed), and the site parameter is described as a slug or hostname. This provides useful context beyond the enum labels.

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 'Set a network website's status' with specific verb 'set' and resource 'network website's status'. It distinguishes between three statuses (active, paused, removed), differentiating it from sibling tools like earn_join_network or earn_sites which handle other actions.

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 explains the effects of each status (paused stops new work, removed leaves network), but does not explicitly state when to use this tool versus alternatives or mention prerequisites. The context is clear, but exclusions are missing.

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, so the tool is read-only. The description adds value by specifying exactly what data is returned (earnings, network status, terms), providing behavioral context beyond the annotation.

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?

Single sentence of 18 words, no fluff. Front-loaded with the key output: 'Every owned website'. Each word carries meaning.

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 no-parameter, no-output-schema tool, the description fully explains what the tool returns. It covers the essential context for its simple listing function.

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?

No parameters exist; schema coverage is 100%. Per guidelines, baseline for 0 parameters is 4. The description does not need to add parameter info.

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 lists owned publisher sites with specific details (earnings per placement, network status, terms). It uses a specific verb ('list') and resource ('publisher sites'), distinguishing it from siblings like find_sites or earn_earnings.

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 tool is for viewing your own sites in the publisher network, but it does not explicitly state when to use it versus alternatives (e.g., find_sites for discovery, list_sites for generic listing). No exclusion criteria or usage context given.

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 indicate non-read-only, non-destructive, and open-world. The description adds valuable behavioral context: the server fetches the URL and checks link presence before marking verified. No contradictions 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?

Two sentences with no waste. The key action, process, and consequence are front-loaded and efficiently communicated.

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 no output schema, simple parameters, and annotations cover safety, the description adequately covers the verification process and payment trigger. Could mention expected response time or prerequisites, but overall sufficient.

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% with clear descriptions. The tool description does not add additional parameter-level detail beyond what is already in the schema, so baseline score 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 action: 'Report a placement live.' It explains the server-side verification process and the consequence of payment. This distinguishes it from other earn-related sibling tools like 'earn_accept_assignment' or 'earn_set_status.'

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 when to use—when you have a placement and live URL to get paid—but offers no explicit when-not-to-use or alternatives. Sibling tools exist but no comparative guidance is provided.

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 indicate it is a write operation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds 'Tune' which implies modification, but does not disclose side effects, permission requirements, or any behavioral details beyond what annotations 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 a single, well-structured sentence. Every word is meaningful and there is no redundancy or unnecessary detail.

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 update tool with 4 parameters and no output schema, the description covers the core action. However, it omits details about return values, error cases, permission requirements, or confirmation of changes, leaving gaps for an AI agent.

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% (only 'site' and 'turnaroundDays' have descriptions). The description adds the terms 'link types', 'turnaround', and 'monthly cap', which map to the undocumented parameters. This adds meaning but does not fully compensate for the missing parameter 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?

The description uses the verb 'Tune' to indicate updating, and specifies the resource as 'network website's placement settings'. It lists the key settings (link types, turnaround, monthly cap), making the purpose clear. However, it does not explicitly distinguish this from sibling tools like 'earn_accept_assignment' or 'earn_set_status', which limits differentiation.

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. It does not mention prerequisites, context, or when not to use it. Users must infer from the tool name and context signals.

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 the description adds minimal extra behavioral context. No mention of response size, permission requirements, or other traits beyond the export purpose.

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?

Single sentence, front-loaded with action and resource, includes specific output contents. No unnecessary words.

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

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

Given no output schema, the description adequately describes the output contents (metrics, authority payload, badge snippets). Lacks details on pagination or limits, but acceptable for a simple export tool.

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

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

Schema coverage is 100% with clear parameter description. The tool description does not add additional meaning beyond what the schema already provides for the 'site' parameter.

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 exports site data in machine-readable format, listing specific contents (metrics, authority payload, badge snippets), and distinguishes it from siblings like get_site or get_badge_snippets which return subsets.

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 it's for comprehensive export, but does not explicitly state when to use vs alternatives or provide exclusion criteria. Usage context is inferred rather than stated.

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 the description adds meaningful behavioral context: results are limited to verified websites, exclude already contacted/dismissed matches, and represent a specific first step in a workflow. This goes beyond the annotation status, though it doesn't cover pagination or result structure.

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 long, front-loaded with the primary purpose, and the second sentence efficiently points to the associated action. Every word contributes value, with no redundancy or filler.

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

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

Given the tool has 6 parameters with full schema coverage, no output schema, and simple list-returning behavior, the description adequately covers the core workflow and exclusions. It could mention result pagination or sorting, but the schema defaults (limit) handle that, so the description is sufficiently complete for 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?

Schema coverage is 100%, with all six parameters described in the schema. The description itself adds no additional parameter-level detail (e.g., 'site' meaning one of the user's sites is already in the schema). Thus 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 the tool finds 'Verified websites open to a relevant editorial link exchange with one of your sites,' which specifies the action (find), resource (link exchange matches), and key filtering (excluding already-contacted/dismissed). It distinguishes itself from the sibling find_sites by focusing on link exchanges and referencing propose_link_exchange for the next step.

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

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

The description provides clear context for use: it's for discovering link exchange opportunities, and explicitly points to propose_link_exchange for previewing the proposal. However, it does not explicitly state when not to use this tool or alternative scenarios beyond the sibling reference.

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 `openWorldHint: false`, so the read-only nature is covered. The description adds valuable behavioral context beyond annotations: the ranking order ('ranked by TrueDR then DR') and the default filtering behavior ('Verified-only by default'). This goes beyond what the schema alone conveys.

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 exceptionally concise: two short sentences, with the core purpose front-loaded in the first sentence. Every element serves a purpose—no filler or repetition of schema details.

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 discovery tool with six optional parameters, the description covers the key behavioral essentials: purpose, ranking order, and default verification filter. However, since there is no output schema, it does not hint at what fields are returned or whether pagination is supported (beyond the `limit` parameter), leaving minor gaps for an agent.

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 baseline is 3. The description enriches parameter meaning by explaining that results are ranked by TrueDR then DR (relevant to `minTrueDr` and `minDr`) and that unverified sites are excluded by default (relevant to `trafficValidated` and `includeUnverified`). This adds context beyond the schema 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?

The description clearly states the tool's function: 'Discover approved sites by authority for broad website, sponsor, or integration prospecting.' It names a specific action ('Discover'), resource ('approved sites'), and distinguishes itself from siblings like `list_sites` by emphasizing authority-based prospecting and the ranking order ('TrueDR then DR').

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

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

The description provides clear context on when to use this tool—'broad website, sponsor, or integration prospecting'—which is useful for selecting among sibling tools. However, it does not explicitly mention when not to use it or point to alternatives like `list_sites` or `marketplace_sites`, so exclusions are missing.

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

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

Annotations already mark readOnlyHint=true, and the description reinforces this with 'Reading never spends budget,' adding behavior context beyond structured hints. It also discloses the content of the response (score, answers, rivals, cited pages, run history), which is useful transparency without contradicting the annotations.

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

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

The description is compact at two sentences, front-loads the core purpose, and every word adds value. It efficiently enumerates what the tool returns and adds a cost-relevant note without unnecessary filler.

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

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

For a simple one-parameter tool with no output schema, the description sufficiently covers the return values and context. It explains the scope ('tracked questions', 'one of your sites') and the read-only nature, making it complete for an agent to select and invoke correctly.

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

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

The single parameter 'site' is fully described in the schema with examples, and the description does not add additional semantic detail beyond schema coverage. With 100% schema_description_coverage, this is the baseline score.

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

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

The description clearly identifies the tool as a read-only getter for AI visibility metrics, specifying the exact data returned (score, per-question answers, rival brands, cited pages, run history) for tracked questions about one of your sites. It distinguishes itself from sibling run/diff tools by stating 'Reading never spends budget' and mentioning run history, making its purpose concrete and unique.

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

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

The description provides clear usage context: use this tool to retrieve AI visibility data without spending budget, as explicitly stated in 'Reading never spends budget.' It implies a distinction from running a scan, but it does not name specific alternative tools or state when not to use it, so it stops short of full 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 annotations already declare readOnlyHint=true, so the description adds little beyond stating outputs are for approved sites. The description does not contradict annotations, but also does not provide additional behavioral details like rate limits or scope.

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

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

A single sentence that conveys all necessary information without redundancy. Every word is meaningful and efficiently front-loaded.

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

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

With one parameter, full schema coverage, and read-only annotations, the description fully explains the tool's purpose and inputs. No output schema exists, but the description implies the output types (snippets, links). Complete for the tool's simplicity.

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 covers 100% of parameters, but the description adds meaning: the site must be 'approved VerifiedDR' and can be a domain, URL, or slug, and does not have to be the user's own. This goes beyond the schema's plain string 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 uses a specific verb ('get') and resource ('badge snippets'), and clearly distinguishes the output: ready-to-paste HTML, markdown, share text, plus public links. It is clearly different from sibling tools like get_site or get_growth_plan.

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

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

The description states the tool works for 'any approved site' and clarifies the parameter input (domain, URL, or slug). It does not explicitly mention when not to use it or alternatives, but the context is clear enough.

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 the description adds useful behavioral context: it works for any domain regardless of VerifiedDR status, and it only returns DR, not TrueDR/trust/traffic. This goes beyond the annotation by disclosing the tool's scope and limitations, though it doesn't cover edge cases like invalid domains.

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

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

Three tightly packed sentences carry all essential information: purpose, use case, and exclusion condition. No wasted words, and the key point ('ANY domain' and 'DR only') is highlighted up front.

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 no output schema, this description is complete. It explains what the tool returns (DR only), when to use it, and when to switch to lookup_site. The readOnlyHint annotation covers safety, so no additional disclosure is needed.

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% for the single 'domain' parameter, and the description repeats the same 'any domain' semantics without adding new syntax or formatting details. The description's use-case framing ('scoring a prospect') adds minimal parameter meaning, so 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 the tool's purpose: 'Domain Rating for ANY domain' uses a specific verb ('score') and resource ('domain rating'). It explicitly distinguishes from siblings by noting it can score any domain not on VerifiedDR and that TrueDR/trust/traffic require lookup_site, preventing confusion with related 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 description gives explicit use cases: 'score a prospect, competitor, or link target before anyone submits it.' It also provides an alternative directive: 'call lookup_site when listed is true' for TrueDR/trust/traffic, clearly defining when not to use 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?

Annotations already declare the tool as read-only (readOnlyHint=true). The description adds transparency by noting that free plans have restricted output, which is useful behavioral context beyond the annotation. No contradictions.

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 long, front-loading the core purpose in the first sentence and adding a critical qualification in the second. No unnecessary words; every sentence adds value.

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

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

Given the tool's simplicity (1 parameter, read-only, no output schema), the description adequately covers what the tool returns (ranked tasks, impact, status, artifacts, benchmarks) and a plan-dependent limitation. Could optionally mention that the plan must first be generated via run_growth_plan, but this is implicit from the word 'generated'.

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 provides a clear description for the single 'site' parameter (slug or hostname), achieving 100% coverage. The description does not add additional meaning beyond the schema, so baseline score 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 explicitly states the tool retrieves the generated growth task plan for a site, listing specific components (ranked tasks, impact, status, execution artifacts, benchmark sites). It clearly distinguishes from sibling tools like run_growth_plan (generation) and update_growth_task (modification).

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 includes a practical note about free plans receiving only a summary and one action, guiding agents on expected output based on subscription. However, it does not explicitly state when to use this tool versus alternatives or exclude scenarios.

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 openWorldHint=false. Description adds 'latest stored' and prerequisite, but doesn't detail output format or other behavioral aspects 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?

Single sentence, no wasted words. Essential information is front-loaded.

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

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

With simple tool (1 param, no output schema, annotations present), description covers purpose, prerequisite, and resource nature. Could mention return type but not necessary. Fairly 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?

Single parameter 'site' has schema description that explains format. Description doesn't add extra meaning beyond what schema provides. Baseline 3 as schema coverage is 100%.

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 clearly states verb (get), resource (latest stored GSC index audit), and scope (for a site, requires connected GSC property). It distinguishes from siblings like run_gsc_audit and get_gsc_performance.

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?

Prerequisite 'needs a connected GSC property' is mentioned. Context via sibling names implies this is for retrieving a stored audit versus running a new one. No explicit when-not or alternatives, but clear enough.

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 set readOnlyHint=true, and the description adds that it uses existing sync data, implying no new fetch or mutation. This goes beyond annotations, but does not address staleness or rate limits.

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?

One sentence efficiently conveys the tool's output structure without extraneous words. Front-loaded with key 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?

Given only 2 simple parameters and no output schema, the description adequately summarizes return types (totals, daily data, snapshots) but could clarify data structure or refresh behavior.

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%; the description does not add meaning beyond the schema definitions. 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 it retrieves Search Console performance data for a site, specifying totals vs preceding period, daily data, and top dimensions (query/page/country/device). This differentiates it from sibling get_gsc_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 says 'from the existing sync,' implying the tool reads previously synced data, but does not explicitly state when to use this versus alternatives like get_gsc_audit or account_usage. No when-not guidance.

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

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

The readOnlyHint annotation indicates no mutation, and the description confirms it returns data (DR, traffic history, backlinks). It adds behavioral details about resolution order and the owned indicator, which go beyond the annotation. No contradictions.

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 extraneous information. Front-loaded with what the tool returns, then behavior details. Every phrase 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?

Without an output schema, the description adequately describes the return data (DR, traffic history, backlink totals) and behavior. It covers the key aspects for using the tool correctly. Slight improvement possible by mentioning pagination or limits, but not necessary for this simple tool.

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

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

Schema coverage is 100%, but the description adds value by explaining the resolution logic (own sites first, then public) and the meaning of `owned`. This context is not present in the schema description of the parameter.

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 it retrieves one site with DR, traffic history, and backlink totals, and distinguishes from siblings by mentioning fallback resolution and the `owned` field. The verb 'get' and resource 'site' are precise.

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 explains it resolves own sites first, then falls back to public sites, giving clear context. It does not explicitly list when not to use it, but the fallback behavior and mention of `owned` provide implicit guidance compared to siblings like list_sites or lookup_site.

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. Description adds that the score is 'from the stored score' (not real-time) and details what detailed=true returns. No contradictions. Adds useful behavioral context 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?

Two sentences perfectly front-loaded: first sentence defines core action and resource, second sentence adds key option with uniqueness. Every word earns its place; no fluff.

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 2-parameter tool with no output schema, description fully explains the main return value and the additional data when detailed=true. Sufficient for effective invocation among 60+ sibling tools.

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% with descriptions. Description adds meaning: site as 'one of your websites, as a slug or hostname' and detailed's 'per-signal trust breakdown and recommended actions' plus its uniqueness. Exceeds baseline 3.

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

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

Description clearly states it retrieves 'TrueDR' (DR weighted by trust and real traffic) for one of the user's sites from a stored score. It distinguishes from siblings by noting that detailed=true exposes per-signal breakdown, which is unique among 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?

Indicates the tool works for 'one of YOUR sites' and explains when to use detailed=true as the only place breakdown is exposed. Does not explicitly state when not to use it or compare with alternatives like get_site or get_trust_map, but 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 declare readOnlyHint=true and openWorldHint=false. The description adds context: data comes from cache, specific fields returned, and potential 503 error. No contradictions.

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 concise sentences front-load the purpose and then provide behavioral details. Every sentence adds value.

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

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

For a simple, one-parameter read tool, the description covers the output fields and error condition. Minor omission: no explicit format of the response, but acceptable given no 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?

The single parameter 'site' is fully described in the input schema (100% coverage). The description adds no extra parameter details beyond what the schema provides.

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

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

The description states it retrieves the public Trust Map (backlink map) for an approved site, including per-domain DR, link type, importance, and spam score. This is specific and distinguishes it from sibling tools like get_truedr or get_site.

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 clarifies the tool is for any approved site and notes a 503 response if no cached map exists, implying a condition. However, it does not explicitly compare to alternatives or state 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 indicate mutation (readOnlyHint=false) and non-destructiveness. The description adds value by noting that bad lines are skipped (tolerance) and that it counts against a budget, providing useful behavioral context beyond the annotations.

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

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

The description is two sentences, front-loads the core purpose, and contains no fluff. Every phrase ('bad lines are skipped', 'counts against budget') adds necessary information.

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

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

Without an output schema, the description should explain what the tool returns (e.g., success count or errors). It omits this entirely, leaving a critical gap for an AI agent to understand the tool's effect.

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 described. The description adds no extra semantics beyond mentioning 'bad lines are skipped' inline with the prompts array, which only reinforces schema 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?

The description states 'Import several questions at once', which clearly indicates the batch nature, distinguishing it from the sibling 'add_ai_visibility_prompt' (single import). However, it does not explicitly name the alternative, so it falls short of a perfect score.

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 for batch imports but does not specify when to use this tool over alternatives (e.g., 'add_ai_visibility_prompt'). It mentions budget constraints but lacks explicit guidance on suitable scenarios or exclusions.

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

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

Annotations already declare readOnlyHint=true, so the tool is known to be safe. The description adds a crucial behavioral directive: 'Time-sensitive human work: summarize and draft, don't answer on your own.' This goes beyond annotations by telling the agent to involve a human and not act autonomously, which is valuable context for invocation. It 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 two sentences long, front-loaded with the core action and scope, and includes a meaningful usage caveat. Every sentence earns its place with no redundant filler.

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

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

For a simple list tool with no output schema, the description conveys the content (thread types and unread count) and an important behavioral rule. It adequately covers the tool's purpose and usage context. A minor gap is not detailing the exact return structure, but that is not essential for a list endpoint with well-known pagination parameters.

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 covers both parameters (limit and offset) with descriptions, achieving 100% coverage. The tool description does not add any additional parameter meaning beyond what the schema provides. Baseline 3 is appropriate because 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 identifies the tool's function: listing inbox threads for link exchange conversations and marketplace threads, with unread count. It uses a specific verb ('list') and resource ('inbox threads'), and distinguishes itself from siblings like inbox_thread, inbox_reply, and inbox_mark_read by specifying the scope and included data.

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

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

The description provides clear context for when to use this tool (for listing time-sensitive inbox threads) and includes an exclusion: 'don't answer on your own.' It implicitly contrasts with reply/mark-read tools by directing the agent to summarize and draft rather than directly respond. However, it does not explicitly name alternative tools, so it falls short of a 5.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false, and idempotentHint=true. The description adds only the thread scope (exchange or marketplace), which is useful context. It doesn't mention reversibility, permissions, or side effects, but given the annotation coverage, this is acceptable.

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, concise sentence with no filler or redundancy. It exactly states the purpose without unnecessary detail.

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 one-parameter operation with good annotations and schema, the description is nearly complete. It could be slightly more contextual (e.g., mentioning it affects only the user's view), but it doesn't leave critical gaps for this straightforward 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 input schema provides 100% coverage for the only parameter 'id' with the description 'Thread id from inbox_list.' The tool description does not add additional parameter semantics, so it relies entirely on the schema, which is adequate.

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 action (mark) and the resource (exchange or marketplace thread) with the result (as read). This is a specific, distinct operation compared to sibling tools like inbox_list, inbox_thread, and inbox_reply, making the purpose 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?

There is no explicit guidance on when to use this tool versus alternatives. The description doesn't mention exclusions or direct users to other tools (e.g., 'use inbox_reply to respond'). The usage is implied but not stated.

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 critical behavioral traits beyond annotations: it SENDS REAL EMAIL as the account owner, and instructs to only send with explicit user approval. This adds meaningful context about real-world side effects, which the annotations (readOnlyHint: false, openWorldHint: true) only partially convey.

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

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

The description is three short sentences, each carrying distinct value: purpose, real-world effect, and usage constraint. It is front-loaded and every word earns its place, with no redundancy.

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

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

The tool is simple (2 required params, no output schema) and the description covers the core action, the side effect, and the consent requirement. It is complete for an agent to understand when and how to invoke the tool 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?

The input schema already provides 100% coverage with clear descriptions for both parameters (thread id and reply text). The description does not add further parameter detail, but the schema fully documents them, so a baseline score 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 uses the specific verb 'Reply' with the resource 'thread' and scopes it to 'exchange or marketplace thread,' clearly distinguishing it from sibling tools like inbox_list and inbox_mark_read. The action and target are 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 implies when to use the tool: when the user wants to reply in a thread. It does not explicitly name alternatives or state when not to use it, but the context is clear enough. The warning 'Draft and send only on the user's word' adds usage guidance.

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

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

The readOnlyHint annotation covers the safety profile, so the bar is lower. The description adds that the tool returns 'messages and relevant context,' which suggests the output contents but remains vague about specifics like message ordering or what 'relevant context' includes. No extra behavioral details (e.g., no side effects, pagination) are provided.

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, front-loaded with the key noun ('One exchange or marketplace conversation'), and conveys the essence without unnecessary words. It is appropriately sized for a simple read operation.

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 simple (one param, read-only) and annotations cover safety, so completeness requirements are modest. However, with no output schema, the description should better explain the return format; 'with its messages and relevant context' is vague and does not clarify fields, pagination, or ordering. It is adequate but has gaps for a tool that returns meaningful data.

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% for the single parameter 'id', with the description 'Thread id from inbox_list' fully explaining its origin and purpose. The main description adds the concept of 'exchange or marketplace conversation,' but this does not materially enhance understanding 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 title 'Read a thread' provides the verb, while the description defines what a thread is ('exchange or marketplace conversation with its messages and relevant context'), making the purpose clear. It distinguishes from siblings like inbox_list and inbox_reply by focusing on reading a single thread's content. However, the description itself is a noun phrase rather than an explicit action, so it's slightly less direct than ideal.

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 parameter description 'Thread id from inbox_list' implies a prerequisite: call inbox_list first to obtain the id. This gives some contextual usage guidance. However, it does not explicitly state when to use this tool versus siblings (e.g., 'use inbox_list to see all threads, inbox_reply to reply'), leaving the choice to the agent's inference.

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 declare readOnlyHint true. Description adds behavioral details: computes median DR, weakest domain, gap, verdict. 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?

Single sentence conveying all essential information with no redundancy. Front-loaded with key output details.

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

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

No output schema but description outlines return values. With good annotations and full schema coverage, description is sufficient for correct tool 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 coverage 100% but description adds meaning: domain parameter includes gap and verdict. Other param keyword is simply defined in 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?

Description states specific verb and resource: analyses keyword difficulty via DR profile of Google top 10. Clearly distinguishes from siblings like keyword_suggestions or lookup_site.

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?

Clear context: for assessing keyword competition. Explicit constraint: paid plans only (402 otherwise). Does not explicitly mention alternatives but context from sibling tools provides implicit guidance.

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

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

Annotations declare readOnlyHint=true and openWorldHint=false. Description adds behavioral details: filters brand queries, orders by traffic value, and limits to ranks 4-30. No contradictions. Could further describe output format, but sufficient given simplicity.

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 concise sentences covering purpose, scope, constraints. Front-loaded with key information. No redundant words.

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 simple tool with one parameter and no output schema, description covers core purpose and constraints (paid only, brand filter, rank range). Could hint at output format, but adequate for low complexity.

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?

Only one parameter 'domain' with 100% schema coverage (description: 'Any domain, e.g. competitor.com'). Tool description does not add new meaning beyond schema, so 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?

Description clearly states the tool returns winnable keywords (rank 4-30) for a domain, ordered by traffic value, with brand queries filtered. It specifies it works for any domain and is for paid plans. This distinguishes it from sibling tools like keyword_difficulty or list_tracked_keywords.

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

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

Explicitly states 'Paid plans only' and 'Works for any domain (competitor research)' which provides clear usage context. However, it does not explicitly contrast with alternative tools or specify 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 indicate read-only; description adds value by stating exact number of values and per-site limit. No contradictions.

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?

Single sentence conveying all necessary information efficiently without redundancy.

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

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

With no parameters or output schema, description fully informs about return type and constraints, sufficient for agent use.

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?

No parameters exist (schema coverage 100% vacuously); baseline 4 applies as description adds no parameter info but none needed.

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 clearly states it lists category values used for submitting sites or filtering discovery, with specific count (32) and constraint (max 3 per site), distinguishing it from 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?

Explicitly states usage context (submitting site or filtering discovery) but no explicit when-not-to-use or alternatives; however, 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 mark readOnlyHint=true, and the description adds what data is returned (metrics). No contradictions. While pagination or limits are not mentioned, the tool has no parameters and is simple, so this is sufficient.

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?

Single sentence that is front-loaded with the key action ('List your sites') and immediately details the output. Efficient with no wasted words.

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 list tool, the description provides sufficient context about what is returned. No output schema exists, but the list of metrics explains the return value. Could be improved by noting if there's any limit on the number of sites returned.

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?

No parameters exist, and schema coverage is 100% (empty). The description adds value by listing the metrics returned (DR, TrueDR, etc.), which provides 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 description clearly states 'All websites on your account with current metrics' including specific metrics like DR, TrueDR, etc. It distinguishes itself from sibling tools like get_site (specific site) and find_sites (search) by implying it returns all sites without filters.

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 does not explicitly state when to use this tool versus alternatives like get_site or find_sites. The phrase 'All websites on your account' implies comprehensive listing, but no direct comparison or contraindications are provided.

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 indicate readOnlyHint=true, so the read-only behavior is covered. The description adds value by specifying the data included (difficulty snapshots, 28-day GSC impressions) beyond what annotations 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 a single, concise sentence with no wasted words. It efficiently conveys the tool's purpose and key details.

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 list tool with one parameter and no output schema, the description is fairly complete. It covers the return data and connectivity condition, though it could optionally mention pagination if applicable.

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 single parameter 'site' is well-described in the schema (100% coverage). The description does not add additional semantic meaning beyond what the schema provides, so baseline score 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 it lists tracked keyword targets for a site, including specific data like difficulty snapshots and GSC impressions. It distinguishes from sibling tools such as add_tracked_keyword and remove_tracked_keyword.

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 for listing tracked keywords but does not explicitly provide when-to-use or when-not-to-use guidance, nor does it mention alternatives among sibling tools.

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 indicate readOnlyHint=true. The description adds valuable behavioral context: it never returns owner data, and it lists the exact data points returned (DR, TrueDR, etc.). No contradictions.

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 compact sentences that front-load the purpose and immediately convey key specifics. Every sentence adds value with zero wasted words.

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

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

With no output schema, the description fully explains what the tool returns (DR, TrueDR, trust score, etc.) and clarifies privacy constraints. The single parameter is well-documented. Complete for a lookup 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 input schema covers 100% of parameters with a description that matches the tool description. The description does not add new meaning beyond the schema's description of the 'site' parameter. 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 it performs a public authority lookup for approved sites and enumerates specific fields (DR, TrueDR, trust score, etc.). It distinguishes itself from sibling tools like get_site or get_truedr by noting it never returns owner data.

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 for public data lookup without revealing owner info, but it does not explicitly state when to use this tool versus alternatives like get_site, get_truedr, or get_trust_map. No exclusions or when-not-to-use guidance.

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

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

Annotations already set readOnlyHint=true, so the description doesn't need to emphasize safety. It adds that the cart is 'open', but nothing else about behavioral traits. No contradiction.

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

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

Extremely concise: a single noun phrase that conveys the tool's purpose. No unnecessary words. 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 tool has no parameters, no output schema, and simple annotations. The description is minimal but adequate for a straightforward read operation. However, it could mention what the cart contains or how to use 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?

There are zero parameters, and schema description coverage is 100%. The description adds no parameter info, but baseline 4 applies as no compensation needed.

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 (current open marketplace cart) and implies a read operation. It distinguishes from sibling tools like marketplace_cart_add_package. However, the verb is implicit; 'View cart' in the title helps.

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 on when to use this tool versus alternatives. Since it's a simple getter, some context about prerequisites or typical workflow would be useful, but it's missing.

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 annotations (which show no destructive or readOnly hints), the description reveals that prices are re-derived server-side and the cart has a 5-row cap, providing valuable behavioral insights.

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 concise sentences with no unnecessary words. Front-loaded with the 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?

Covers purpose, server-side re-derivation, and cart limit. Missing details on error behavior when exceeding cap, but acceptable for a simple tool.

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

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

Schema coverage is 100% for the single parameter 'packageId', which is already described. The description adds 'Backlink Package' context but does not enhance the parameter meaning further.

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 'Add a Backlink Package to the cart' with a specific verb and resource. It distinguishes from sibling tools like marketplace_cart_add_site by specifying 'Package' rather than 'Site'.

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 clear context with 'Prices are re-derived server-side; the cart caps at 5 rows.' This implies usage constraints but does not explicitly state when not to use or list alternatives.

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 show readOnlyHint=false and destructiveHint=false, indicating mutation without destruction. The description confirms it adds to cart, matching annotations. However, it adds little beyond annotations—no mention of side effects, authorization needs, or how the cart state changes.

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?

Description is a single short sentence that conveys the core action concisely. No unnecessary words. Front-loaded with the verb and resource.

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 tool with one parameter and no output schema, the description covers the basic action. It lacks context about whether the cart must already exist or is created implicitly, but this is minor given sibling tools like marketplace_cart and marketplace_cart_checkout.

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% with one parameter. The description in the schema ('websiteId from marketplace_sites') is clear. The tool description does not add new meaning or usage details 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 'Add a single-website placement to the cart' clearly states the action (add), the resource (single-website placement), and the target (cart). It distinguishes from sibling tools like marketplace_cart_add_package and marketplace_cart_remove by specifying 'single-website placement' vs package.

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 guidance on when to use this tool versus alternatives. The name implies it is for adding a specific website to the cart, but there is no mention of prerequisites or exclusions. Usage context is implied but not 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?

Discloses key behavior: no charge is made, and the payment boundary is deliberate. Annotations provide no additional safety hints, so description adds essential 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?

Three sentences, front-loaded with key action, no wasted words. Efficient and clear.

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 zero parameters and no output schema, description covers all necessary details: purpose, behavior, output (URL), and user action.

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?

No parameters exist, so description has no burden. Baseline of 4 applies as per rules.

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 clearly states it starts checkout, returns a Stripe URL, and charges nothing. Distinguishes from other marketplace tools by focusing on the checkout initiation step.

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 instructs to give URL to the user, clarifying the intended use. Lacks explicit when-not-to-use or alternatives, but 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 destructiveHint=true, so the description confirms destructive behavior. However, it does not elaborate on effects like what happens to the cart state or if removal is permanent. With annotations covering the safety profile, the description adds minimal extra 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 a single, effective sentence that conveys all essential information without waste. It is front-loaded and 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?

Given the tool's simplicity, one required parameter, no output schema, and strong annotations, the description sufficiently explains the core action. However, it could mention that the index must be valid (e.g., within bounds) or that removal is immediate.

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 is only one parameter, and the schema description already states 'Row index from marketplace_cart.' The tool description repeats that but adds no new semantics. With 100% schema coverage, 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 the verb 'Remove', the resource 'row from the cart', and the condition 'by its index', leaving no ambiguity. It distinctly differentiates from sibling tools like marketplace_cart_add_package.

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 on when to use this tool versus alternatives, such as marketplace_request_remove or marketplace_cart_checkout. No preconditions or context provided beyond the basic action.

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

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

Annotations only declare this as not read-only and not destructive, so the description adds value by revealing the pricing uplift, availability constraint, and the need to reference marketplace_cart for per-row details. It does not mention error conditions or side effects, but the provided context goes beyond the annotations.

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

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

The description is two sentences, with the first directly stating the action and the second providing essential domain context (pricing and availability). No fluff or redundancy.

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

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

For a simple mutation tool with full schema coverage and no output schema, the description covers the essential context: the action, pricing, availability constraints, and where to get per-row data. It lacks explicit return-value or error info, but that is less critical here given the tool's simplicity.

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 describes both parameters (index and homepage) with 100% coverage, so baseline is 3. The description adds meaning by explaining the effect of homepage (turn link on/off) and connecting index to a row from marketplace_cart that contains availability and uplift info, enriching the 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 action ('Turn the homepage link on or off') and the specific resource ('one single-placement row'). It also distinguishes itself from sibling cart tools like marketplace_cart_remove or marketplace_cart_add_site by focusing on the homepage link toggle.

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 context on when to use the tool by mentioning that homepage links cost 60% more and are only sold where the publisher accepts one, and it references marketplace_cart for availability data. However, it does not explicitly state when to use the tool over 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 are minimal (only flags), and description does not disclose side effects, mutability, or safety beyond the basic action. For a write tool, more transparency is needed.

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?

Extremely concise: one sentence plus a parenthetical. Front-loaded with the key action. No unnecessary words.

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 5 parameters and no output schema, the description is too brief. Missing details on how to find orderNo, what optional parameters do, and what the response is. Not complete for effective use.

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 20% (only orderNo described). The tool description adds no parameter-level information. Agent must infer from parameter names, which is risky.

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 briefs a paid order for publishers to start, and the parenthetical adds context about after payment. However, the verb 'brief' is not fully explained, but given the domain, it's sufficient.

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 use after payment, but no explicit alternatives or when-not-to conditions are given. Sibling tools exist, but no guidance on choosing this over others.

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 provide readOnlyHint=true, which is consistent. Description adds that orders are 'as publishers deliver', implying live status. No additional context on authentication, rate limits, or side effects. Adds some value but limited.

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, concise, but second sentence is cryptic and may distract. Not front-loaded clearly; first sentence could be more direct. Moderate structure.

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

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

No output schema or parameters; description is the sole source. It explains output content but misses details like ordering, pagination, or format. Adequate for a simple list-all tool, but could be richer.

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 has zero parameters and is fully covered. Baseline for 0 params is 4. Description does not add parameter info but is not expected to. Adequate.

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 output includes 'marketplace order with its placements, their status, and live URLs', clearly indicating what the tool returns. Combined with title 'List orders', purpose is clear, though description lacks an explicit verb. Differentiates from sibling 'marketplace_order_brief' by including placements and URLs.

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 guidance on when to use this tool vs siblings. The tip 'An unbriefed paid order is the thing to chase' hints at a use case but does not clarify tool selection or 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?

Annotations already declare readOnlyHint=true, so description adds value by specifying the result includes pricing and websites, but does not disclose additional behavioral traits beyond what annotations imply.

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?

Single sentence, front-loaded with key information, no redundant words. Efficiently conveys purpose and scope.

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 listing tool with no parameters, the description fully explains what the tool returns. No additional information (e.g., output schema) is needed.

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?

No parameters exist, so schema coverage is 100%. Description adds meaning by specifying the output includes pricing and websites, which compensates for the lack of output 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?

Description uses specific verb 'list' and resource 'backlink packages', and adds context about account-specific pricing and included websites, clearly distinguishing it from sibling tools like marketplace_sites or marketplace_cart.

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

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

Usage is implied: to view available backlink packages for the account. However, no explicit guidance on when not to use this tool (e.g., for adding to cart or ordering) or comparison with alternatives.

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 indicate write operation (readOnlyHint=false) and non-destructive (destructiveHint=false). The description adds that passing an id edits instead of adds, and requires a verified website, which goes 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 a single, information-dense sentence. It is front-loaded with the purpose and includes the key usage note about editing via id.

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 5 parameters, full schema coverage, and annotations, the description is mostly complete. It explains core functionality and editing override. However, it does not mention the return value or error cases, but these are partly covered by the lack of output schema.

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

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

Schema coverage is 100%, so baseline is 3. The description adds context for 'id' (edit vs add) and 'budgetAmount' (pay/payment), but does not provide additional constraints or formatting 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 verb (post or edit), the resource (ask/request), and distinguishes from siblings like marketplace_request_remove (delete) and marketplace_requests (list). It also mentions the prerequisite (verified website).

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 when to use: to post a new ask or edit an existing one. It mentions the required condition (verified website) but does not explicitly state when not to use or provide alternatives.

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 indicate destructiveHint=true, and the description aligns without adding extra behavioral info like consequences or permissions.

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 extremely concise with no wasted words, but could be slightly more informative without losing conciseness.

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 removal tool with two parameters and no output schema, the description combined with schema is adequate, though it lacks a note on confirmation or error 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?

Schema coverage is 100%, and the description adds no additional meaning beyond what the schema already provides for 'id' and 'site'.

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 'Take a posted ask down' clearly states the action (removing a posted request) and resource (ask). The name and title align, and it distinguishes from siblings like marketplace_request_post.

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 context implies it is used when wanting to remove an ask, but no explicit instructions on when to use vs alternatives or prerequisites are provided.

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, so the description's mention of 'asking' aligns with read-only behavior. However, no additional behavioral traits (e.g., response format, pagination) are disclosed beyond what annotations 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 a single, front-loaded sentence with no unnecessary words. Every part serves to clarify the tool's function.

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

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

With no output schema, the description should explain what the returned data contains (e.g., request details, fields). It only says 'what a website is asking for,' leaving agents without crucial context for interpreting results.

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 parameter 'site' is already described in the schema. The tool description does not add new meaning or usage context beyond the schema's 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 the tool lists what a website is asking for, aligning with the name and title. It distinguishes from sibling tools like marketplace_request_post and marketplace_request_remove, but lacks specific details about the output format.

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 for viewing asks but provides no explicit guidance on when to use this tool versus alternatives like marketplace_request_post or marketplace_request_remove. No exclusions or prerequisites are mentioned.

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 value beyond the readOnlyHint annotation by explaining ranking by niches and the relevance of websiteId for cart operations. It 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?

Two sentences, no redundancy, and key information is front-loaded. Every sentence adds value.

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

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

Lacks output schema and does not describe return fields beyond mentioning websiteId. For a listing tool, more detail on response structure would improve completeness.

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 for the 'limit' parameter is 100% via its description. The tool description does not add additional parameter details, so 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 states that the tool lists single-website placements ranked by user's niches, which clearly indicates its purpose. However, it does not explicitly distinguish itself from siblings like 'list_sites' or 'find_sites', leaving some ambiguity about when to use this specific 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?

No guidance is provided on when to use this tool versus alternatives. The description does not mention when-not-to-use or suggest other tools for different scenarios.

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 indicate readOnlyHint=true, confirming non-destructive behavior. The description adds context that it provides traffic validation and spam/trust alerts, which goes beyond the annotation. No contradiction; it accurately describes a read-only monitoring operation with no side effects.

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, front-loading the core purpose and output. It uses clear, jargon-light language and avoids redundancy. Every word adds value, making it efficient and easy to parse.

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

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

Given no output schema, the description adequately conveys the tool's function and output (change digest, alerts). It covers the optional site restriction and daily/weekly cadence. However, it could mention what the digest looks like or that no output schema exists, but overall it provides sufficient context for an agent to decide to invoke this tool.

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

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

Schema coverage is 100% with both parameters having descriptions. The description adds minimal extra meaning ('Optionally restrict to one site' for 'site', and 'Use the daily cadence instead of weekly' for 'daily'), but these largely mirror the schema descriptions. Thus, the description does not significantly enhance 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 monitors sites for changes and provides a weekly/daily digest with traffic validation and spam/trust alerts. It specifies the action (authority watch), the resource (sites), and the output (change digest, alerts). It distinguishes itself from siblings like 'list_sites' or 'get_site' by focusing on monitoring rather than listing or retrieving static data.

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 use cases (getting change digests and alerts) but does not explicitly state when not to use or provide alternatives. It mentions optional restriction to one site, but lacks explicit guidance on when to choose this tool over others, such as 'list_sites' for a full site list or 'get_site' for detailed info on a single site.

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 explicitly warns 'SENDS REAL EMAIL when dryRun is false', which goes beyond the annotations (readOnlyHint: false, openWorldHint: true) by naming the concrete external effect. It also stresses the need for preview and approval, adding critical behavioral context for a side-effectful 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?

Two sentences total, front-loaded with the core purpose, followed by a prominent warning and a concise note about dry-run generation. Every clause earns its place, with no redundancy.

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

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

Given the tool's side-effect potential and no output schema, the description covers the essential workflow, real-email risk, and standard-proposal generation. It does not mention destinationUrl's send-time requirement, but that is already in the schema; overall, it provides sufficient context beyond structured fields.

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 covers all 6 parameters (100%), so baseline is 3. The description adds meaningful semantics by explaining how dryRun controls send vs. preview and that omitting subject/message in a dry run generates the standard proposal. This enriches understanding of dryRun, subject, and message beyond their schema 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?

The description uses specific verbs ('preview or send') and clearly identifies the resource ('one-link-each editorial exchange proposal') and actor ('as the account owner'). It distinguishes from sibling tools like find_link_exchanges by focusing on the proposal action rather than discovery.

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 clear workflow guidance: 'Always preview first and get the user's approval before sending' and explains the dry-run behavior for generating a standard proposal. However, it does not explicitly mention exclusions or alternative tools beyond the implied role distinction.

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 safety and idempotency hints. The description adds that it snapshots difficulty, but does not elaborate on effects (e.g., whether previous data is overwritten) 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 a single, efficient sentence that front-loads the action ('Re-snapshot') with no wasted words.

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, the description is sufficient but could be more complete by explaining what the agent can expect after the snapshot (e.g., updated difficulty value).

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 no additional meaning beyond what is in 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 uses a specific verb 'Re-snapshot' and resource 'saved keyword target's difficulty', clearly distinguishing it from sibling tools like add_tracked_keyword or list_tracked_keywords.

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 when to use (to refresh difficulty) but lacks explicit guidance on prerequisites or when not to use. No alternatives are mentioned.

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 states 'Delete', which aligns with the destructiveHint: true annotation. However, it adds no extra behavioral context beyond the annotation, such as irreversibility or effects on other scans.

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, concise sentence that directly states the tool's function with no wasted words.

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 destructive tool with two required parameters and no output schema, the description adequately conveys the action. However, it could include a brief note about the origin of the promptId.

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 description adds no additional meaning beyond what the schema already provides for 'site' and 'promptId'. 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 the action 'Delete' and the resource 'one tracked question', specifying the identifier 'by its prompt id'. It effectively distinguishes this tool from siblings like 'add_ai_visibility_prompt' and 'get_ai_visibility'.

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, such as prerequisites or context. For example, it does not mention that the promptId should come from get_ai_visibility, though that is hinted in the parameter description.

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 declare destructiveHint=true, so the destructive nature is already known. The description adds no additional behavioral context beyond stating the action. A 3 is appropriate given the annotation coverage.

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 very short (4 words) and to the point. It could benefit from a bit more detail without losing conciseness, but it is efficient and not 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 destructive tool with no output schema and annotations covering safety, the description is minimally adequate. It lacks information about side effects or return value, but the operation is straightforward.

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 has 100% coverage with descriptions for both parameters ('id' and 'site'). The tool description does not add any parameter information beyond what the schema already provides, so baseline 3.

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

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

The description 'Remove a tracked keyword target' clearly states the action (remove) and the resource (tracked keyword target). It distinguishes from sibling tools like 'add_tracked_keyword' and 'refresh_tracked_keyword'.

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. It does not mention prerequisites, typical use cases, 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?

The description adds the behavioral detail that all prompt IDs must be provided, but annotations already indicate idempotentHint=true and destructiveHint=false. No additional behavioral traits (e.g., response behavior, ordering effects) are disclosed beyond the annotation set.

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

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

The description is a single, front-loaded sentence that conveys the essential information without any extraneous words. Every word is purposeful.

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

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

Given no output schema, the description does not mention return values. It adequately explains the input requirement but lacks context about what happens on success or error, which would be helpful for a mutation tool.

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

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

Schema coverage is 100%, so baseline is 3. The description reinforces that promptIds must contain all IDs in the new order, which adds marginal value over the schema description 'All prompt ids, in the new order.' No further parameter insights are provided.

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

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

The description clearly states the action 'Reorder the tracked questions' with a specific verb and resource. It also specifies the requirement to pass every prompt id in the new order, which distinguishes it from sibling tools like add, remove, or reset.

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 by instructing to pass all prompt IDs, suggesting you need the current list first. However, it does not explicitly state when to use this tool versus alternatives (e.g., reset_ai_visibility_prompts) 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 set destructiveHint: true, and the description reinforces this by stating 'Destructive: the old questions are gone.' It adds value by explaining the reseeding behavior and the paid plan restriction, which annotations do not cover.

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 concise, consisting of three short sentences that front-load the core action. Every sentence adds relevant information without any filler.

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

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

For a simple destructive reset tool with one parameter and no output schema, the description adequately covers the action, constraints, and outcome. It does not mention the return value, but the agent can infer a generic success/failure response.

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 has 100% description coverage for the only parameter 'site', with a clear explanation. The tool description does not add any additional meaning about the parameter 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?

The description clearly states the tool's action: discarding the current question set and reseeding from site keywords. It uses specific verbs 'throw away' and 'reseed', and distinguishes from sibling tools like add_ai_visibility_prompt and remove_ai_visibility_prompt.

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 'Paid plans only' as a prerequisite but does not provide explicit guidance on when to use this tool versus alternatives like add_ai_visibility_prompt or run_ai_visibility_scan. Usage context is implied but not 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?

Annotations (readOnlyHint=false, openWorldHint=true) indicate the tool has side effects and is not read-only. The description adds concrete behavioral traits: it spends real vendor budget and enforces a weekly rate limit per site. This is valuable context beyond the 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 concisely convey the core action and critical constraints. No redundant information; the description is front-loaded with the immediate action, making it easy to parse.

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?

While key constraints (budget, rate limit) are covered, the description omits what the agent should expect after the scan (e.g., results format, where to view them) and prerequisites like whether the site must be verified or imported first. Given the tool's cost and side effects, this is a gap.

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

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

Schema coverage is 100% with a clear description of the 'site' parameter. The tool description adds general context about 'tracked questions' but does not elaborate on what the parameter means beyond the schema. At high coverage, 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 the tool runs a visibility scan across AI engines by asking tracked questions. It distinguishes from sibling tools like get_ai_visibility (read) and diff_ai_visibility_runs (comparison) by emphasizing this is an active, budget-consuming scan.

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 advises checking account_usage first, mentions the one-run-per-site-per-week rate limit, and notes that paid plans use a monthly budget. This gives clear preconditions and usage constraints, helping the agent decide when to invoke.

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 value beyond annotations by explaining that unchanged tasks carry over and re-runs don't reopen finished work, indicating non-destructive behavior despite generating a fresh plan. Annotations already indicate not read-only and not destructive.

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 concise sentences front-load the key action and constraints, with no wasted words. Every sentence adds value.

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

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

The description explains behavior and payment requirement but lacks information about the return value or side effects. Given no output schema, the agent might need to know what data it gets back for proper 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?

With 100% schema coverage, the description does not add extra meaning to the single 'site' parameter. The schema description suffices, so baseline score 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 specifies the action ('Generate a fresh growth plan') and uniquely distinguishes it from siblings like get_growth_plan (retrieve) and update_growth_task (update) by noting it creates a fresh plan and that re-runs carry over progress.

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 clearly states 'Paid plans only,' indicating a prerequisite. It does not explicitly list alternatives or when not to use, but the context of siblings implies other tools for retrieval or task updates.

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 behavioral context beyond annotations: it reveals that the tool consumes real URL Inspection quota and enforces a 12-hour cooldown. No contradiction with annotations (readOnlyHint=false, destructiveHint=false).

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?

Extremely concise: one sentence plus a condition. Every word is necessary, and the main action 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?

Given low complexity (1 required param, no output schema), the description is sufficient. It covers purpose, quota impact, and cooldown. Might benefit from briefly stating output, but not required.

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 description for the 'site' parameter matches the schema. The description adds no additional meaning beyond what the schema provides, which is adequate.

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 'Run a fresh index audit,' specifying the action (run) and resource (index audit). It effectively distinguishes from siblings like 'get_gsc_audit' and 'get_gsc_performance'.

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 a 12-hour cooldown between runs and that it spends real quota, providing clear context for when to use it. However, it does not explicitly state when not to use it or compare with alternatives.

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 indicate non-read-only and non-destructive behavior. The description adds the 'Paid plans only' pricing constraint but does not detail side effects like overwriting previous location or triggering a scan.

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 extremely concise with two short sentences. It includes only essential information without any waste.

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 mutation tool with three required parameters and no output schema, the description adequately covers the core action and pricing constraint. It lacks details on return behavior or idempotency, but these are not critical for basic usage.

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 input schema already describes all parameters. The description adds minimal extra meaning beyond the schema (e.g., 'country market' is already covered by schema's 'location' 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 the action: 'Pin one tracked question to a country market.' This uses a specific verb and resource, distinguishing it from sibling tools like add_ai_visibility_prompt or remove_ai_visibility_prompt.

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 a constraint ('Paid plans only') but provides no explicit guidance on when to use this tool versus alternatives. Usage context is implied but not clearly stated.

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 mark readOnlyHint=false and destructiveHint=false, which the description aligns with. Beyond annotations, it discloses the ownership behavior (owned submits count against cap), the anonymous accounting distinction (never shows in dashboard, no owner emails, uncapped), and the siteCheck side-effect (stores a report fetchable later). Rich behavioral context beyond structured fields.

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

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

Tight, front-loaded description in one opening sentence plus two specific domain/accounting notes. Every sentence earns its place; no filler. The schema handles parameter details so the description stays focused on high-level guidance.

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 create/write tool with 7 params fully covered by schema and informative annotations, the description adds the key scoping rules (primary domain, cap counting, anonymous distinction). No output schema exists, so return-value expectations rely on siblings, but the write nature is clear and the siteCheck param points to check_site for report retrieval.

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 documents all 7 parameters. The description adds value by explaining the strategic meanings: anonymous's behavioral implications and siteCheck's side effects are described in the schema itself. The description adds the primary-domain rule, which augments the url param meaning. Baseline 3 is appropriate given full schema coverage with some description value added.

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 verb+resource ('List a new website on VerifiedDR') plus the ownership scoping ('owned by your account'). It distinguishes from siblings by clarifying this is 'owned' submission versus anonymous, and the free-tier cap note differentiates it from find_sites/lookup_site/check_site.

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 domain guidance ('Use the primary domain, not blog.example.com'), distinguishes owned vs anonymous submits, references the free-tier cap, and sibling tools (list_categories, check_site) are explicitly cross-referenced in the schema. The anonymous parameter description even tells the agent when to use anonymous mode.

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 indicate this is not read-only and not destructive, and the description correctly implies mutation ('move status'). Beyond that, no additional behavioral details (e.g., permissions, side effects) are provided. For a mutation tool, more transparency would be beneficial.

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