YubHub MCP Server

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

With no annotations provided, the description carries full burden but only states the basic action. It doesn't disclose behavioral traits like permissions needed, whether creation is idempotent, rate limits, or what happens on success/failure. For a creation tool with zero annotation coverage, this is inadequate.

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 directly states the tool's purpose without any fluff or redundancy. It's appropriately sized 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 creation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what a 'job feed' entails, what monitoring involves, or what the tool returns. Given the complexity implied by sibling tools and lack of structured data, more context 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%, so the schema fully documents all parameters. The description doesn't add any meaning beyond what's in the schema (e.g., it doesn't explain relationships between parameters or usage nuances). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the action ('Create') and resource ('new job feed for monitoring career pages'), providing a specific purpose. However, it doesn't explicitly differentiate from sibling tools like 'update_feed' or 'list_feeds', which would require a 5.

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

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

The description provides no guidance on when to use this tool versus alternatives like 'update_feed' or 'list_feeds', nor does it mention prerequisites or exclusions. It only states what the tool does, not when it's appropriate.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It effectively communicates the destructive nature ('This action cannot be undone') and the cascading effect on associated jobs. It doesn't cover potential error conditions, permissions needed, or rate limits, but provides crucial safety warnings.

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 zero waste: the first states the action and scope, the second provides critical safety warning. Every word earns its place, and the most important information (irreversible deletion) is appropriately emphasized.

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 destructive tool with no annotations and no output schema, the description does well by warning about irreversible consequences and cascading effects. It could be more complete by mentioning error cases (e.g., invalid feedId) or confirming deletion success, but covers the essential behavioral risks adequately.

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 the single parameter 'feedId' clearly documented in the schema. The description doesn't add any parameter-specific information beyond what the schema provides, so it meets the baseline for high schema coverage without compensating value.

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 specific action ('Delete') and resource ('a feed and all associated jobs'), distinguishing it from siblings like delete_jobs (which only deletes jobs) and list_feeds/get_feed (which are read-only). It precisely communicates the tool's destructive scope.

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 about when to use this tool (to delete a feed and its jobs) and implicitly when not to use it (if you want to delete only jobs, use delete_jobs). However, it doesn't explicitly name alternatives or mention prerequisites like feed existence checks, keeping it from a perfect score.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It clearly states this is a destructive operation ('This action cannot be undone'), which is crucial context for a deletion tool. However, it doesn't mention authentication requirements, rate limits, error conditions, or what happens to associated data, leaving some behavioral aspects unspecified.

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 zero waste - the first states the purpose, the second provides critical behavioral warning. The description is appropriately sized and front-loaded with the core functionality, making it highly efficient.

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 destructive operation with no annotations and no output schema, the description does well by warning about irreversibility. However, it doesn't explain what 'jobs' are in this context, what happens after deletion, or whether there are prerequisites (like feed status). Given the complexity of a deletion tool, slightly more context would be beneficial.

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 the single parameter 'feedId' fully documented in the schema. The description adds no additional parameter semantics beyond what's already in the schema (it doesn't explain feedId format, validation rules, or examples). Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Delete') and target resource ('all jobs for a specific feed'), distinguishing it from sibling tools like delete_feed (which deletes the feed itself) or list_jobs (which only lists jobs). The verb+resource combination is precise and 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 clear context about when to use this tool (to delete jobs for a specific feed), but doesn't explicitly mention when NOT to use it or name alternatives like retry_failed_jobs (for selective job management) or delete_feed (for deleting the entire feed). The irreversible warning implies caution but doesn't specify 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?

No annotations are provided, so the description carries the full burden. It discloses the behavioral effect ('The feed will require manual triggering after this'), which is useful context. However, it lacks details on permissions, reversibility (e.g., via 'enable_feed_auto_run'), or error conditions, leaving gaps for a mutation tool.

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

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

The description is two sentences, front-loaded with the core purpose and followed by usage guidance. Every sentence adds value without redundancy, making it efficient and well-structured.

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

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

