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

No annotations are provided, so the description must disclose behavioral traits. It only says 'manually add' with no mention of idempotency, duplicate handling, required permissions, or side effects on existing models. This is insufficient for a mutation tool, leaving the agent guessing about edge cases.

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

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

The description is a single, compact sentence that conveys the essential purpose and usage condition. Every word adds value, with no redundant information or filler.

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

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

For a simple tool with only two string parameters and an output schema, the description covers the core purpose and trigger condition. It does not address potential failure modes (e.g., provider not found, duplicate model name), but the low complexity and presence of output schema make this acceptable. One more sentence about duplicates or validation would push it to 5.

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

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

The schema has 2 parameters (model_name, provider_id) with 0% description coverage. The description references both concepts in the sentence, giving the agent a clue about their roles, but it does not explicitly map parameter names to meanings, nor does it highlight that both are required. This partial compensation earns a 3, not lower.

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: manually add a model name as an available model for a provider. It specifies the resource (model) and the target (provider), and the parenthetical explains the exact scenario when this is needed, distinguishing it from sibling tools like list_models or add_provider.

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 the tool: when the provider's /v1/models API is unavailable. This implies the normal path is automatic discovery via that API, and this tool is the manual fallback. It clearly differentiates use cases without needing to list alternatives.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not mention side effects (e.g., whether an existing provider is overwritten), permission requirements, error handling, or reversibility. The only behavioral hint is the suggestion to list models after adding, which is mild context but insufficient 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 concise sentences, front-loaded with the purpose. It includes actionable follow-up steps without unnecessary fluff. Every sentence earns its place, 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?

The description covers the core action and next steps, but it lacks parameter semantics and any mention of error conditions, idempotency, or prerequisites. The presence of an output schema helps, but without annotations and with 0% schema coverage, the description remains incomplete for a tool with four required parameters.

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

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

The schema has zero descriptions, and the description only explains the 'type' parameter with example values. The other three parameters (name, api_key, base_url) are left entirely to their names, with no added meaning. With 0% schema coverage, the description should compensate but only covers one of four parameters, leaving the rest under-specified.

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 ('Add a new LLM provider') with a specific verb and resource. It also provides example type values (openai/deepseek/qwen/groq/custom), which helps distinguish this add operation from sibling tools like update_provider. The purpose is unambiguous and action-oriented.

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

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

Provides explicit post-add guidance: call list_models to confirm availability or use add_model to manually add model names. This gives clear context on how to use the tool and what to do next. However, it does not explicitly state when not to use this tool (e.g., for updating existing providers) or name alternatives, so it loses one point.

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, the description carries the burden of behavioral disclosure. It reveals that cancellation is cooperative and non-immediate, checking at each chunk during LLM summarization. It also provides the return structure. It does not mention side effects on partial outputs or idempotency, but the core behavior is transparent.

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: the first states purpose and key behavioral nuance, the second lists the response shape. No redundant words, front-loaded and 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 simple cancellation tool with one parameter and an output schema described, the description covers purpose, behavior, and response. It lacks details on error cases or whether partial results are cleaned, but these are not critical for basic usage. Overall, it is sufficiently 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 schema has only task_id with no description coverage. The description implies that task_id identifies the note generation task and includes it in the return, but does not add explicit details on how to obtain it or its format. Baseline 3 is appropriate given a single parameter and clear context from the tool name.

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

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

Description explicitly states 'cancel an ongoing/queued note generation task' with a specific verb and resource. This clearly distinguishes it from sibling tools like get_task_status (status check) and cleanup_note (file cleanup).

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

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

The description gives the context that cancellation is for ongoing/queued tasks and notes the cooperative timing ('takes effect at the next stage boundary'). However, it does not explicitly mention when not to use it or suggest alternatives (e.g., cleanup_note for already-completed tasks), leaving usage guidance implicit.

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

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

With no annotations provided, the description carries full responsibility and does exceptionally well. It explicitly lists what gets cleared (three directories), what is preserved by default (config/ and models/), what happens when flags are true, that the database is untouched, and that the tool returns per-directory statistics and retained items. This fully discloses the destructive impact.

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

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

The description is concise and well-structured: an opening declarative sentence followed by two bullet points for the parameters, plus a final note on database behavior and return value. Every sentence contributes necessary information with no fluff.

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

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

