Vibeking

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

Annotations already declare readOnlyHint=false, idempotentHint=true, and destructiveHint=false. The description adds valuable context beyond these: it states that country/language are inherited from the site, that it requires an active subscription, and that it counts toward the plan keyword limit. This informs the agent of side effects and constraints without contradicting 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 zero filler. The primary action and core constraints are front-loaded, and the permissions/limit context follows naturally. Every phrase adds 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?

For a simple two-parameter tool with no output schema, the description covers the essential context: who can use it, required subscription, limit impact, and character restrictions. It does not describe the return value or behavior on duplicates, but given idempotentHint and the tool's simplicity, this is adequate.

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

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

Schema coverage is 100%—both parameters have descriptions. The description adds the max-80-character limit (already in schema) and clarifies that country/language come from the site, which relates to parameter interpretation but does not introduce new parameter semantics. It meets the baseline for high schema coverage.

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

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

The description states a clear verb ('Add') and specific resource ('keywords to daily Google rank tracking for a website'), and distinguishes itself from the sibling get_keywords by implying a mutating operation. The additional constraints (max 80 characters, country/language from site) make the purpose unmistakable.

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 prerequisites (owners/admins only, active subscription, counts toward plan limit) but does not explicitly contrast with alternative tools like get_keywords or other mutating tools. There is no 'when to use' versus 'when not to use' guidance, though the purpose is self-evident.

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

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

Annotations already provide readOnlyHint=true and idempotentHint=true, which cover the safety profile. The description adds content details but no additional behavioral context such as data freshness, pagination, or performance limitations. It does not contradict the annotations, and given the annotations, a 3 is appropriate.

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 that is front-loaded with the primary purpose and lists the key output components without any fluff. Every word contributes to understanding what the tool returns.

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 only two parameters, no output schema, and annotations covering safety, the description is fairly complete. It enumerates the expected output dimensions (share per engine, gaps, cited competitors, tracked domains), giving the agent a solid mental model. It could mention the default weeks value, but that is already in the schema.

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

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

Schema description coverage is 100% for both parameters (site_id and weeks), so the schema already documents them fully. The description adds no parameter-specific information beyond what the schema provides, so it meets the baseline but does not exceed it.

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

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

The description states the verb 'Show' and the resource 'AI answer visibility for a website', then lists specific output components (share per engine per week, open answer gaps, cited competitors, tracked domains). It is clear and specific, but it does not explicitly differentiate from sibling tools like get_site_metrics or get_competitors, so it misses the distinction bonus.

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 guidance on when to use this tool versus the many sibling tools. It does not mention any alternatives, conditions, or exclusions. The description simply describes what it shows, leaving the agent to infer its place among the 19 siblings.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds extra context by noting the data is refreshed monthly via DataForSEO (implying possible staleness) and lists the specific data components returned. This goes beyond the structured annotations.

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

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

The description is a single sentence that front-loads the action and resource, followed by a compact enumeration of data points and a useful parenthetical about data freshness. It is efficient with no filler; the length is justified by the amount of specific information conveyed.

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

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

For a one-parameter, read-only tool with no output schema, the description adequately communicates what the caller will receive (multiple competitor data categories). It omits potential pagination or result-limit details, but given the simplicity of the tool, the description is sufficient for correct invocation.

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

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

The schema already provides full coverage for the single site_id parameter, including a clear description ('The site id, as returned by list_sites'). The tool description adds no additional meaning to the parameter, 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 uses a specific verb ('List') and clearly identifies the resource ('competitors of a website') along with the precise data returned (organic keywords, estimated traffic, top counts, shared keyword positions, suggested competitors). This makes it unambiguous and easily distinguished from sibling tools like get_keywords or get_site_metrics.

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 you need competitive intelligence for a website) but does not explicitly contrast it with sibling tools or state when not to use it. There's no mention of alternatives or exclusions, so the guidance is implicit rather than explicit.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=false, and idempotentHint=true, covering the safety profile. The description adds no behavioral details beyond the return fields (status, last sync, error), which is not behavioral transparency per se. It does not contradict annotations and provides minimal extra context, so 3 is appropriate.

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 efficiently states the resource, examples, and return fields. There is no filler or redundant 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?

For a simple read-only tool with one parameter and no output schema, the description covers the action, resource, and return content (status, last sync, error). It does not mention pagination or error handling, but given the low complexity and annotation coverage, this is adequate.

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

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