For a mutation tool with no annotations and no output schema, the description is reasonably complete—it explains the action, outcome, and usage context. However, it could improve by mentioning related tools (e.g., 'enable_feed_auto_run' for reversal) or potential side effects, given the complexity of disabling automation.

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 the single parameter 'feedId' well-documented in the schema. The description adds no additional parameter details beyond what the schema provides, so it meets the baseline for high schema coverage without compensating value.

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 specific action ('Disable automatic runs') and the resource ('for a feed'), distinguishing it from sibling tools like 'enable_feed_auto_run' and 'trigger_feed_run'. It precisely defines the tool's function without being tautological.

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

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

The description explicitly states when to use this tool ('Use this when you want full control over when a feed runs') and implies an alternative (manual triggering via 'trigger_feed_run'). It provides clear context for its application versus other feed management 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?

With no annotations provided, the description carries the full burden. It discloses key behavioral traits: the tool enables automatic scheduling, mentions the scheduler runs hourly, specifies the default interval (7 days), and describes the purpose ('keeping job feeds updated without manual intervention'). However, it doesn't cover potential side effects, error conditions, or what happens if the feed doesn't exist.

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 efficiently structured in two sentences: the first states the core purpose and key behavioral details (scheduler frequency, default interval), and the second provides usage context. Every sentence adds value with zero wasted words, 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?

For a tool with 2 parameters, 100% schema coverage, and no output schema, the description provides adequate context: it explains what the tool does, why to use it, and key behavioral aspects. However, it doesn't mention what the tool returns (success/failure indicators) or error handling, which would be helpful given 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 description coverage is 100%, so the schema already fully documents both parameters. The description adds minimal value beyond the schema: it mentions 'weekly runs' and 'configured interval' which aligns with the schema's 'intervalDays' parameter, but doesn't provide additional semantic context or usage examples. The baseline of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the specific action ('Enable automatic weekly runs') on a specific resource ('for a feed'), distinguishing it from sibling tools like 'disable_feed_auto_run' (opposite action) and 'trigger_feed_run' (manual vs. automatic). The verb 'enable' is precise and the resource 'feed' 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 clear context about when to use this tool ('Great for keeping job feeds updated without manual intervention') and mentions the scheduler's hourly operation and default interval. However, it doesn't explicitly state when NOT to use it or compare it to alternatives like 'trigger_feed_run' for one-time execution.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves aggregated job data but doesn't cover critical aspects like whether it's read-only (implied by 'Get'), rate limits, authentication needs, data freshness, or error handling. For a tool with zero annotation coverage, this leaves significant gaps in understanding its operational 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?

The description is a single, efficient sentence that front-loads the core functionality ('Get job counts by category/sector') and adds necessary detail ('with experience level breakdown (entry, mid, senior)'). There is no wasted verbiage, making it highly concise and well-structured for quick comprehension.

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

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

Given the tool's complexity (aggregating job data with breakdowns), no annotations, and no output schema, the description is minimally adequate. It specifies the data retrieved but lacks details on format, pagination, or error cases. For a read operation with no parameters, it meets basic needs but doesn't fully address potential agent uncertainties about behavior or output structure.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by explaining what data is retrieved ('job counts by category/sector with experience level breakdown'), which clarifies the output semantics beyond the empty schema. This compensates appropriately for the lack of parameters.

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

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