For a destructive tool with no annotations and two parameters, the description is complete. It covers side effects, default safe behavior, optional destructive extensions, exclusion of the database, and the return format. The 'factory reset' analogy provides helpful mental context, and the output schema is provided separately.

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 does so thoroughly: include_config and include_models are each explained with their defaults, effects, and rationale (e.g., models are expensive to re-download). This adds meaning far beyond the bare boolean schema.

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

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

The description clearly states the tool's purpose: '全局清理（类似恢复出厂）' (global cleanup, similar to factory reset) and lists the exact resources it affects (note_results / static/screenshots / logs). This distinguishes it from the sibling tool cleanup_note, which is per-note, by emphasizing global 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 for when to use this tool: it's a global cleanup affecting all task artifacts. It explains default behavior (preserving config and models) and conditions for extending cleanup via include_config and include_models. However, it does not explicitly mention alternatives like cleanup_note or state 'do not use for per-note cleanup,' so it falls short of a perfect 5.

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

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

With no annotations, the description fully carries the behavioral disclosure burden. It explains destructive behavior (deleting intermediate files, optionally deleting final note and manifest), safety mechanisms (only deletes manifest-recorded files and validates paths to prevent traversal), and the return structure. This is comprehensive for a deletion 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 concise and well-structured: a purpose statement, parameter behavior, safety note, and return value. Each sentence contributes useful information without redundancy, 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?

The description covers purpose, parameters, safety, and return value comprehensively for a tool of this complexity. Minor gaps exist, such as not specifying whether the task must be completed before cleanup or explicitly describing the task_id format, but the return field 'missing' implies handling for absent files.

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

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

The schema has 0% description coverage, but the description compensates by explaining include_note's semantics in detail (False keeps final note, True deletes it along with manifest). task_id is implied as the task identifier but not explicitly defined; overall, the description adds substantial meaning beyond the bare schema.

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

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

The description clearly states the tool's function: cleaning up intermediate artifacts (downloaded media, transcripts, screenshots, temp files, dl directory) generated by a specific task. It distinguishes from sibling cleanup_all by targeting a single task, and from get_task_files by being a deletion operation.

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

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

The description implies the tool is used for per-task cleanup but does not explicitly state when to use it versus alternatives like cleanup_all or get_task_files. It provides contextual guidance on the include_note parameter but lacks explicit when-not or alternative tool references.

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 that the download runs in the background and directs users to list_transcriber_models for progress/status, which is valuable. Yet it does not mention behavior on repeated downloads, error handling, or any resource requirements, leaving some transparency 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 two concise sentences, each serving a clear purpose: stating what the tool does and where to check results. No unnecessary words or repetition.

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

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

The description covers the key context: when to use (local engine), the background execution, and how to query status. An output schema exists, so return values are not needed. However, the lack of parameter details makes the overall picture incomplete for correct invocation, especially given the tool has a required parameter.

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 no descriptions and the description does not explain model_size or transcriber_type. The only hint is the tool name and the mention of 'whisper model', but the required parameter and its allowed values are undefined. With 0% schema coverage, the description fails to compensate, giving the agent insufficient information to choose parameter values correctly.

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 (download) and resource (whisper model), and notes it runs in the background and is only needed for the local engine. This distinguishes it from sibling tools like list_transcriber_models and list_models by specifying its unique role.

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 says '仅本地引擎需要' (only for local engine), giving clear context for when to use it. It also refers to list_transcriber_models for querying status, which implies this tool is for initiating downloads rather than monitoring them. However, it does not explicitly state when not to use it or mention alternative tools for remote models.

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 adds useful context by stating it does NOT generate notes ('不生成笔记') and by outlining the return structure (including an error field). However, it does not explicitly disclose read-only behavior, authentication requirements, rate limits, or how errors are surfaced beyond the error field. It is moderately transparent but leaves 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?

The description is concise: three sentences that front-load the main purpose, followed by the return format and usage guidance. Every sentence provides value, with no filler. The structure aids 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?