Schema description coverage is 100%: site_id is fully described as 'The site id, as returned by list_sites.' The description adds no additional parameter semantics, so it does not enhance the schema. Baseline of 3 is correct.

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 'List' and the resource 'data connections of a website', naming specific connection types (Search Console, Analytics, Ads, ChatGPT Ads) and the returned data (status, last sync, error). It is specific enough to distinguish from siblings like get_site_metrics or get_keywords, though it does not explicitly name an alternative.

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

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

Usage context is only implied: the tool lists connections for a site, so an agent would use it when needing connection status. The schema description adds the prerequisite that site_id must come from list_sites, but there is no explicit when-to-use or when-not-to-use guidance, nor any mention of 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 declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds useful output scoping (which fixes, what fields) but does not mention behavior like pagination, response format, or any limits, though it does not contradict 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?

A single, front-loaded sentence that states the operation and the relevant output details with no filler. 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?

For a zero-parameter, read-only listing tool, the description gives enough context: it specifies the resource and the expected fields (prices, bilingual titles/descriptions). It does not detail the response shape, but no output schema exists and the operation is simple.

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 the schema is complete, so no parameter documentation is needed. The baseline for a zero-parameter tool is 4, and the description focuses on the output content instead, which is appropriate here.

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

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

The description names a specific verb ('List'), a specific resource ('fixes Vibeking can carry out'), and the exact output fields (price in EUR excl. VAT, title/description in Dutch and English). This clearly distinguishes the catalog from sibling tools like get_fix_plan or order_fix.

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

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

The intended usage is implied: call this when you need the catalog of available fixes and pricing. However, it never explicitly contrasts it with alternatives such as get_fix_plan or get_fix_changes, and it gives no exclusions or conditions.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the description is not required to state safety. It does add value by detailing what the change set contains (field, before/after values, status), which goes beyond the structured hints. However, it does not disclose potential pagination or the response structure, leaving some behavioral ambiguity. 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?

A single sentence that concisely states the tool's output without extraneous words. The key information is front-loaded: what is returned and its composition. No redundancy.

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

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

For a simple read-only tool with one well-documented parameter and annotations covering safety, the description is mostly adequate. However, there is no output schema, and the description does not clarify whether the result is a list of changes, how pagination works (if any), or the exact structure of the response. The phrase 'per page' is ambiguous, leaving room for misinterpretation.

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 the only parameter (order_id) with a clear description ('The fix order id, as returned by list_tasks'). With 100% schema coverage, the description adds no further parameter detail, so a baseline of 3 applies per the rubric.

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

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