The description clearly states the tool's purpose: 'Get job counts by category/sector with experience level breakdown (entry, mid, senior).' It specifies the verb ('Get'), resource ('job counts'), and granularity ('by category/sector' with 'experience level breakdown'). However, it doesn't explicitly differentiate from siblings like 'get_stats_overview' or 'get_experience_levels', which might overlap in scope, preventing 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 provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or compare it to siblings such as 'get_stats_overview' or 'get_experience_levels', which could offer similar or complementary data. Without this context, the agent must infer usage from the purpose alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states this is a 'Get' operation, implying it's likely read-only, but doesn't confirm this or describe any other behavioral traits like authentication needs, rate limits, or what the return format looks like (e.g., structured data, counts). For a tool with zero annotation coverage, this is a significant gap in 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 extremely concise—a single sentence that directly states the tool's purpose with no wasted words. It's front-loaded with the core action ('Get experience level distribution') and includes helpful examples (entry, mid, senior). Every part of the sentence earns its place by clarifying what 'experience level distribution' means.

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 (0 parameters, no output schema, no annotations), the description is adequate but has clear gaps. It explains what the tool does but doesn't cover behavioral aspects like return format or usage context relative to siblings. For a basic read operation, it meets minimum viability but lacks completeness for optimal agent guidance.

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 0 parameters, and schema description coverage is 100%, so there's no need for parameter documentation in the description. The description appropriately doesn't mention parameters, focusing instead on the tool's purpose. A baseline of 4 is applied for zero-parameter tools, as the description efficiently avoids unnecessary detail.

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: 'Get experience level distribution' with specific categories listed (entry, mid, senior, etc.). It uses a specific verb ('Get') and identifies the resource ('experience level distribution'), making it immediately understandable. However, it doesn't explicitly differentiate this from sibling tools like 'get_categories' or 'get_stats_overview', which prevents 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 provides no guidance on when to use this tool versus alternatives. With sibling tools like 'get_categories' and 'get_stats_overview' that might overlap in data retrieval, there's no indication of when this specific distribution data is needed or what distinguishes it from other get_* tools. This leaves the agent to guess based on tool names alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. While 'Get' implies a read operation, it doesn't specify whether this requires authentication, has rate limits, what format the statistics are returned in, or if it's idempotent. The mention of 'statistics' adds some context but lacks operational details.

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 directly states the tool's purpose without unnecessary words. It's front-loaded with the core action and includes a useful qualifier ('including statistics'), making it appropriately sized and zero 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?

Given the lack of annotations and output schema, the description is incomplete for a tool that retrieves 'detailed information' and 'statistics'. It doesn't explain what the return values include, how statistics are structured, or any error conditions, leaving significant gaps for an AI agent to understand the tool's behavior fully.

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, with 'feedId' clearly documented. The description adds no additional parameter semantics beyond what the schema provides, such as format examples or constraints. With high schema coverage, the baseline score of 3 is appropriate as the description doesn't compensate but doesn't need to.

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 'Get' and resource 'feed' with the qualifier 'detailed information including statistics', which provides a specific purpose. However, it doesn't explicitly distinguish this from sibling tools like 'list_feeds' or 'show_feed_dashboard', which likely serve different purposes.

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

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

The description provides no guidance on when to use this tool versus alternatives. With siblings like 'list_feeds' (likely for listing multiple feeds) and 'show_feed_dashboard' (possibly for visual data), there's no indication of when this detailed retrieval is preferred or what prerequisites might 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?

No annotations are provided, so the description carries full burden. It discloses the tool's read-only nature implicitly ('Get', 'Shows'), but lacks details on permissions, error handling, rate limits, or response format. For a tool with no annotation coverage, this is insufficient behavioral context.

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 core purpose and followed by specific details. Every sentence adds value without redundancy, making it efficient and well-structured.

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

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

Given no annotations, no output schema, and a simple input schema, the description is adequate for a read-only tool but lacks completeness. It covers what the tool returns but not how (e.g., data format), leaving gaps in behavioral context 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 description coverage is 100%, so the schema already documents the 'feedId' parameter. The description does not add meaning beyond what the schema provides (e.g., format examples or constraints). Baseline 3 is appropriate when schema does the heavy lifting.

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

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

