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

Discloses that images are downloaded to '<project>/public/images/' and how to reference them, adding behavioral context beyond annotations. Does not mention overwrite behavior or error handling.

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, front-loaded with the core action, no redundant information. Efficient and clear.

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?

Provides usage guidance for the tool's output (referencing in content.json) but lacks mention of prerequisites (e.g., project existence) and error scenarios. Adequate for a simple 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?

Description explains the 'images' parameter (url from search results, short filename) but omits explanation of the 'slug' parameter, leaving it unclear. With 0% schema coverage, this is a partial 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 it downloads Wikimedia images into a specific project directory, distinguishing it from sibling tools like search_wikimedia_images and preview_images.

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?

Implies usage via 'Pass the direct URLs from search results', guiding the agent to use search results first. However, it does not explicitly state when to use this tool vs alternatives like preview_images.

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?

Discloses autonomous one-shot execution, background job, and that no user confirmation is needed. Annotations (readOnlyHint false, idempotentHint false) align; description adds behavioral detail beyond annotations.

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

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

Front-loaded with key phrase 'ONE-SHOT builder — the preferred path,' but is somewhat lengthy with repeated context. Still organized well with flow steps. Minor redundancy (e.g., 'content_json = ...') could be trimmed.

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?

No output schema, but description informs about polling project_status for mp4 path and QA frames, and finishing with write_publish_meta. Covers typical workflow and essential details for a complex tool. Could be more explicit about error handling.

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?

Adds context beyond schema: content_json must include meta/scenes with voiceover and language-specific note, images must match paths, slug kebab-case. Schema already has descriptions, so description enhances but is not fully compensating for low coverage (80% is high).

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 clearly states it is a one-shot builder that scaffolds, downloads, writes content, and renders in one job. It distinguishes from siblings by being the preferred path and specifying typical flow after image gathering.

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 (after storyboard and images chosen, typical flow with search_wikimedia_images), and provides instructions: run autonomously, do not pause to ask user, then poll project_status and use write_publish_meta.

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?

Discloses background execution, fallback behavior, configuration file location, and default voice—all beyond annotations. No contradiction with annotations.

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

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

Packs essential details (backend, voice, fallback, waiting instruction) into two efficient sentences, 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?

Fully explains return behavior and how to check completion, compensating for lack of output schema.

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

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

Adds meaning to voice_id (optional, with default) and implies slug is a project identifier, compensating for 50% schema coverage.

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

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

The description clearly states the tool generates Vietnamese voiceover for every scene using ElevenLabs with a specific voice and fallback, distinguishing it from sibling tools like project_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?

It explains when to use (start voiceover generation) and how to wait for completion via project_status, but lacks explicit when-not-to-use or 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?

The description adds behavioral context beyond the readOnlyHint and openWorldHint annotations, such as what fields the response contains (including poster image when exists) and the required follow-up action of user interaction. No contradictions with annotations.

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

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

The description is concise (about 80 words), front-loaded with the main purpose, and structured with clear sections. Every sentence adds value: purpose, output details, and mandatory user interaction steps.

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

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

Given no parameters, existing annotations, and no output schema, the description fully explains the tool's output and the required workflow after calling. It is complete for an agent to use effectively.

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

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

The input schema has zero parameters, so the baseline is 4 per instructions. The description does not need to add parameter information since there are none.

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's purpose as 'START HERE for any make a video about X request' and lists exactly what it returns (id, name, appearance, best use case, poster image). This clearly identifies the tool and distinguishes it from siblings like template_schema.

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 explicit usage guidance: 'START HERE' for video requests, instructs the agent to present templates to the user and ask for a choice using AskUserQuestion tool, and warns against silent selection. It also indicates the next step (call template_schema with the chosen id).

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 indicate this is a mutation (readOnlyHint=false) and not idempotent. The description adds the detail that it runs npm install (~15s) and creates the project at a specific path. However, it does not disclose what happens if the project already exists (e.g., overwrite or error), which is a notable behavioral gap.

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

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

The description is extremely concise, consisting of two short sentences that convey the essential purpose, location, side effect (npm install), and usage context. 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?

Given the absence of an output schema, the description does not explain what the tool returns, which is a minor gap. However, the tool's purpose is straightforward (project creation), and the usage context is well-specified. The description works well within the broader toolset, as implied by sibling tools.

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 covers 100% of parameters with descriptions for both 'slug' and 'template'. The description does not add additional semantics beyond what the schema provides. Baseline score of 3 is appropriate for full schema coverage with no extra parameter information.

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

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