Despite lacking parameter semantics, the description gives a strong sense of the tool's role within the ecosystem (preview for notes, alternative to danmaku, injectable into prompts) and includes the return format. Since an output schema exists, the return values are covered elsewhere. The tool has only 2 parameters, and the description is reasonably complete for its complexity, though it could be rounder with explicit parameter explanations.

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%, and the description does not explain the parameters. It references video indirectly ('视频' in the first sentence) but does not clarify the 'limit' parameter or its default behavior. The description adds little beyond what the schema already shows, failing to compensate for the lack of parameter descriptions.

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

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

The description clearly states the tool's purpose: '抓取 B 站视频的热门评论' (fetch hot comments from Bilibili videos). It specifies the resource (B站视频), the action (抓取/fetch), and the scope (热门评论/hot comments). It also distinguishes itself from sibling tools by explicitly saying it does not generate notes, and references fetch_danmaku and generate_note as 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 explicitly mentions the intended use case: '供生成笔记前预览/参考' (for preview/reference before generating notes). It also points to alternatives: '可用 fetch_danmaku 看弹幕汇总' (use fetch_danmaku for danmaku summaries) and 'generate_note 的 include_comments' for injecting both into note prompts. This provides clear when-to-use and when-to-use-other tools guidance.

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

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

No annotations exist, so the description carries the burden. It discloses the 'does not generate notes' boundary and the return structure, adding meaning beyond just 'fetch'. However, it lacks details on prerequisites like valid URL format or cookie requirements, though these may be less critical for a simple fetch.

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

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

Three concise sentences front-load the main purpose and efficiently cover usage, return format, and sibling relationships. Every sentence earns its place without redundancy.

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

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

For a simple single-parameter tool with an output schema, the description is fairly complete: it states purpose, usage, alternatives, and non-side-effects. It could mention URL validation or error behavior, but the output schema likely covers return details, and the tool is straightforward.

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

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

The schema has 1 parameter (video_url) with 0% description coverage. The tool description does not explicitly explain the parameter format or constraints, only implying it's a Bilibili video URL. The param name is self-explanatory but the description adds little beyond what the name suggests.

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

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

The description clearly states the tool fetches Bilibili video danmaku summaries, with a specific verb and resource. It also differentiates from siblings by noting it doesn't generate notes and positioning itself as a preview/reference step.

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

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

Explicitly says when to use (before generating notes for preview/reference) and provides alternatives: fetch_comments for hot comments, and generate_note's include_comments to combine both. This is clear contextual guidance.

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

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

With no annotations, the description fully discloses the tool's behavior: async processing, return format ({task_id, status, platform}), file output (portable notes with Assets/ folder), default fallback chains (e.g., notes_dir from env var), and scope-specific behaviors (e.g., comments only for Bilibili). It also explains overrides like 'explicitly passed always overrides defaults'.

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 lengthy but efficiently structured with a one-sentence purpose, a bulleted parameter list, and a follow-up workflow note. Each bullet covers a distinct parameter or behavior without redundancy. The front-loaded summary ensures immediate grasp of the tool's core function.

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

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

Given the complexity (16 parameters, no annotations, async behavior), the description is remarkably complete. It covers return values, asynchronous polling, alternative tools, parameter semantics, defaults, and environment variable fallbacks. An output schema exists, but the description provides all necessary context not inferable from the structured fields.

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

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

Schema has 0% description coverage, so the description carries full parameter documentation. Every parameter is explained with its role, allowed values (e.g., style enum list, format array examples), defaults, and dependencies (e.g., provider_id requiring list_providers/add_provider). This far exceeds the minimal schema 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 opens with a clear statement: '提交一个视频链接/本地文件，异步生成 AI Markdown 笔记' (submit a video link/local file, asynchronously generate AI Markdown notes). This specifies the verb (generate), resource (AI Markdown notes from video), and async nature, clearly distinguishing it from the sibling tool prepare_note_material.

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 mentions the alternative tool: '只需素材（转写/帧/评论，不调 LLM 总结）供自行写笔记时，用 prepare_note_material' (if you only need raw materials without LLM summarization, use prepare_note_material). It also outlines the full async workflow, including using get_task_status / wait_for_note to query results, providing clear when-to-use guidance.

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

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

No annotations are provided, so the description carries the full burden. It discloses the scan method (manifest records + prefix scan), clarifies that 'existing' is the list of actually existing files/directories (implying some recorded paths may not exist), and uses verbs like 'list' and 'view' to imply a read-only operation. This goes beyond a simple tool name.

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

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