The description clearly states the specific action ('Get'), resource ('automatic run schedule configuration for a feed'), and scope ('shows if auto-run is enabled, the run interval, and when the next automatic run is scheduled'). It distinguishes from siblings like 'get_feed' (general feed info) or 'trigger_feed_run' (manual execution).

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 schedule configuration, but does not explicitly state when to use this vs. alternatives like 'get_feed' (which might include schedule info) or 'list_feeds' (for overview). No guidance on prerequisites or exclusions 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action ('get detailed information') without covering critical aspects like read-only nature, error handling (e.g., invalid job IDs), response format, or any rate limits or permissions required, which are essential for safe and effective use.

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, direct sentence with no wasted words. It is appropriately sized and front-loaded, efficiently conveying the core purpose without unnecessary elaboration, making it easy for an agent to parse quickly.

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 lack of annotations and output schema, the description is incomplete. It does not explain what 'detailed information' includes, how results are structured, or potential behavioral traits like idempotency or errors, leaving significant gaps for a tool that retrieves data based on an ID.

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, with 'jobId' clearly documented. The description adds no additional meaning beyond the schema, such as format examples or constraints, but the schema adequately defines the parameter, meeting the baseline for high 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 the tool's purpose as retrieving detailed information about a specific job, which is clear but vague. It specifies the verb ('get') and resource ('job'), but does not differentiate from sibling tools like 'list_jobs' or explain what 'detailed information' entails beyond basic identification.

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 (e.g., needing a job ID), contrast with 'list_jobs' for browsing, or specify use cases like checking job status or details, leaving the agent without contextual direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves statistics but does not describe any behavioral traits, such as whether it's a read-only operation, its performance characteristics, error handling, or data freshness. This is a significant gap for a tool with no 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 a single, efficient sentence that front-loads the core action ('Get high-level statistics') and lists the specific metrics without any wasted words. It is appropriately sized for its purpose and structured for quick comprehension.

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

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

Given the tool's complexity is low (0 parameters, no annotations, no output schema), the description is minimally adequate. It specifies what statistics are retrieved, but it lacks details on the return format, data scope, or any limitations. Without an output schema, the agent must infer the structure from the description alone, which is incomplete for full contextual understanding.

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

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

The tool has 0 parameters, and the input schema has 100% description coverage (though empty). The description does not need to add parameter semantics, as there are none to document. It appropriately focuses on the output metrics, earning a high baseline score for parameter clarity in this context.

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 with a specific verb ('Get') and resource ('high-level statistics'), and it enumerates the three key metrics returned (total enriched jobs, companies, and active feeds). However, it does not explicitly differentiate this tool from sibling tools like 'get_top_companies' or 'get_top_titles', which might also provide statistical data, 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 provides no guidance on when to use this tool versus alternatives. It does not mention any prerequisites, context, or exclusions, such as whether it should be used for dashboard summaries or in contrast to more detailed statistical tools. This leaves the agent without explicit usage instructions.

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

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

With no annotations provided, the description carries full burden but offers minimal behavioral context. It mentions the comparison timeframe but doesn't disclose output format, data freshness, rate limits, authentication needs, or whether results are cached. The description doesn't contradict annotations (none exist), but provides insufficient operational details.

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 perfectly concise with two clear, information-dense sentences. The first states the core purpose, the second adds crucial temporal context. Every word earns its place with zero 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 analytical nature, no parameters, no annotations, and no output schema, the description provides adequate basic purpose but lacks important context about return values, data format, and operational constraints. It's minimally viable but leaves significant gaps for an agent to use it effectively.

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 with 100% schema coverage, so no parameter documentation is needed. The description appropriately focuses on the tool's purpose rather than parameters, earning a baseline score of 4 for zero-parameter tools.

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 specific action ('Get titles gaining or losing demand') and resource ('titles'), with precise temporal scope ('compares the last 2 weeks vs prior 2 weeks'). It distinguishes itself from siblings like 'get_top_titles' by focusing on trend analysis rather than static rankings.

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 analyzing title demand trends over a specific 4-week comparison period, but provides no explicit guidance on when to use this tool versus alternatives like 'get_top_titles' or 'get_stats_overview'. 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It mentions the tool retrieves data ('Get') and specifies metrics like 'enriched job count' and timeframes ('last 7d and 30d'), but it does not cover critical aspects such as whether this is a read-only operation, potential rate limits, authentication needs, or the format of returned data. For a tool with zero annotation coverage, this is a significant gap.

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 core purpose without any wasted words. It directly states what the tool does and includes key details like timeframes, making it highly concise and well-structured.

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

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

