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 the tool creates a clip, implying a write operation, but doesn't disclose behavioral traits such as permissions needed, whether the operation is idempotent, rate limits, or what happens on failure. This is a significant gap for a creation 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 front-loaded with a clear purpose statement, followed by a structured list of parameters with brief explanations. Every sentence adds value without redundancy, making it efficient and easy to parse.

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

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

Given the tool has an output schema, the description doesn't need to explain return values. However, as a creation tool with no annotations and 5 parameters, it lacks details on behavioral context (e.g., error handling, side effects), making it minimally adequate but incomplete for safe and effective use.

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

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

The description adds meaningful semantics beyond the input schema, which has 0% coverage. It explains that 'show' is a slug from PODHOME_SHOWS, 'episode_id' identifies the episode, 'title' is for the clip, and 'start_time' and 'duration' are in seconds (including fractional values). This compensates well for the lack of schema descriptions.

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

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

The description clearly states the action ('Create a clip') and resource ('from an episode'), specifying it creates a soundbite. However, it doesn't explicitly differentiate from sibling tools like 'create_episode' or 'modify_episode', which are related but distinct operations.

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

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

No guidance is provided on when to use this tool versus alternatives. The description lacks context about prerequisites (e.g., needing an existing episode) or exclusions (e.g., not for modifying clips), leaving the agent to 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?

With no annotations provided, the description carries full burden and does well by disclosing key behavioral traits: it creates a new episode, schedules publishing with a future date, mentions paid features ('enhance_audio'), and specifies requirements between parameters. However, it doesn't cover error conditions, rate limits, or authentication needs.

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 well-structured with a clear purpose statement followed by parameter explanations. It's appropriately sized for 11 parameters, though some redundancy exists (e.g., repeating 'Optional' from schema). Every sentence adds value, but it could be more front-loaded with critical usage 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?

Given the complexity (11 parameters, creation operation) and no annotations, the description does a good job covering purpose, parameters, and some behavioral aspects. With an output schema present, it doesn't need to explain return values. However, it lacks details on error handling, authentication, or side effects that would be helpful for a creation tool.

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

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

Schema description coverage is 73%, so the description adds value by providing context beyond the schema. It clarifies parameter relationships (e.g., 'requires use_podhome_ai=true'), notes that 'description' can contain HTML, and identifies 'enhance_audio' as a paid feature, compensating for the 27% coverage gap in the schema.

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

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

The description clearly states the verb 'create' and resource 'new episode for a specific show', making the purpose explicit. It distinguishes from siblings like 'list_episodes', 'modify_episode', and 'schedule_episode' by focusing on creation rather than listing, modification, or scheduling operations.

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 through parameter explanations (e.g., 'requires use_podhome_ai=true'), but lacks explicit guidance on when to use this tool versus alternatives like 'schedule_episode' or 'modify_episode'. No clear exclusions or prerequisites are stated beyond parameter dependencies.

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 states the tool deletes a webhook, implying a destructive mutation, but lacks critical details: it doesn't specify if deletion is permanent or reversible, what permissions are required, or any side effects (e.g., impact on related data). This leaves significant gaps in understanding the tool's behavior beyond the basic 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 front-loaded with the core purpose ('Delete a webhook.') followed by parameter explanations. It avoids unnecessary elaboration, with each sentence serving a clear function. However, the parameter section could be more integrated into the flow rather than a separate 'Args:' block, slightly affecting structure.

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

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

Given a destructive tool with no annotations, 0% schema coverage, but an output schema (which handles return values), the description is moderately complete. It covers the purpose and parameters adequately but lacks behavioral details like safety warnings or usage context. The output schema reduces the need to explain returns, but more guidance on when and how to use the tool would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds value by explaining 'show' as 'One of the slugs configured in PODHOME_SHOWS' and 'integration_id' as 'The ID of the webhook to delete', providing essential context not in the schema. However, it doesn't detail format constraints (e.g., slug patterns or ID formats), leaving some ambiguity. This partial compensation justifies a baseline score.

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

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

The description clearly states the action ('Delete') and resource ('a webhook'), making the purpose immediately understandable. It distinguishes from siblings like 'register_webhook' and 'test_webhook' by specifying deletion rather than creation or testing. However, it doesn't explicitly differentiate from other destructive operations like 'modify_episode' or 'create_clip' in terms of resource type.

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., needing an existing webhook), exclusions, or comparisons to siblings like 'list_webhooks' for verification. The agent must infer usage from the purpose alone, which is insufficient for optimal 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 of behavioral disclosure. It mentions what data can be included (transcripts, chapters, downloads, people) but doesn't describe the return format, pagination behavior, rate limits, authentication requirements, or whether this is a read-only operation. For a listing tool with 6 parameters, 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 with a clear purpose statement followed by a bullet-point list of parameters. While the parameter list is somewhat redundant with the schema, it's organized and front-loaded. The description avoids unnecessary verbosity, though the parameter section could be more concise given the schema coverage.

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 (6 parameters, no annotations, but with output schema), the description is moderately complete. It covers the basic purpose and parameters but lacks behavioral context and usage guidelines. The presence of an output schema means return values don't need explanation, but other aspects like authentication or error handling 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?

