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

With no annotations, the description carries the burden well: it discloses idempotency ('Appending a video the skill already lists is refused... re-running a pipeline is safe'), the required body shape, the auto-generated artifacts (frontmatter, provenance table, WORKFLOW.md), and that create/replace without a 'What would change this skill' section is refused. It does not say what happens to the existing body on `replace` or what permissions/paths are needed, so a 4 rather than 5.

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?

Front-loaded with the action, then responsibilities, then mode selection, then hard refusals. Slightly long with a trailing paragraph on refusal rules, but every sentence carries operative information; no 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?

Output schema exists, so return values need no explanation, and the description covers delegation of reading transcripts/frames, generated artifacts, and refusal conditions. The only meaningful gap is the mismatched `mode` default between prose and schema.

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

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

Schema coverage is 100%, so the baseline is 3; the description adds real decision semantics on `mode` (default append, when to choose replace) and on what `body` must contain. However, it states 'Default to `append`' while the schema declares `mode` default 'create' — a conflict the agent must resolve, which keeps this below 5.

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?

Opening sentence names specific verbs (write / append) and a concrete resource (video-built skill), and the tool is clearly distinct from siblings like list_watch_skills and watch_media. An agent knows exactly what this tool produces.

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

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

Explicit routing guidance: 'Call `list_watch_skills` first to see which skill a new video belongs to', 'Default to `append`', and a clear enumerated set of conditions selecting `replace`. Alternatives and exclusions are both named.

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 disclosure burden, yet it says nothing about authentication requirements, rate limits, blocking or long-running behavior, overwrite semantics for download_directory, or what 'supported sites' actually means. Only the basic read-and-write-to-disk nature is implied.

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

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

A single front-loaded sentence with no waste and no preamble. It is efficient, though its brevity contributes to the gaps in behavior and routing rather than being a deliberate trade-off.

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 output schema relieves the need to describe return values and the schema covers all parameters, but for a network-facing download tool with no annotations and nine closely related siblings, the definition omits failure modes, restrictions, and tool-selection context an agent needs to call it correctly.

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

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

Schema description coverage is 100% and all three parameters are documented in the schema, including the audio_only MP3 conversion and download_directory default. The description adds only a slight hint about which sites are supported, so the baseline 3 applies.

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

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

States a specific verb ('Download') and resource ('video or audio') and names example sources (YouTube, Rumble), so the core action is unambiguous. However, it gives no signal distinguishing it from siblings like media_downloader_download_video, media_downloader_download_all, or watch_media, leaving the agent to guess among near-identical download 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 offers no when-to-use or when-not-to-use guidance and never mentions any alternative. With ten sibling tools in the media_downloader family, the absence of routing criteria is a real gap.

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 non-mutating read and the description discloses what comes back (skills plus their existing videos), but it says nothing about behavior on a missing/invalid skills_root, whether the root is created, or ordering/pagination.

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 short sentences with the capability stated first and the usage rationale second. The second sentence is slightly redundant in phrasing ("extends an existing skill" vs "already covers it"), but no sentence is wasted.

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?

An output schema exists, so return values need not be detailed, and with one well-documented parameter the surface is small. The only meaningful gap is undefined behavior for an invalid or empty skills_root.

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

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

Schema coverage is 100% for the single parameter, so the schema already defines skills_root as the directory holding video-built skills. The description adds no format, path-resolution, or constraint detail beyond that, making the baseline 3 appropriate.

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

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

States a specific verb and resource: it lists video-built skills under a root directory plus the videos each already contains. That is clearly a read/inspection operation and distinct from build_watch_skill, though the sibling is never named explicitly.

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?

"Use it before building" gives a concrete trigger point, and the follow-on clause explains the decision it informs (extend an existing skill vs. create new, and coverage overlap). It stops short of naming build_watch_skill or stating when not to call it.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, and destructiveHint=false, so the agent knows this is a non-destructive but externally-reaching operation. The description adds nothing beyond that: it does not say what gets downloaded, whether files are written to disk, how progress is reported (despite a sibling progress_callback tool), or how large an 'all' operation may be.

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 short sentence with no wasted words, but it is under-specified rather than concise — there is no front-loaded statement of scope or outcome. The single sentence carries no information an agent could act on.

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

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