Given the tool has 0 parameters and no output schema, the description adequately covers the purpose and output semantics. However, it lacks behavioral details (e.g., read-only nature, data format) and usage guidelines, which are important for a tool in a server with many siblings. This makes it minimally viable but with clear gaps.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description adds value by explaining the semantics of the output—'top companies by enriched job count, with recent activity'—which clarifies what the tool returns beyond the schema. This justifies a score above the baseline of 3 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 clearly states the tool's purpose: 'Get top companies by enriched job count, with recent activity (last 7d and 30d).' It specifies the verb ('Get'), resource ('top companies'), and key metrics ('enriched job count' and 'recent activity'). However, it does not explicitly distinguish this from sibling tools like 'get_categories' or 'get_top_titles', which reduces the score from 5 to 4.

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 exclusions, nor does it reference sibling tools like 'get_stats_overview' or 'get_title_trends' for comparison. This lack of usage context leaves the agent without clear direction.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool retrieves data ('Get'), implying a read-only operation, but does not mention any behavioral traits like rate limits, authentication needs, data freshness, or error handling. This is a significant gap for a tool with no 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 a single, efficient sentence that front-loads the core functionality ('Get the most common job titles by volume') and adds necessary scope ('top 30'). There is zero waste, making it highly concise and well-structured.

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

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

Given the tool has 0 parameters, no annotations, and no output schema, the description provides a clear purpose but lacks details on behavioral aspects and usage context. It is minimally adequate for a simple read operation but does not compensate for the absence of annotations or output schema, leaving gaps in 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?

The input schema has 0 parameters with 100% coverage, so no parameter documentation is needed. The description appropriately does not discuss parameters, and the baseline for 0 parameters is 4, as it avoids unnecessary details while being complete for 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 action ('Get') and resource ('most common job titles by volume'), specifying the scope ('top 30'). However, it does not explicitly differentiate from siblings like 'get_title_trends' or 'get_categories', which might offer related but different data. The purpose is specific but lacks sibling comparison.

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 such as 'get_title_trends' or 'get_categories'. The description implies usage for retrieving top job titles by volume, but it does not specify contexts, prerequisites, or exclusions, leaving the agent to infer based on tool names alone.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It states it 'Get[s]' data, implying a read-only operation, but does not specify if it requires authentication, has rate limits, returns paginated results, or what the output format is. For a tool with zero annotation coverage, this leaves significant gaps in understanding its 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?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is front-loaded and wastes no space, making it easy to parse quickly.

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 (0 parameters, no output schema, no annotations), the description is minimal. It lacks details on behavioral aspects like authentication needs, rate limits, or output structure, which are important for a data retrieval tool. Without annotations or output schema, the description should provide more context to be 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?

The tool has 0 parameters, and schema description coverage is 100%, so no parameter documentation is needed. The description does not add param info, which is appropriate. Baseline is 4 for zero parameters, as there is no schema burden to compensate for.

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 'Get' and the resource 'work arrangement distribution', specifying the types of arrangements (remote, hybrid, onsite, etc.). It distinguishes this from siblings like 'get_categories' or 'get_experience_levels' by focusing on work arrangements, but does not explicitly contrast with all siblings. The purpose is specific and actionable.

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 exclusions, such as whether it requires specific permissions or data availability. With many sibling tools for data retrieval (e.g., 'get_categories', 'get_stats_overview'), the lack of differentiation leaves usage unclear.

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

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

No annotations are provided, so the description carries the full burden. It states 'Get all your job feeds' but lacks details on behavior: e.g., whether it returns a list, pagination, error handling, or authentication needs. This is a significant gap for a tool with no structured safety hints.

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 with zero waste. It's front-loaded and appropriately sized for a simple tool, making it easy to parse without unnecessary elaboration.

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 annotations, no output schema, and a simple tool with 0 parameters, the description is incomplete. It doesn't explain what 'get all' entails (e.g., format, limitations) or behavioral aspects, leaving gaps in understanding how the tool operates in practice.

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 0 parameters with 100% coverage, so no parameter documentation is needed. The description doesn't add param info, which is fine here. A baseline of 4 is appropriate as the schema fully handles the absence of parameters.

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

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