The description clearly states the tool creates a new Remotion project at a specific path using a chosen template, and positions it as the first step before adding media or content. This distinguishes it from sibling tools like add_images or write_content.

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 'Do this once per video, after the user picked a template, before adding images or writing content', providing clear context on when to use it. It also mentions the npm install duration. However, it does not explicitly state when not to use it or list alternative tools for other scenarios.

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 (readOnlyHint=true) indicate a safe read operation. The description adds that thumbnails are small and for visual preview before committing, which aligns with read-only behavior. There is no contradiction, and the text enriches the behavioral understanding beyond annotations.

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

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

Two sentences, front-loaded with the core action and purpose. Every word contributes meaning, with no redundancy. Ideal conciseness.

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 single parameter with full schema coverage and no output schema, the description fully explains the tool's purpose, when to use it, and what it produces. No gaps remain for effective invocation.

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

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

Schema coverage is 100%, with the parameter 'urls' already described as 'image URLs from search results'. The description reiterates this context but does not add new semantic details beyond what the schema provides. Baseline score of 3 is appropriate.

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

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

The description clearly states the tool downloads image URLs and returns thumbnails for visual judgment. It specifies the action (download, return), resource (image URLs), and context (before committing), distinguishing it from sibling tools like search_wikimedia_images.

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 'Use after search_wikimedia_images when you need to see the images,' providing clear context and sequence. It does not explicitly mention when not to use, but the guidance is sufficient for proper selection.

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

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

Annotations declare readOnlyHint=true, consistent with reporting status. Description adds behavioral detail: polling semantics (wait up to ~50s), returned data (duration, audio presence, 4 QA frames), and post-use actions (adjust focalX/focalY). No contradiction.

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 primary purpose, then conditional details. Every sentence provides value without redundancy. Length is appropriate for the information conveyed.

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

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

Covers return values, timeout, and actionable QA instructions. Lacks details for error handling (invalid slug) and the 'build' option. Overall sufficient 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 description must compensate. It explains two of four enum values for wait_for (voiceover, render) and their behavior, but does not clarify 'build' or 'none' (default). Slug parameter is obvious. Partial 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 reports voiceover and render progress for a project, with specific wait behaviors. It distinguishes from siblings like render_video and generate_voiceover by focusing on status checking rather than initiation.

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 clear usage context: when to call (after initiating processes), how to interpret output (inspect QA frames, adjust parameters), and retry advice ('If a job is still running... call again'). Does not explicitly contrast with alternatives but implies its role.

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 indicate non-readOnly (mutation), not idempotent. Description adds that it runs in the background and returns immediately, which is critical behavioral info. Could mention if there are any side effects besides the render file, but overall solid.

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 sentences with no fluff. First sentence states action, second describes behavior, third gives usage guidance. Highly efficient.

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

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

Ties into the pipeline well with explicit before/after instructions. Lacks parameter doc, but the workflow context compensates. No output schema mentioned, but follow-up tool covers it.

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

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

The single parameter 'slug' has no description in schema (0% coverage) and the tool description does not explain what it is. This is a significant gap; agent cannot know what value to provide.

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

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

The description clearly states the verb 'Start' and the resource 'Remotion render', and specifies the output file. It distinguishes from siblings by describing the background nature and ties into the pipeline with sibling tool project_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?

Explicitly says to use after voiceover finished and then call project_status. Provides clear timing and follow-up, with no ambiguity.

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?

Beyond annotations (readOnlyHint, openWorldHint), the description discloses that the tool returns candidates with title, license, author, pixel dimensions, and downloadable URL. It sets selection criteria (>=1000px, old photos) and instructs the agent to be autonomous and always credit sources. This provides a complete behavioral profile for the agent.

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

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

The description is well-structured, starting with the main purpose, followed by usage tips, return format, selection criteria, and autonomy instructions. Each sentence adds value, though it is slightly verbose. The information is front-loaded and logically ordered.

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

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

Given the lack of output schema, the description adequately describes return values (title, license, author, dimensions, URL). It also provides selection criteria and attribution instructions. However, it does not address edge cases like no results or pagination. Overall, it is sufficiently complete for an image search tool.

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

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

The description adds meaning to the 'query' parameter by emphasizing English keywords and providing examples. However, the 'limit' parameter is not mentioned in the description, and the schema provides only constraints (default, min, max) without context. With 50% schema coverage, the description partially compensates but misses an opportunity to explain how 'limit' affects results.

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: 'Find freely-licensed (Public Domain / CC) images on Wikimedia Commons for a topic.' It specifies the exact resource (Wikimedia Commons), license type, and action (find/search). It differentiates from siblings like 'preview_images' and 'add_images' by focusing on search and retrieval of candidates.

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 detailed usage guidance: search with English keywords, prefer images >= 1000px, prefer old public-domain photos for documentary feel, and always keep license/author for credits. It also instructs autonomy ('do NOT stop to ask the user') and mentions a sibling tool (list_templates) as the only exception. However, it does not explicitly state when to avoid this tool in favor of alternatives.

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

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