With no parameters and no output schema, the description is the only place to explain what 'all' covers, where the results go, and what side effects to expect on an openWorld operation. It supplies none of that, leaving a meaningful gap for a tool that likely triggers bulk downloads.

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 takes zero parameters, so there is nothing for the description to disambiguate at the parameter level. Baseline 4 applies; the missing semantics are about behavior, not inputs.

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 is a tautology: 'Invoke the download_all operation' merely restates the tool name and title without saying what is downloaded, from where, or to where. It gives no basis for distinguishing it from siblings such as download_media, media_downloader_download_video, or watch_media.

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

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

No guidance on when to use this versus the several download/watch siblings, and no prerequisites or exclusions are stated. The agent must infer scope from the 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?

Annotations declare readOnlyHint=false and openWorldHint=true, so an agent knows this is a non-destructive write that reaches the open web, but the description adds nothing beyond that — no mention of download location, size/format limits, network/auth requirements, or blocking behavior. For a network-writing tool with zero added context, this is inadequate.

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

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

It is one short sentence with no filler, but brevity here is under-specification rather than conciseness — there is no front-loaded statement of purpose or scope to justify the sentence that 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?

A two-parameter, open-world network operation with 0% schema coverage, no output schema, and no annotations covering input semantics requires substantially more description. Nothing an agent needs in order to call it correctly is present.

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%: `link` is required but untyped and undocumented, and `extra_opts` has only a title with a null default. The description provides no meaning for either parameter, so the agent has no idea what format `link` expects (URL? ID?) or what belongs in `extra_opts`.

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 merely restates the tool name and title ("Invoke the download_video operation") without stating what resource is fetched, from where, or how it differs from siblings like download_media, media_downloader_download_all, or watch_media. It is a tautology that gives an agent no basis for selecting this tool over the other download-family 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?

There is no when-to-use guidance at all — no mention of supported sources, no distinction from download_media or download_all, and no noted prerequisites. An agent must guess between at least four download-related siblings with zero routing signal.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds real value by disclosing a side effect the annotations do not mention: links are queued on ``self.links`` so they can presumably be passed to download_all later. That disclosure sits awkwardly against readOnlyHint/idempotentHint (does a repeat call enqueue duplicates?), and the description doesn't resolve that, nor does it say whether the queue is cleared first.

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?

It is a single front-loaded sentence with no padding, which is good. But it spends its words on the internal implementation token ``self.links``, which is jargon an agent may not be able to interpret, rather than on the parameter and return details that are actually missing.

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

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

With no output schema, 0% schema descriptions, and no parameter documentation, the description carries the full burden and does not discharge it: return shape ('return them' – links? IDs? objects?), channel identifier format, and the meaning of limit=-1 are all absent. For a 2-parameter network tool that mutates an internal queue, this leaves too much for the agent to guess.

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%: neither `channel` (untyped) nor `limit` (default -1, presumably meaning unlimited, but unstated) carries any documentation. The description mentions a channel only in passing and never explains `limit` or the accepted channel identifier format, so it fails to compensate for a total schema documentation gap.

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

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