The description is three sentences long: purpose/method, return structure, and usage context. Every sentence adds value, no redundancy, and the structure is logical 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?

Despite having an output schema, the description voluntarily explains the return object {task_id, manifest_paths, existing} and its meaning. Combined with the purpose, method, and pre-cleanup use case, it is fully complete for a simple list 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?

With 0% schema description coverage, the description compensates by explaining that task_id is used as a prefix scan pattern and appears in the return object. This gives the parameter practical meaning, though it doesn't specify format or validation rules. For a simple task_id parameter, that is sufficient.

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

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

The description clearly states the tool's function: listing files/directories generated by a task on disk, using manifest records and a {task_id}* prefix scan. This specific verb+resource combination distinguishes it from sibling tools like cleanup_note or get_task_status, which have 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 explicitly says to use it before cleanup to see which storage a task occupies, providing clear contextual guidance. It doesn't explicitly mention when not to use it or alternatives, but the pre-cleanup use case is a clear directive.

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, the description carries the full burden. It adds useful context by stating that on SUCCESS, result contains markdown/transcript/audio_meta. However, it does not disclose behavior on failure, whether the tool is strictly read-only, or how invalid task IDs are handled.

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 consists of two short sentences, front-loading the core purpose ('查询笔记生成任务进度') followed by a succinct result detail. There is no redundant filler.

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

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

With an output schema present, the description does not need to enumerate return fields, but it adds a helpful note about SUCCESS. It lacks error-handling context, yet for a single-parameter read-only status query, the description is largely 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 only parameter, task_id, has no schema description (coverage 0%). The description does not explain where task_id comes from or how to obtain it, only implying a connection to note generation. This is a significant gap for an agent trying to invoke the tool correctly.

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

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

The description clearly states the tool's function: '查询笔记生成任务进度' (query note generation task progress). It also specifies what the result contains on SUCCESS, distinguishing it from sibling tools like wait_for_note and generate_note.

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 task progress via '查询进度', but it does not explicitly contrast with alternatives like wait_for_note. There is no clear when-to-use vs when-not-to-use guidance, leaving the agent to infer the polling pattern.

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?

Without annotations, the description carries the full burden of behavioral disclosure. The verb '查看' (view) implies a read-only operation, and it mentions checking model readiness, but it does not explicitly state that no configuration is modified, nor does it describe network dependencies or output format. The description adds some transparency by indicating the scope (current config and readiness) but lacks explicit side-effect information.

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

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

The description is a single, tightly packed sentence that conveys the essential function and the set of transcribing engines covered. It is front-loaded with the main action ('查看') and avoids any unnecessary details, making it highly concise 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's simplicity (no parameters, no nested objects) and the presence of an output schema, the description is nearly complete. It sufficiently describes the resource (transcriber config) and the additional aspect of model readiness. It does not explain return values, but the output schema fulfills that role, so the description meets the contextual needs for a simple getter.

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?

This tool has zero parameters, making parameter semantics non-applicable. The description correctly focuses on the tool's purpose without needing to explain parameter details. The baseline for 0 parameters is 4, and the description meets that baseline by being clear and not requiring parameter compensation.

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

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

The description clearly states the tool's function: viewing the current transcriber engine configuration and model readiness status. It names specific engines (fast-whisper, groq, bcut, kuaishou, mlx-whisper) and distinguishes itself from siblings like get_task_status and list_providers by focusing on current configuration rather than tasks or provider lists.

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 a read-only operational context but does not explicitly state when to use this tool versus alternatives like set_transcriber or list_transcriber_models. No exclusions or alternative naming are provided, leaving usage to be inferred from the tool's nature rather than being explicitly guided.

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, the description carries the full burden of disclosing behavior. It states that it checks readiness but does not mention whether the operation is read-only, what output to expect, or whether any side effects occur. This lack of detail leaves important behavioral traits undisclosed.

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

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

The description is a single, compact sentence that front-loads the action and lists all checked components. It is concise and devoid of superfluous information.

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

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

For a checklist-style health tool with an output schema, the description covers the scope of the check and is complete enough. It could mention whether it performs remote calls or just local checks, but given the output schema exists, this is a minor gap.

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

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