The description states a specific verb ('Return'), a clear resource ('change set of a fix order'), and elaborates on the content (per page: field, value before and after, status). This clearly distinguishes it from sibling tools like get_fix_catalog or get_fix_plan, which return different aspects of fix orders.

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 its purpose (retrieving a fix order's changes) but provides no explicit guidance on when to use it versus alternatives such as get_fix_plan or get_fix_catalog. It neither states prerequisites nor mentions exclusion criteria, leaving the agent to infer from the tool name and sibling 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 and idempotentHint=true, so the safety profile is covered. The description adds that the plan is stored and includes generation timing, which is useful, but it does not address edge cases such as a missing plan or error behavior.

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, front-loaded with the action and resource, with no filler or repetition.

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

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

For a one-parameter, read-only retrieval tool, the description covers what is returned (steps and generation time) and the annotations cover safety. No output schema exists, but the description gives enough for an agent to invoke it correctly.

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

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

The single parameter task_id is fully documented in the schema with a clear description ('as returned by list_tasks'). The tool description adds no additional parameter-level detail, so the schema carries the burden.

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 ('Return') and names a concrete resource ('stored AI fix plan of a task'), and clarifies the content ('steps and when it was generated'). This distinguishes it from sibling tools like get_fix_catalog or get_fix_changes, which concern different fix-related artifacts.

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

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

The description makes the tool's context clear: use it to retrieve an existing fix plan for a task. It does not explicitly name alternatives or state when not to use it, so it stops short of full routing guidance.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the read-only nature is covered. The description adds value by specifying exactly what data is returned (current value, previous period, baseline, targets, on-track status), which goes beyond the annotations and helps the agent understand the output without an output schema.

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

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

The description is a single, well-structured sentence that front-loads the action and resource, then lists the key data fields. No unnecessary words or repetition.

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

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

Given the tool has only one parameter and annotations cover safety, the description provides a comprehensive list of what the response will contain (current value, previous period, baseline, targets, on-track status). This is sufficient for an agent to know what to expect, and no critical details are missing.

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

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

The schema fully describes site_id as 'The site id, as returned by list_sites', so the parameter semantics are already clear. The tool description does not add additional meaning beyond that, so a baseline score of 3 is appropriate given high schema coverage.

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

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

The description clearly states the tool shows goals per metric for a website, listing specific data fields (current value, previous period, baseline, targets, on-track status). This differentiates it from siblings like get_site_metrics or get_report by focusing specifically on goals per metric.

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 retrieving goal-related metrics, but does not explicitly mention alternatives or when not to use it. However, the clear resource scope (goals per metric) provides sufficient context to distinguish it from other reporting tools, though it lacks explicit exclusions.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, and the description does not contradict them. It adds value by disclosing the fixed 28-day window and the fact that both search queries and tracked keyword rankings are returned, which is behavioral context beyond the structured fields.

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

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

The description is a single well-structured sentence that front-loads the core action and resource, then packs the return fields without redundancy. 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?

With no output schema, the description adequately conveys what the tool returns: queries with metrics plus tracked keyword rankings. It does not mention sort order or pagination behavior, but the limit parameter and simple read-only nature keep these gaps minor.

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 fully documents the site_id and limit parameters. The description adds no parameter-level detail beyond what the schema provides, so the 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 a specific verb ('List') and names a precise resource ('Search Console queries for a website over the last 28 days') along with the data fields returned. It also mentions the tracked-keyword component, which distinguishes it from sibling metrics/pages/competitors 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 clearly states the context of use: retrieving Search Console query performance for a website with a fixed 28-day window. It doesn't name explicit alternatives or exclusions, but the resource and timeframe make the intended use reasonably unambiguous.

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

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

Annotations already establish read-only and idempotent behavior. The description adds useful context by specifying the 90-day time window for clicks and that other fields come from the latest completed crawl, which implies a dependency on crawl completion. It does not contradict 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 a single 31-word sentence with no filler; the core action is front-loaded before the metric list. It is efficient but slightly run-on, so it falls just short of a perfect structure score.

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

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

For a read-only list tool with fully documented parameters and no output schema, the description covers the main return fields and data provenance (90-day clicks, latest crawl). It lacks explicit handling of pagination or what 'issues per page' counts, but these are minor gaps given the schema already documents limits.

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%: site_id, sort, and limit all have descriptive text including defaults and ranges. The description adds no parameter-specific guidance beyond the schema, so it stays at 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 names a specific action ('List the pages of a website') and enumerates the exact data returned (Google clicks over 90 days, status code, title, H1, meta description, issues). This makes it clearly distinguishable from sibling tools like get_keywords or list_issues, which target different resources or metrics.

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 prefer this tool over alternatives or mention related tools such as list_issues or get_site_metrics. However, the detailed output list implies the use case of retrieving per-page SEO and crawl metrics, so the usage is indirectly inferable rather than absent or misleading.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true. The description adds that the report is 'stored', indicating a pre-existing snapshot rather than live computed data, and it discloses the content categories. No behavioral contradictions are present.

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

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

The description is a single compact sentence that front-loads the action and object, then lists report sections without filler 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 read-only tool with two well-documented parameters, safety annotations, and no output schema, the description covers the core purpose and return contents. It leaves minor ambiguity about the exact response shape and the meaning of 'the three decisions', but this is a small gap for an otherwise simple retrieval 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 fully documents both parameters: site_id is a UUID from list_sites and month uses the yyyy-mm pattern. The description mentions 'website and month' but adds no format, derivation, or usage detail beyond the schema. With 100% schema coverage, the baseline of 3 applies.

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

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

The description states a specific verb ('Return') and resource ('stored monthly report content'), and enumerates the report sections: key numbers, health, AI visibility, fixes, goals, and the three decisions. This clearly separates it from sibling tools that return individual metrics, though it does not explicitly name an alternative.

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

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

The phrase 'stored monthly report content' implies this tool retrieves a pre-generated aggregate report, and listing its sections hints that it is an umbrella alternative to several metric-specific siblings. However, there is no explicit when-to-use, when-not-to-use, 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?

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds meaningful behavioral context beyond annotations: it specifies aggregation granularity ('day totals only'), the exact sources included, and currency details (EUR for chatgpt_ads, ad account currency for google_ads). This helps the agent understand what the returned data represents without an output schema.

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

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

The description is a single, information-dense sentence that front-loads the core action and scope, then lists the sources and metrics. Every clause earns its place: the 'day totals only' qualifier prevents misinterpretation, and the source/metric enumeration is essential for an agent to know what data is available. 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 read-only, idempotent tool with 2 well-documented parameters and no output schema, the description is nearly complete. It tells the agent what data comes back (per source and metric, day totals) and the currency nuances. The only minor gap is that it doesn't describe the exact response shape (e.g., whether it's a flat list or nested object), but with no output schema and a clear aggregation description, this is a minor omission.

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 both parameters (days and site_id) are already documented in the schema. The description adds context about the time window ('last N days') and the site_id's origin ('as returned by list_sites' is in the schema, not the description). The description doesn't add new parameter-level meaning beyond what the schema provides, 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 states a specific verb ('Summarize'), a clear resource ('daily metrics for a website'), and a precise scope ('over the last N days, totalled per source and metric (day totals only)'). It also enumerates the exact sources and metrics, which distinguishes it from sibling tools like get_report or get_ai_visibility without needing to open their schemas.

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

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