The description states a specific verb and resource ('Find a channel's video links'), so an agent knows exactly what the tool retrieves. It does not, however, contrast itself with siblings such as media_downloader_download_video or media_downloader_download_all, nor does it say how the discovered links relate to those downloaders.

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

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

There is no explicit guidance on when to choose this tool versus download_all, download_video, or watch. Usage is only implied by the word 'Find'. Nothing states prerequisites (does the channel need to be authenticated?) or exclusions.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered structurally, but the description adds nothing: it doesn't explain what 'open' actually does, whether it launches an external process, or what side effects openWorldHint implies.

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

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

A single short sentence is technically concise, but it is under-specified rather than efficient—there is no front-loaded useful information to 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?

For an open-world, non-read-only tool with an undocumented required parameter and no output schema, the description supplies none of the information an agent needs to call it correctly or predict its effects.

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

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

There is one required parameter 'file' with 0% schema description coverage and no type information; the description says nothing about it, so an agent cannot tell whether it expects a path, URL, or identifier.

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?

'Invoke the open_file operation' only restates the tool name; it does not say what resource is opened, in what sense (OS handler launch, file read, stream), or how it differs from siblings like watch_media or download_media.

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 whatsoever on when to call this versus the ten sibling tools (download_media, watch_media, media_downloader_watch, etc.), nor any prerequisites or exclusions.

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

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

Annotations declare readOnlyHint=false, openWorldHint=true, and destructiveHint=false, so the safety profile is partly covered. The description adds nothing about side effects, what the hook does when invoked, or what it returns; it doesn't contradict annotations, but contributes zero behavioral context.

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

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

One short sentence with no wasted words, but this is under-specification rather than conciseness. There is no front-loaded information an agent can act on.

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?

A single-parameter tool with an opaque parameter name, no output schema, and annotations only hinting at open-world non-destructive behavior. The description is far too thin for an agent to call this correctly.

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

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

The single required parameter is named 'd' with no type and 0% schema description coverage. The description says nothing that would explain what 'd' should contain, leaving the agent unable to supply a meaningful value.

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

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

The description merely restates the tool name as 'Invoke the progress_hook operation,' adding no verb specificity or resource clarification. It doesn't distinguish this from media_downloader_set_progress_callback or explain what a 'progress hook' does.

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

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

No guidance on when to use this versus the closely related media_downloader_set_progress_callback, nor any prerequisites or conditions. The agent must infer everything from the 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?

Annotations already declare readOnlyHint=false, destructiveHint=false, and openWorldHint=true, so the description carries a lower burden — yet it adds nothing at all. It does not say that setting a callback mutates downloader state, whether it replaces a previously registered callback, whether it persists, or how the callback is invoked (signature, threading, frequency).

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?

It is short, but the brevity is under-specification rather than efficiency — a single contentless sentence that front-loads nothing useful.

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

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

With one untyped parameter, no output schema, and only minimal annotations, the description should explain what the callback receives and what registering it changes. None of that is present.

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

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

There is a single required parameter 'callback' whose schema is an empty object with no type, description, or signature information, and schema description coverage is 0%. This is the one place the description had to compensate, and it says nothing about the expected callback shape.

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 is a tautology: 'Invoke the set_progress_callback operation' restates the tool name and title without saying what a progress callback is for, what it attaches to, or what it reports. It gives no way to distinguish this from the sibling media_downloader_progress_hook.

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

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

There is no indication of when to call this, whether a download must be in flight first, or how it relates to media_downloader_progress_hook and media_downloader_watch. An agent has to guess entirely.

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?

Goes beyond the annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false) by disclosing the return manifest shape, the `status` success/partial semantics, and the important trait that a degraded run never raises. That failure-mode disclosure is exactly the kind of thing annotations cannot convey; it stops short of covering on-disk artifacts or network/permission constraints.

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?

Front-loaded with the core action, then return contract and edge-case behavior. Four sentences, each carrying information, with no filler; the double-backtick emphasis on `status`/`partial` is slightly verbose but not wasteful.

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?

Return semantics are well covered despite no output schema, and the non-raising guarantee is valuable. However, for a five-parameter tool with zero schema documentation, the description leaves the agent unable to set frame limits, language preferences, or scene sensitivity correctly.

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

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

Schema description coverage is 0% across five parameters, and the description adds no meaning to `link`, `max_frames`, `min_frames`, `subtitle_langs`, or `scene_threshold`. It only obliquely implies captions and scene-based frame extraction, so an agent gets no guidance on tuning frame counts or thresholds.

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?

States a specific compound action: download a video with captions and extract scene-change key frames. Clear verb+resource. It doesn't differentiate itself from siblings like media_downloader_download_video, download_media, or watch_media, so an agent must infer that this is the combined media+transcript+frames pipeline.

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 only implied: a caller wanting media, transcript, and key frames together should use this, and can tolerate a partial bundle. There is no explicit 'use this instead of X' or precondition statement, despite three plausible overlapping siblings.

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

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

With no annotations, the description carries the full load and does well: it discloses the on-disk bundle layout, that frame filenames carry timestamps, and that `status` can be `partial`. It adds a recovery path via `captions.fallback`. It doesn't mention disk footprint, network/size limits, or whether directories are created, which keeps it off a 5.

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?

Front-loaded with the core action, then return shape, then caveat. Every sentence carries distinct information, and there is no filler or repetition of the schema.

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?

An output schema exists, so return values needn't be fully restated, and the description still covers the one thing the schema likely doesn't: the meaning of `status: partial` and the fallback path. An agent has enough to call it and interpret results, with only operational details like disk usage 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 coverage is 100%, so all five parameters are already documented, and the description adds no syntax or format detail beyond them. The reference to captions and `captions.fallback` is output-related rather than parameter guidance, so baseline 3 applies.

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

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

Opens with a specific verb+resource+output: 'Watch a video: download it with captions and extract key frames.' It also explicitly contrasts itself with archiving, which separates it from the download_media / media_downloader_download_video siblings.

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?

Gives a clear when-to-use list ('analyse a tutorial, demo, talk, or screen recording') and an implicit exclusion ('rather than merely archive it'), which points at the plain downloader siblings. It stops short of naming the alternative tool explicitly.

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