The tool has zero parameters, so there is no parameter meaning to convey. The baseline for zero-parameter tools is 4, and the description appropriately focuses on the tool's purpose without needing param details.

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

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

The description uses the specific verb '检查' (check) and explicitly enumerates the resources being checked: FFmpeg, database, transcriber configuration, and local whisper model. This clearly defines the tool's purpose and distinguishes it from sibling tools that target individual resources like get_transcriber_config or list_models.

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 a general health-check use case (checking environment readiness) but provides no explicit guidance on when to use this tool versus more specific sibling tools. The context suggests it is a first-line diagnostic, but this is not stated.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It transparently explains the priority order: first try the provider's /v1/models endpoint, then fall back to local database models. This is valuable context beyond the simple 'list' operation. It does not mention side effects (none expected) or error handling, but the fallback logic is a key behavioral trait well disclosed.

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

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

The description is two sentences long, front-loaded with the primary purpose, followed by a concise behavioral note. Every word earns its place; no fluff or repetition.

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

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

Given the tool has only one parameter and an output schema (present but not shown), the description covers the main behavior and the fallback logic. It does not mention error cases or return format, but the output schema likely covers those. For a low-complexity list tool, this is reasonably complete.

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

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

Schema description coverage is 0%, so the description must compensate. It references the provider's /v1/models endpoint, implying provider_id identifies a specific provider with that endpoint. However, it does not explicitly explain the provider_id format or that it should come from a known provider list. The parameter name itself is self-explanatory, but the description adds only marginal semantics beyond the schema.

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

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

The description clearly states the tool lists models available for a given LLM provider, using the specific verb '列出' (list) and resource '某 LLM 供应商可用的模型'. It distinguishes itself from sibling tools like list_providers (which lists providers) and add_model (which adds models).

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: use this tool to retrieve models for a provider. It does not explicitly name alternatives, but the fallback behavior (real-time API vs. local DB) gives the agent an understanding of what to expect. No exclusions are stated, but the use case is clear from the description and sibling tool names.

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 'api_key mask', which is a useful transparency detail, but omits any explicit read-only statement, authentication requirements, or side effects. The verb 'list' implies non-mutating, but lacks deeper 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?

One concise sentence, front-loaded with the action 'List' and immediately clarifies the resource and relevant fields. No superfluous content.

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

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

For a simple list operation with 0 parameters and an output schema present, the description sufficiently covers what the tool does and the key attribute of the returned data (api_key mask). Missing explicit behavioral disclaimers, but overall adequate.

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

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

The tool has zero parameters, so the description has no parameter semantics to add. Baseline for 0 params is 4; the description is appropriately minimal.

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

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

Description states 'List configured LLM providers' with fields, clearly distinguishing from sibling tools like add_provider, update_provider, and list_models. The verb 'list' is specific and the resource is explicit.

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?

Description implies usage for viewing providers but does not explicitly compare with alternatives like list_models or mention when not to use it. No exclusions or alternative tool references.

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 burden. 'List' implies a read-only operation, and 'local' suggests it inspects local state, but it doesn't explicitly state side effects, return behavior, or whether any configuration is required. This is adequate for a simple query, but lacks depth.

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

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

The description is a single, front-loaded sentence that conveys the essential purpose without waste. It's 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 low complexity, empty input schema, and presence of an output schema, the description is reasonably complete. It covers what the tool does, and the output schema likely documents the return format. However, it could mention how this differs from 'list_models' to fully contextualize usage.

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

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

The tool has zero parameters, so the schema is trivially complete. The description doesn't need to explain parameters, and there's no ambiguity. Baseline for 0 params is 4.

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

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

The description clearly states the tool lists the download status of local whisper models (fast-whisper). The verb 'list' is specific, the resource is well-defined, and it distinguishes itself from sibling tools like 'list_models' by focusing on transcriber models and their download status.

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

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

The description provides no guidance on when to use this tool versus alternatives. It doesn't mention prerequisites, exclusions, or scenarios (e.g., checking before download). Without this, 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 disclosure burden. It discloses the async behavior (returns PENDING), the optional frame extraction with file:// paths, platform-specific behavior (Bilibili-only comments), and default off for frame extraction. It also clearly states no LLM is invoked. It lacks details on error states or rate limits, but for this tool the coverage is substantially above average.

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 relatively long but well-structured with bullet points that map to parameters. Every sentence provides useful information, including intended usage, defaults, and result format. It is not overly verbose despite covering many optional parameters, though it could be slightly more concise by omitting the result fields since an output schema exists.

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?