The description clearly implies when to use this tool: when you need daily totals per source/metric for a site over a recent window. It does not explicitly name alternatives or exclusions, but the detailed source/metric list and 'day totals only' qualifier provide enough context to differentiate it from broader reporting tools. A small gap: it doesn't explicitly say 'use get_report for non-daily or cross-site analytics,' but the context is strong.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds context about what data is returned (plan, status, limits, usage, MCP calls this month), which is useful. It doesn't disclose any side effects, rate limits, or auth requirements, but for a read-only tool with annotations, 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 sentence that front-loads the key information: what the tool shows and the specific data points. No wasted words, and the MCP calls detail adds value without bloating the text.

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

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

For a read-only, single-parameter tool with full schema coverage and annotations, the description is nearly complete. It could mention that the organization_id comes from list_sites, but that's already in the schema. The only minor gap is not describing the output format, but there's no output schema and the description lists the data points, which is 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 description coverage is 100%, so the single parameter organization_id is fully documented in the schema. The description doesn't add extra meaning beyond what the schema provides, but it doesn't need to. 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 uses a specific verb ('Show') and clearly identifies the resource: an organization's subscription details, including plan, status, limits, and current usage. It also mentions MCP calls this month, which adds specificity and distinguishes it from other get_* 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 implies when to use this tool: when you need subscription/plan/usage information for an organization. It doesn't explicitly name alternatives or exclusions, but the context signals and sibling list show many get_* tools; the description's focus on subscription/usage is clear enough to guide selection. A small gap: no explicit 'use this instead of X' 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 declare readOnlyHint=true and idempotentHint=true, and the description does not contradict them. The description adds little behavioral context beyond that, such as ordering or pagination, but the read-only/idempotent profile reduces the burden on the description.

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 focused sentence stating the action, scope, and optional filters. There is no filler, and it does not redundantly repeat 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 simple read-only list operation with fully documented parameters and annotations covering safety, the definition is nearly complete. It lacks explicit return-shape or pagination details, but the low complexity makes those omissions non-critical.

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

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

Schema description coverage is 100%, with each parameter already documented including enums, bounds, and a default for limit. The description only restates the high-level status and severity filters, so it does not add meaningful semantic value 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 identifies the resource (issues), the scope (a website), and the optional filters (status and severity). It is clear and unambiguous relative to sibling tools like list_sites and list_tasks, though it does not explicitly name a sibling to differentiate from.

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 this tool is used when an agent needs the issues belonging to a site and wants to optionally narrow by status or severity. It does not provide when-not-to-use guidance or name alternatives, so usage context is only implicit.

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

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

Annotations already declare readOnlyHint and idempotentHint, so the safety profile is covered. The description adds behavioral context beyond annotations by clarifying the access scope and the included attributes (organization, platform, language), giving the agent a better sense of the result.

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 action, scope, and output fields without unnecessary words. Every phrase 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 parameterless, read-only, idempotent list tool, the description is fully sufficient. It states what is listed, for whom, and what information is returned; no critical context is missing.

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

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

The tool has zero parameters and schema description coverage is 100%, so there are no parameter semantics for the description to clarify. The baseline of 4 applies because nothing is missing.

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 ('List') and identifies the resource ('websites the signed-in user can access'), adding a clear access scope. It also names the result dimensions (organization, platform, language), distinguishing it from sibling tools like get_pages or get_site_metrics.

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

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

The description clearly implies when to use the tool: to list websites available to the signed-in user. It does not explicitly state exclusions or alternatives, but the context is clear for a simple list operation and no conflicting siblings exist.

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

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