Schema description coverage is high (83%), with most parameters well-documented in the schema itself (e.g., status filter values are explained). The description adds minimal value beyond the schema, merely listing parameter names without additional context. However, the schema does most of the work, justifying a baseline score of 3.

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

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

The description clearly states the tool's purpose: 'List episodes for a specific show.' This is a specific verb ('List') and resource ('episodes'), though it doesn't explicitly differentiate from sibling tools like 'list_shows' or 'modify_episode' beyond the obvious resource difference. The purpose is clear but lacks sibling-specific distinction.

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. There's no mention of prerequisites (e.g., needing a valid show slug), comparison to other listing tools like 'list_shows', or context about when filtering by status or including additional data is appropriate. Usage is implied but not explicitly stated.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It mentions 'all configured' which implies completeness, but lacks details on permissions, rate limits, pagination, or response format. The description is minimal and doesn't compensate for the absence of annotations.

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

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

The description is a single, efficient sentence that directly states the tool's function without any wasted words. It is front-loaded and appropriately sized for a simple tool with no parameters.

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 annotations, but has an output schema), the description is adequate but minimal. It covers the basic purpose but lacks behavioral details that would be helpful for an agent, such as what 'configured' entails or how the output is structured, though the output schema may mitigate this.

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 appropriately doesn't discuss parameters, earning a baseline score of 4 for not adding unnecessary information.

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 ('List') and resource ('configured Podhome show slugs'), making the purpose understandable. However, it doesn't differentiate from sibling tools like 'list_episodes' or 'list_webhooks' beyond the resource type, missing explicit sibling distinction.

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 'list_episodes' or 'list_webhooks', nor does it mention prerequisites or context for usage. It simply states what it does without operational 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?

No annotations are provided, so the description carries full burden. It states the action ('List all registered webhooks') but fails to disclose behavioral traits such as whether this is a read-only operation, if it requires authentication, potential rate limits, or what the output format entails. The description adds minimal context beyond the basic 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 appropriately sized and front-loaded, with the core purpose stated first followed by parameter details. Every sentence earns its place by providing essential information 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 the tool's low complexity (1 parameter) and the presence of an output schema, the description is minimally adequate. It covers the purpose and parameter semantics but lacks behavioral details that annotations would typically provide. The output schema likely handles return values, so the description's gaps in transparency are partially mitigated, but it remains incomplete for a tool with no annotations.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining that 'show' is 'One of the slugs configured in PODHOME_SHOWS', which clarifies the parameter's purpose and format beyond the schema's basic string type. However, with only one parameter documented, the value is limited but sufficient given the low parameter count.

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 resource ('all registered webhooks for a specific show'), making the purpose unambiguous. It distinguishes from siblings like 'delete_webhook' or 'register_webhook' by specifying listing rather than modification. However, it doesn't explicitly differentiate from other list tools like 'list_episodes' or 'list_shows' beyond the resource type.

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 needing to see webhooks for a show, but provides no explicit guidance on when to use this tool versus alternatives like 'test_webhook' or 'register_webhook'. It mentions the 'show' parameter context but lacks prerequisites or exclusions, leaving usage context inferred rather than stated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. While 'modify' implies a mutation operation, the description doesn't address important behavioral aspects: whether this requires specific permissions, if changes are reversible, what happens to existing metadata not mentioned, rate limits, or error conditions. It provides basic parameter information but lacks operational 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 appropriately concise with a clear purpose statement followed by a parameter list. The structure is logical and front-loaded. However, the parameter explanations are somewhat redundant with the schema descriptions, and the formatting as a code block with 'Args:' header is slightly verbose.

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

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

For a mutation tool with 8 parameters and no annotations, the description is minimally adequate. It covers the basic purpose and parameters but lacks important context about permissions, side effects, error handling, and relationship to sibling tools. The existence of an output schema helps, but the description doesn't reference it or explain what successful modification looks like.

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 description lists all 8 parameters with brief explanations, but the input schema already provides good coverage (75%) with detailed descriptions for most parameters. The description adds minimal value beyond what's in the schema - it doesn't explain parameter interactions, constraints beyond what's in schema descriptions, or provide examples. With high schema coverage, the baseline is 3.

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

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