The description 'Get all your job feeds' clearly states the action (get) and resource (job feeds), making the purpose evident. However, it doesn't differentiate from sibling tools like 'get_feed' (singular) or 'show_all_feeds_dashboard', which might offer similar functionality in different contexts, preventing 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 provides no guidance on when to use this tool versus alternatives. With siblings like 'get_feed' (for a specific feed) and 'show_all_feeds_dashboard' (potentially a UI-focused view), there's no indication of context, prerequisites, or exclusions, leaving usage ambiguous.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is a 'Get' operation but doesn't clarify if it's read-only, whether it requires specific permissions, what format the output takes, or if there are pagination/rate limits. For a list operation with zero annotation coverage, this is insufficient.

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 with zero wasted words. It's appropriately sized for a simple list operation and front-loads the core functionality without unnecessary elaboration.

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 good schema coverage but no annotations or output schema, the description is minimally adequate. It states what the tool does but lacks important context about behavioral traits, output format, and differentiation from sibling tools that would help an agent use 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 description coverage is 100%, so the schema fully documents both parameters (feedId and status with enum values). The description adds marginal value by mentioning 'optionally filtered by status' but doesn't provide additional semantic context beyond what's already in the structured 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 'Get' and resource 'jobs for a specific feed', making the purpose understandable. However, it doesn't explicitly differentiate from sibling tools like 'get_job' (singular) or 'list_feeds', which could cause confusion about when to use this specific list operation versus alternatives.

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 minimal guidance with 'optionally filtered by status', but offers no explicit when-to-use rules, no comparison to sibling tools like 'get_job' or 'list_feeds', and no prerequisites or exclusions. This leaves the agent without clear direction on tool selection.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool re-queues jobs based on failure stage, which is useful behavioral context. However, it does not mention permissions needed, rate limits, whether the operation is idempotent, or what happens if no failed jobs exist, leaving gaps for a mutation tool.

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

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

The description is two sentences, front-loaded with the core purpose and efficiently explains the two failure scenarios. Every sentence adds value without redundancy, making it appropriately sized and well-structured.

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

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

Given the tool's complexity (a mutation with no annotations and no output schema), the description is adequate but incomplete. It explains what the tool does but lacks details on return values, error handling, or side effects, which are important for an agent to use it correctly without structured output guidance.

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 the single parameter 'feedId' clearly documented in the schema. The description does not add any parameter-specific details beyond what the schema provides, such as format examples or constraints, so it meets the baseline for high 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 verb ('retry') and resource ('failed jobs for a feed'), specifying that it re-queues jobs based on their failure stage (scraping or enrichment). It distinguishes from siblings like 'delete_jobs' or 'trigger_feed_run' by focusing on retrying only failed jobs rather than deleting, creating, or triggering new runs.

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

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

The description implies usage when jobs have failed, but does not explicitly state when to use this tool versus alternatives like 'delete_jobs' or 'trigger_feed_run'. It provides context about failure types (scraping vs. enrichment) but lacks explicit guidance on prerequisites 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?

No annotations are provided, so the description carries full burden. It mentions UI aspects ('Modern React UI with dark theme') which are behavioral traits, but fails to disclose critical operational details: whether this is a read-only view, if it requires authentication, how data is refreshed, or if it's interactive. For a dashboard tool with zero annotation coverage, this leaves significant behavioral gaps.

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 efficiently structured in two sentences. The first sentence covers the core functionality comprehensively. The second adds UI context that might be relevant for user experience. While slightly verbose with 'Modern React UI with dark theme', this could help agents understand the visual nature of the output.

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 complexity of a dashboard tool with no annotations and no output schema, the description is insufficient. It doesn't explain what 'stats' includes, what columns are sortable, how XML feed links are presented, or what the dashboard output looks like. For a tool that presumably returns rich visual data, more context about the return format and capabilities 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?

The tool has 0 parameters with 100% schema description coverage, so the baseline is 4. The description appropriately doesn't waste space discussing non-existent parameters. It focuses on what the tool does rather than parameter details, which is correct for a parameterless tool.

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: 'Display a comprehensive dashboard showing all feeds with stats, sortable columns, and XML feed links.' It specifies the verb ('display'), resource ('dashboard showing all feeds'), and key features (stats, sortable columns, XML links). However, it doesn't explicitly differentiate from sibling 'show_feed_dashboard' or 'list_feeds', which reduces clarity about when to choose 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?

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this dashboard should be used instead of 'list_feeds' for a simple list or 'show_feed_dashboard' for a single feed view. There's no context about prerequisites, user roles, or typical scenarios for dashboard access.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states this is an 'interactive dashboard' which implies a visual/UI component rather than data return, but doesn't describe what 'interactive' means, whether it opens a browser, requires specific permissions, has rate limits, or what happens after display. For a tool with zero annotation coverage, this leaves significant behavioral gaps.

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 gets straight to the point with no wasted words. It's appropriately sized for a tool with one parameter and clearly front-loaded with the core functionality.

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 moderate complexity (dashboard display with one parameter), no annotations, and no output schema, the description is minimally adequate but incomplete. It identifies what the tool does but lacks crucial context about how it behaves, what 'interactive' entails, and how it differs from the similar 'show_all_feeds_dashboard' sibling tool.

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

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