Annotations already declare readOnlyHint=true and idempotentHint=true, so the safety profile is covered. The description adds that the response includes 'fix and verification instructions,' which is useful content context. However, it does not disclose any further behavioral traits like result ordering, pagination semantics beyond the limit parameter, or the distinction between fix tasks and other task types.

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-front-loaded sentence with no filler. The primary action and resource appear first, and the instructional content detail adds value without bloat. Every word 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 simple read-only list tool with full schema coverage and readOnly/idempotent hints, the description is largely complete. It mentions that fix and verification instructions are included, which gives the agent a sense of the response content. A small gap is the lack of explicit guidance on the default behavior or the relationship between fix tasks and the site_id, though these are partially inferred from the schema and sibling context.

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

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

Schema description coverage is 100%, so all three parameters (limit, status, site_id) are already documented with types, constraints, and meaningful descriptions. The tool description does not add parameter-level detail beyond the schema; saying 'for a website' aligns with site_id but does not extend the schema's 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 operation ('List'), the resource ('fix tasks'), and the scope ('for a website'), and adds a specific detail about the included content ('fix and verification instructions'). This makes it immediately distinguishable from siblings like list_issues, get_fix_plan, and update_task_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 the tool is used when you need fix tasks for a site, but it does not explicitly state when to use it instead of related tools such as get_fix_plan or list_issues. There are no exclusions or alternative routing hints, so the agent must infer usage context from the name and resource type.

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 no hints (all false), so the description carries the burden. It adds meaningful behavioral context: payment occurs only after the fix is proven, and it imposes role and subscription requirements. It does not repeat annotation info. It doesn't disclose side effects like whether the task status changes, but that's a minor gap for a purchase action.

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 plus a constraint clause. It front-loads the core action and immediately follows with the payment and access conditions. 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 2-parameter action with full schema coverage and no output schema, the description covers the core purpose, payment model, and access prerequisites. It omits return-value details, but that is not critical for a purchase command. Overall, it is adequately complete for an agent to call it correctly.

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

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

Schema coverage is 100% and both parameters (task_id, note) have descriptions. The tool description adds no additional parameter semantics beyond what the schema already provides. Per the rubric, 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 ('Ask Vibeking to carry out') and the resource ('the fix for a task'), and distinguishes it from siblings like get_fix_catalog (which likely only lists fixes) and update_task_status (which updates status without ordering a fix). The purpose is unambiguous.

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

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

The description provides prerequisites (owners/admins only, active subscription) but does not explicitly state when to use this tool versus alternatives. It implies the tool is for ordering a fix, but it doesn't mention when to use get_fix_catalog to browse fixes first or when to use update_task_status instead. Usage context is present but not fully developed.

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 mark the operation as non-read-only and non-idempotent. The description adds useful behavioral details beyond that: it follows the Scan now path/page limits and returns either a run id or the refusal reason, which meaningfully informs an agent's expectation.

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

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

Two sentences with no filler. The action is stated first, then the return behavior, and the reference to the Scan now button adds practical context 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?

For a single-parameter tool with no output schema, the description adequately covers what the call does and what it returns. The annotations cover the safety profile, and nothing essential for invoking this tool correctly is missing.

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

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

Schema description coverage is 100%: site_id is already documented as a UUID returned by list_sites. The description does not add parameter-specific details, so the 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 opens with a specific verb and resource: 'Start a crawl of a website'. It also gives operational scope ('same path and page limits as the Scan now button'), and this is the only start/scan action among the siblings, so it is clearly distinguished.

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 use case is clear: call this when you need to initiate a standard website crawl. It does not explicitly name alternatives or exclusion conditions, but no sibling provides an equivalent 'start scan' action, so the context is sufficient.

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 convey read-write, idempotent, and non-destructive behavior, so the description does not need to restate those. It adds the 'fix task' scope and allowed statuses, though the enum is already in the schema; no side effects or transition rules are disclosed.

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

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

A single front-loaded sentence states the action, resource, and allowed values with no filler or redundancy. Every word 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 simple two-parameter update with complete schema coverage and annotations covering safety, the description is nearly sufficient. It does not describe the return value or error behavior, but no output schema exists and 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?

Schema description coverage is 100%: both task_id and status are documented in the schema, including the enum and the origin of task_id. The description's parenthetical status list adds no information beyond the schema, so baseline 3 applies.

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

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

The description uses a specific verb ('Update'), names the resource ('status of a fix task'), and enumerates the four allowed statuses. This makes it immediately distinguishable from read-oriented siblings like list_tasks and get_fix_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 clearly implies the tool is for changing a fix task's status, but it does not explicitly state when to prefer it over alternatives or mention any exclusions. The sibling list makes the read/write distinction inferable, but the description leaves it implicit.

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