Description adds significant behavioral context beyond annotations: writes to specific file with restricted permissions, never leaves the machine, idempotent behavior confirmed by noting calling with no args just checks status. No contradictions with annotations.

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

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

Description is reasonably concise given the detail needed. Front-loaded with primary action, then usage conditions, security, alternatives. Each sentence serves a purpose, though slightly lengthy.

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?

Complete for a key-setter tool: explains security, alternative config, and status-check behavior. No output schema needed as side-effect is clear. Sibling tools (like generate_voiceover) likely depend on this key, making context sufficient.

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

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

Schema already covers the single optional parameter (api_key) with description 'omit to only check current status'. Description restates this but doesn't add new semantic meaning beyond the schema. Baseline 3 for high coverage.

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

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

Clearly states the tool saves the user's ElevenLabs API key for generating voiceovers. Distinguishes itself from sibling tools by being the only one handling API key configuration.

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 when-to-call: only when a tool reports no key or user offers one. Instructs to ask user and never invent. Offers alternative environment variable setup, giving complete usage guidance.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=false. The description adds that it returns a scene outline and hard rules, which are behavioral details beyond the annotations. It does not mention any destructive actions, which aligns with readOnlyHint. No contradictions.

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

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

Two sentences with no extraneous information. The first sentence states the outcome concisely, and the second provides usage context. Very 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?

Given the simple input (one parameter), good annotations, and no output schema, the description fully covers when to use, what it returns, and a critical warning. It is complete for the tool's purpose.

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% with the parameter 'template' described as 'template id from list_templates'. The description does not add further semantics beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states it returns the content.json schema, scene outline, and hard rules for ONE template. It uses specific verbs ('Return', 'Get') and resources ('content.json schema', 'scene outline', 'hard rules'), and the title reinforces this. The instruction to call it after the user picks a template and before writing content distinguishes it from sibling tools like list_templates or write_content.

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 states when to use: 'Call this after the user picked a template, before writing any content.' Also provides a clear exclusion: 'Each template has its OWN scene types — do not reuse another template's shape.' This guides the agent on proper sequencing and prevents misuse.

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?

The description adds behavioral context beyond annotations: it specifies the required structure, constraints on Vietnamese text, and factual accuracy. The idempotentHint true is consistent; no contradictions. It could mention that it will overwrite existing content.json but is idempotent per annotations.

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

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

The description is fairly long but well-structured: purpose first, then schema breakdown, then special rules. Every sentence adds value, but it could be slightly more concise by grouping rules more tightly.

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 only 2 parameters and no output schema, the description covers the input format extensively, including edge cases (Vietnamese ALL-CAPS). It lacks some details like whether partial writes are allowed, but likely sufficient for an agent with idempotentHint.

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 parameter 'slug' has no description in schema, but the description compensates by clearly explaining its usage in the path. 'content_json' is fully detailed in the description with schema, internationalization rules, and accuracy requirements, far exceeding the minimal schema description.

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

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

The description clearly states the verb 'Write' and the resource 'the video storyboard to <project>/content.json'. It distinguishes itself from sibling tools like 'preview_images' or 'generate_voiceover' by specifying its exact output file and format.

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 implicitly tells when to use this tool (to write the storyboard) through its clear purpose. However, it does not explicitly mention when not to use it or describe alternatives, which would be helpful given the sibling list.

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 mark it as idempotent but not read-only. The description adds that it saves two files and returns the text for display, which informs the agent about side effects. It does not contradict annotations.

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

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

The description is textually efficient, front-loading the positioning information ('FINAL STEP'). It uses a structured bullet-like format for parameters. A slight reorganisation could improve readability slightly.

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

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

Given the complexity of the tool and the absence of an output schema, the description covers the main behavioral aspects (file saving, return value) and usage constraints. The missing explanation of the 'slug' parameter 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?

Schema coverage is 75%, and the description adds meaningful constraints beyond the schema for title, description, and hashtags (e.g., character limits, sentence count, image credit requirements). However, the 'slug' parameter is not explained in the description, leaving a 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 clearly states the tool's purpose: saving publishing copy (title, description, hashtags) as the final step after rendering. It distinguishes this from sibling tools like 'write_content' which write the script content earlier in the 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?

The description explicitly indicates this is the final step after rendering, providing clear timing. It also gives constraints like language matching and content truthfulness, but does not explicitly list alternatives or when not to use.

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