Even with an output schema present, the description details the return shape ({task_id, status: PENDING} and SUCCESS result fields) which is helpful for understanding the async flow. It also mentions the follow-up tools, making the workflow clear. Minor gaps: no mention of failure/error responses, but overall context is sufficient for an agent to 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?

Despite 0% schema description coverage, the description manually explains every parameter: video_url (required), platform (auto-detect), video_understanding/video_interval/grid_size (frame extraction semantics with defaults), and include_comments/comments_limit (Bilibili-only, default 20). It adds meaning to defaults and conditions, fully compensating for the schema lacking descriptions.

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

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

The description clearly states the tool's function: it submits a video link/local file and asynchronously produces a material package (transcript, frames, comments, paths). It distinguishes itself from generate_note by explicitly noting it does NOT call LLM and is for AGENT to read material. This makes the purpose unambiguous and differentiates it from sibling tools.

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

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

The description explicitly says '需要 AI 生成结构化 Markdown 笔记请用 generate_note' (use generate_note for AI-generated notes), clearly directing to the alternative. It also instructs to use get_task_status / wait_for_note for querying results, and mentions that no LLM provider/model configuration is needed. This provides strong when-to-use and follow-up guidance.

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

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

No annotations are provided, so the description carries the full burden. It indicates that the cookie is used for authenticated downloads, but does not disclose whether the cookie is persisted, whether it overrides existing cookies, or any security implications. This is a mutation tool and the lack of side-effect details prevents a higher score.

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

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

The description is a single, compact sentence that delivers the essential information immediately: what is set, for which platform type, and why. There is no redundancy or irrelevant detail.

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

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

This is a simple tool with two required parameters and an output schema exists. The description explains the goal and the general purpose adequately for an agent to understand its function in the broader download workflow. It does not need to elaborate on return values or complex behavior, making it sufficiently complete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions 'platform' indirectly through the example 'bilibili' and 'cookie' through 'SESSDATA', which adds some meaning beyond the schema's bare titles. However, it does not formally define both parameters or enumerate allowed platform values, leaving room for 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 action ('设置' - set), the resource ('平台下载 Cookie' - platform download cookie), and the purpose ('用于下载需登录/会员的内容' - to download content requiring login/membership). This specific verb+resource combination distinguishes it from sibling tools like set_transcriber or add_provider.

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

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