The input schema has 100% description coverage, with the single parameter 'feedId' clearly documented in the schema. The description doesn't add any parameter semantics beyond what the schema already provides, so the baseline score of 3 is appropriate when the schema does the heavy lifting.

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

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

The description clearly states the tool's purpose with a specific verb ('display') and resource ('interactive dashboard for monitoring a job feed'), distinguishing it from siblings like 'get_feed' or 'list_feeds' that provide data rather than visualizations. However, it doesn't explicitly differentiate from 'show_all_feeds_dashboard', which appears to be a similar dashboard tool.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention when this dashboard is preferable to data-focused tools like 'get_feed' or 'get_stats_overview', nor does it clarify the relationship with 'show_all_feeds_dashboard' (single feed vs. all feeds).

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. 'Start job discovery' implies a potentially long-running or asynchronous operation, but the description doesn't mention execution mode (sync/async), permissions needed, rate limits, whether it's idempotent, or what happens if the feed is already running. For a tool that likely triggers background processing, this is a significant gap.

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 with zero wasted words. It's appropriately sized for a simple tool with one parameter and gets straight to the point without unnecessary elaboration.

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 this is an execution tool with no annotations and no output schema, the description is incomplete. It doesn't explain what 'starting job discovery' entails, what the expected outcome is, whether it returns a job ID or status, or how to monitor progress. For a tool that likely initiates significant processing, more context 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% with the single parameter 'feedId' well-documented in the schema. The description adds no additional parameter semantics beyond what's in the schema. Baseline score of 3 is appropriate when the schema does the heavy lifting, though the description could have added context about feed ID format or sourcing.

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 ('Start job discovery') and target resource ('for a specific feed'), providing a specific verb+resource combination. It distinguishes from siblings like 'get_feed' or 'list_feeds' by focusing on execution rather than retrieval. However, it doesn't explicitly differentiate from similar execution tools like 'retry_failed_jobs' or 'enable_feed_auto_run'.

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 doesn't mention prerequisites (e.g., feed must exist, be enabled), when-not scenarios (e.g., feed already running), or direct alternatives among siblings like 'retry_failed_jobs' or 'enable_feed_auto_run' for related operations.

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

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

No annotations are provided, so the description carries full burden. It mentions updating fields but doesn't disclose behavioral traits such as required permissions, whether updates are reversible, rate limits, or error handling. The tag explanation adds some context, but overall, it's insufficient for a mutation tool with zero 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 two sentences, front-loaded with the core purpose and followed by a specific usage note for tags. It's efficient with zero waste, though it could be slightly more structured by explicitly listing all updatable fields.

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 annotations and no output schema, the description is incomplete for a mutation tool with 5 parameters. It lacks details on behavioral aspects like permissions, side effects, and response format, leaving significant gaps for an AI agent to understand how 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?

Schema description coverage is 100%, so the schema already documents all 5 parameters thoroughly. The description adds minimal value by mentioning 'name, tag, or source URLs' (hinting at careersUrl and exampleJobUrl) and explains tag usage for dashboard filtering, but doesn't provide additional syntax or format details 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 action ('Update') and resource ('a feed's name, tag, or source URLs'), specifying what fields can be modified. It distinguishes from siblings like 'create_feed' (creation) and 'delete_feed' (deletion) by focusing on updates, though it doesn't explicitly contrast with other update-related tools like 'disable_feed_auto_run'.

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 modifying feed attributes, with a specific note on tag usage for dashboard filtering, but lacks explicit guidance on when to choose this over alternatives like 'create_feed' for new feeds or 'get_feed' for viewing. 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.