The description clearly states the tool's purpose: 'Modify an episode's metadata.' It specifies the verb ('modify') and resource ('episode's metadata'), making it easy to understand what the tool does. However, it doesn't explicitly differentiate this from sibling tools like 'create_episode' or 'schedule_episode', 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. There's no mention of prerequisites, when-not-to-use scenarios, or comparisons with sibling tools like 'create_episode' or 'schedule_episode'. The agent must infer usage from the tool name 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool registers a webhook but doesn't explain what happens after registration (e.g., whether it's active immediately, how errors are handled, or if authentication is required). For a mutation tool with zero annotation coverage, this leaves significant gaps in understanding its behavior and side effects.

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

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

The description is efficiently structured with a clear purpose statement followed by parameter explanations. Every sentence adds value, and there's no redundant information. It could be slightly more front-loaded by integrating parameter hints into the main description, but overall it's well-organized and concise.

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

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

Given the tool has an output schema (which handles return values), the description focuses on inputs and purpose. However, for a mutation tool with no annotations and 3 parameters, it should provide more context about behavioral outcomes (e.g., what the webhook does, error conditions). The parameter semantics are adequately covered, but overall completeness is moderate due to missing usage and behavioral details.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaningful context for all three parameters: 'show' is linked to 'PODHOME_SHOWS', 'url' is specified as a 'Webhook endpoint URL', and 'action_type' is clarified with enum values 'episode_published' or 'episode_live'. This goes beyond the bare schema to explain what each parameter represents, though it could provide more detail on format constraints.

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 'Register' and resource 'new webhook', making the purpose immediately understandable. It distinguishes from siblings like 'delete_webhook' and 'list_webhooks' by specifying creation rather than removal or listing. However, it doesn't explicitly differentiate from 'test_webhook' which might have overlapping concepts.

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

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

No guidance is provided on when to use this tool versus alternatives like 'test_webhook' or 'delete_webhook'. The description lacks context about prerequisites (e.g., needing a valid show slug) or typical use cases (e.g., setting up notifications). It simply lists parameters without explaining the tool's role in the workflow.

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 insight. It mentions 'schedule or publish' implying a write operation, but doesn't disclose permissions needed, whether changes are reversible, rate limits, or what happens on success/failure. The description is too vague 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 appropriately sized and front-loaded with the core purpose. The parameter list is organized but could be more integrated. Every sentence earns its place, though the structure is slightly fragmented between the summary and args section.

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

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

Given a mutation tool with 4 parameters, no annotations, but an output schema exists, the description is minimally adequate. It covers the basic action and parameters but lacks critical context like permissions, side effects, and error handling. The output schema reduces need for return value details, but behavioral gaps remain significant.

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

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

Schema description coverage is 50% (2 of 4 parameters have descriptions). The description compensates by listing all 4 parameters with brief explanations, adding value beyond the schema. It clarifies 'show' uses 'slugs configured in PODHOME_SHOWS' and explains the publish_now/publish_date relationship, though more detail on formats/constraints would help.

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 specific verbs ('schedule or publish') and resource ('an episode'). It distinguishes from siblings like 'create_episode' and 'modify_episode' by focusing on scheduling/publishing rather than creation or modification. However, it doesn't explicitly differentiate from all siblings (e.g., 'list_episodes'), keeping it at 4 instead of 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. It doesn't mention prerequisites (e.g., episode must exist), when to choose scheduling vs. immediate publishing, or how it relates to siblings like 'modify_episode' for episode changes. This lack of context 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 mentions that the webhook is called with episode data, implying a read operation, but lacks details on permissions, rate limits, side effects (e.g., whether this triggers actual notifications), or response behavior. For a testing tool with zero annotation coverage, this is a significant gap in behavioral disclosure.

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

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

The description is appropriately sized and front-loaded: the first sentence states the purpose clearly, followed by a structured 'Args:' section for parameters. There's no wasted text, but it could be slightly more concise by integrating the parameter explanations into a single paragraph without sacrificing clarity.

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 2 parameters with 0% schema coverage and an output schema present, the description provides basic purpose and parameter semantics but lacks behavioral context (e.g., side effects, error handling). The output schema likely covers return values, reducing the burden, but for a testing tool with no annotations, more detail on what 'testing' entails would improve completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning by explaining 'show' as 'One of the slugs configured in PODHOME_SHOWS' and 'integration_id' as 'Optional specific webhook ID to test', which clarifies their roles beyond the bare schema. However, it doesn't detail format constraints (e.g., slug patterns) or what happens if 'integration_id' is omitted, leaving some ambiguity.

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: 'Test webhooks' with the specific action of calling a webhook with data from the latest published or live episode. It distinguishes from siblings like 'register_webhook' or 'delete_webhook' by focusing on testing rather than management operations. However, it doesn't explicitly contrast with all siblings (e.g., 'list_webhooks').

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: it mentions testing webhooks with episode data but offers no explicit when-to-use advice, prerequisites, or alternatives. For example, it doesn't clarify when to use this versus 'list_webhooks' or 'register_webhook', or if testing is needed before deployment. This leaves usage context largely implied.

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