The description implies when to use this tool: when downloading content that requires login or membership authentication. It provides a concrete use case example (bilibili's SESSDATA). However, it does not explicitly state alternatives or when not to use, so it falls short of a 5.

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

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

With no annotations, the description carries burden for behavior disclosure. It discloses that fast-whisper requires a model download and that whisper_model_size only applies to that engine. However, it does not state whether the switch persists across sessions, affects ongoing tasks, or requires prior model installation for other engines. These gaps leave some behavioral ambiguity.

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

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

The description is two sentences, front-loaded with the primary action, and each sentence adds distinct value: the first defines the tool and its options, the second clarifies a conditional parameter. No redundancy or filler.

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

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

For a simple setter tool with two parameters and a straightforward purpose, the description covers the main function, the valid values, and the conditional behavior of the optional parameter. The output schema exists and need not be explained. The sibling context further clarifies this tool's place in the workflow.

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

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

Schema coverage is 0%, but the description compensates by enumerating valid values for transcriber_type and explaining that whisper_model_size is optional and only relevant when switching to fast-whisper, with a list of model sizes. This adds meaningful guidance beyond the bare string fields 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 starts with a clear verb '切换转写引擎' (switch transcription engine), specifying the exact resource being modified. It lists distinct engine options (fast-whisper, groq, bcut, kuaishou, mlx-whisper), differentiating it from sibling tools like get_transcriber_config or download_transcriber_model, which query or download rather than switch.

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 context on when to use this tool: whenever switching between transcription engines. It further clarifies that switching to fast-whisper may require prior model download and that whisper_model_size is available only in that case. It does not explicitly mention alternatives or exclusions, but the sibling set makes the intended use unambiguous.

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

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

No annotations are present, so the description carries the full burden. It adds useful context about security (api_key should prefer out-of-band) and confirms non-sensitive fields are unrestricted. However, it does not disclose behavioral details such as whether updates are partial or full, what happens on invalid provider_id, or any immediate effect of changes.

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

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

The description is a tight two-sentence structure: first states the core purpose with example fields, second provides crucial security guidance. No wasted words, and the most important operational detail (api_key alternative) is front-loaded in the second sentence.

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

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

For a simple update tool with an output schema, the description adequately covers key operational context: purpose, sensitive-field handling, and restrictions. Minor gaps remain (e.g., no mention that all parameters except provider_id are optional nullable, though this is visible in the schema), but overall it is sufficiently complete.

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

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

Schema description coverage is 0%, so the description must compensate. It mentions base_url, name, enabled, and api_key, adding meaningful context (sensitive vs non-sensitive). However, provider_id (the required parameter) is not explained, and no per-parameter format or valid value constraints are given beyond what the schema shows.

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 updates LLM provider configuration, listing specific non-sensitive fields (base_url, name, enabled). It uses a specific verb (更新) with a resource (LLM 供应商配置), and is easily distinguished from siblings like add_provider and list_providers.

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

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

Provides explicit guidance on when to avoid using this tool for api_key, recommending an alternative out-of-band command (`bilinote-mcp providers set`). It also clarifies the condition under which using this tool for api_key is acceptable, giving clear usage boundaries.

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 supported platforms and local file paths, which is useful context. However, it does not mention the return format, what happens for unsupported URLs, or any validation side effects. The output schema likely covers return values, but more behavioral detail (e.g., 'this is a read-only check') would improve clarity.

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

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

The description is concise, with exactly two sentences: first stating the purpose, second listing supported inputs. It is front-loaded and every word earns its place with no filler or redundant information.

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

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

For a simple single-parameter validation tool with an output schema, the description is largely complete: it states the purpose, enumerates supported platforms, and notes local paths. It does not explain what the output will look like, but the output schema can handle that. It could mention error/unsupported behavior, but that is a minor gap given the tool's simplicity.

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

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

The schema contains only a bare 'url' field with no description (0% schema coverage). The description compensates by clarifying that the parameter accepts URLs from the listed platforms plus local file paths, implying the accepted format. It adds significant meaning beyond the schema, though it could be more explicit about expected URL formats (e.g., with or without protocol).

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

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

The description explicitly states the tool determines the platform and support status of a video link, and lists all supported platforms (bilibili, youtube, douyin, tiktok, kuaishou, local file paths). This is a specific verb+resource with clear scope and distinguishes it from all sibling tools, which focus on tasks, providers, and transcriber models.

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

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

Usage is implied: any video URL can be passed to check its platform and support. The description does not explicitly say when to use this tool versus alternatives, but sibling tools have no overlap, so no exclusions are necessary. The lack of explicit scenario guidance (e.g., 'use before downloading') makes it adequate but not proactive.

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 behavioral disclosure burden. It reveals that the tool blocks, has a timeout, can be resumed with repeated calls, and returns the same structure as get_task_status with final Markdown in the result on SUCCESS.

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

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

The description is concise and front-loaded: the first sentence states the core purpose, the second adds usage nuance and return value. Every sentence adds value with no fluff.

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

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

The description covers the essential behavior, return structure, and a specific usage scenario (long videos). Minor gaps exist: 'poll_interval' is not explained, and timeout/error handling details are only partially specified.

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%, and the description only indirectly explains the 'timeout' parameter via the long-video remark. 'task_id' is inferable from context but never explicitly defined, and 'poll_interval' is entirely undocumented, including units or purpose.

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

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

The description clearly states the tool's action: blocking/polling a note generation task until completion or timeout. It distinguishes itself from the sibling get_task_status by emphasizing the blocking behavior and the ability to call multiple times for long videos.

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

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

It provides clear usage context: for long videos, the task may exceed timeout, so the tool can be called repeatedly to continue waiting. It doesn't explicitly mention when not to use it or name alternatives, but the blocking vs. non-blocking distinction is implied.

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