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 whether existing scripts are overwritten, whether the operation is asynchronous, whether partial failures can occur, or what side effects the batch operation has. The schema's regenerate parameter hints at overwrite behavior, but the description itself is silent on it.

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 with no wasted words. It quickly communicates the core action and scope, making it easy for an agent to parse.

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

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

For a batch operation with no annotations and no output schema, this description is too thin. It omits important operational context such as return behavior, async/sync execution, whether the project must already contain slides, and what happens when some slides already have scripts.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters. The description adds the batch/all-slides framing but does not clarify the optional slide_ids subset, and it does not provide meaningful semantic detail beyond what the schema already states.

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 action ('Generate narration scripts'), a clear resource ('ALL slides in a project'), and a distinguishing mode ('one batch operation'). This makes it easy to differentiate from the sibling generate_script tool, which presumably handles a single slide.

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 phrase 'ALL slides in a project in one batch operation' implies the tool is for bulk script generation rather than per-slide generation. However, it does not explicitly name the alternative (generate_script) or state when not to use this tool, so usage guidance remains mostly implied.

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 behavioral burden. It communicates that this is a read-only status poll and implies non-blocking use. However, it does not disclose possible status values, how the response looks, or behavior for unknown project IDs.

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 concise sentences, with the core purpose front-loaded and the usage context in the second sentence. Every word earns its place.

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 tool is simple with one parameter and no output schema, so the missing return-value description creates a real gap. The agent knows when to call it, but not what statuses to expect or how to interpret the response.

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

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

Schema description coverage is 100%, so the schema already documents project_id. The description only repeats 'of a project' and adds no format, constraints, or relationship to triggering operations. 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?

The description states a specific verb ('Check') and resource ('processing status of a project'), and the polling context distinguishes it from CRUD and generation siblings. It does not explicitly name a sibling it is not, so it misses the highest bar for differentiation.

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 clearly tells the agent when to use the tool: poll for completion after render, TTS, or video generation. It does not state exclusions or when to prefer get_project or list_projects, so there is a small 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?

The description discloses the main side effect (creating a project) and the return value (project_id), going beyond what the tool name alone implies. It also adds the useful context that the project_id is required for subsequent operations. With no annotations, it carries the burden well, though it omits details like error handling or whether creation is idempotent.

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 no filler. The core purpose is front-loaded, and the return-value note earns its place by signaling workflow relevance.

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 creation tool with only three parameters and no output schema, the description is adequate. It states the return value (project_id) and its importance for later steps, which is the key contextual information. Missing details like response format or error conditions are minor at this complexity level.

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

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

Schema description coverage is 100%, so the parameters are fully documented in the schema. The description adds no additional parameter-level meaning, but it doesn't need to; the baseline of 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?

The description clearly states the action ('Create a new SlideMaster project') and the resource, making it obvious this is a creation tool. It is easily distinguished from sibling project tools like update_project, get_project, list_projects, and delete_project by the verb and 'new' qualifier.

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 explicit guidance is given about when to use this tool versus alternatives. The description does not name other project operations or state prerequisites. The phrase 'needed for subsequent operations' hints at its role in a workflow but does not provide clear when-to-use or when-not-to-use direction.

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

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

With no annotations, the description carries full responsibility for behavioral disclosure. It states the operation is permanent and cascades to associated slides, audio, and video files, which are the critical traits an agent needs to know before invoking.

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 sentence delivers the operation, resource, and destructive scope without any filler. The key warning about permanence is front-loaded.

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

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

For a one-parameter tool with no output schema, the description provides all essential context: what is deleted, permanence, and cascade effects. No additional details are necessary for correct 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 description coverage is 100% and the single project_id parameter is already well-described in the schema. The description adds no additional parameter-level meaning beyond the schema, so the baseline of 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?

The description states a specific verb ('delete'), the resource ('project'), and the scope ('all associated slides, audio, and video files'). It clearly distinguishes from sibling delete_slide by making the whole-project scope 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?

The description implies when to use this tool: when the entire project and its assets must be removed. It does not explicitly name delete_slide as the alternative for removing only a slide, but the cascade scope makes the intended use clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states that a slide is deleted but does not indicate whether deletion is permanent, whether related resources are affected, or whether any confirmation or project-level checks apply.

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, clear sentence communicates the operation with no wasted words. It is front-loaded 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?

The tool is simple with one parameter and no output schema, so the description covers the basic operation. However, because there are no annotations and no guidance on behavior or context, an agent is left to infer important details about the deletion process.

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

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

Schema description coverage is 100%, so the input schema already documents slide_id. The description adds no extra semantic detail beyond 'Slide ID to delete', but the schema is sufficient. 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 uses a specific verb ('Delete') and resource ('an individual slide from a project'), clearly distinguishing it from sibling tools like delete_project or update_slide. It names exactly what is acted upon and the 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 gives no guidance on when to use this tool versus alternatives such as delete_project, update_slide, or list_slides. There is no mention of prerequisites, side effects, or conditions that would make this tool the right choice.

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

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

With no annotations provided, the description carries the full burden for behavioral disclosure. It indicates the tool returns download URLs, but it does not explain whether the export operation is synchronous or asynchronous, whether it triggers generation, or whether the URLs are temporary. This leaves important behavioral ambiguities.

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 sentence with no filler. It front-loads the action and resource, then specifies the asset types. Every phrase earns its place.

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 tool is low complexity with one parameter and no output schema, so the description need not be extensive. However, it omits the return format, sync/async behavior, and prerequisites such as generated assets existing. These gaps prevent it from being fully 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 100%: project_id is documented as 'Project ID to export'. The description adds no further parameter-level meaning beyond the schema, so the 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 action ('Export') and the resource ('project data and download URLs for all generated assets'), with specific asset types (slides, audio, video). This distinguishes it from siblings like get_project or check_status, which focus on retrieving project details or checking status rather than exporting assets.

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 explicit guidance is given about when to use this tool versus alternatives. It does not mention that assets must already be generated, whether export is asynchronous, or that check_status might be needed to monitor progress. Usage is only implied, 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 full burden of behavioral disclosure. It does explain the core behavior: it returns slide titles and descriptions, and the phrase 'can be used to create slides' suggests the outline is not itself a finished slide deck. However, it omits any mention of side effects, persistence, or whether the outline is tied to an existing project.

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 with no filler. The core action is front-loaded, and the output expectation is stated immediately. Every sentence earns its place without repeating schema details.

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 straightforward content-generation tool with fully documented parameters and no output schema, the description adequately captures both input and return value. It could be more complete by explaining how the returned outline is intended to be used downstream, but the essential information for calling the tool 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 100%, so all four parameters are already documented in the schema. The description adds little beyond reinforcing that the outline is generated 'from a topic,' so it stays at the baseline for parameter semantics.

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 specific verb and resource: 'Generate a presentation outline from a topic.' It then clarifies the return value as a list of slide titles and descriptions, which distinguishes it clearly from sibling tools like generate_script or generate_video that produce different artifacts.

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 meant for producing an outline before slide creation, but it never explicitly states when to prefer this tool over generate_script, topic_to_video, or other siblings. No when-to-use or when-not-to-use guidance is provided, so usage context is only implied.

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 state whether generation overwrites existing scripts, whether the operation is asynchronous, what it returns, or whether it has side effects. The regenerate parameter hints at overwrite behavior, but the description itself does not clarify this.

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 with no filler. Every word contributes to the core purpose, and the most important scoping detail ('single slide') is included.

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 and no annotations, the description is incomplete for practical use. It does not mention how the generated script is returned, whether generation is asynchronous, or what happens when a script already exists. An agent would need to infer these details from the regenerate parameter or sibling tool behavior.

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

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

Schema description coverage is 100%, so the parameters are already documented in the schema. The description adds the context of 'narration script' and 'single slide', but it does not add meaning to slide_id, regenerate, or prompt_style beyond what the schema provides. A baseline 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 action (generate), the object (a narration script), and the scope (a single slide). This distinguishes it from siblings like batch_generate_scripts and generate_outline without requiring schema inspection.

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 use this tool versus batch_generate_scripts or other alternatives. The phrase 'single slide' implies a use case, but the description never says 'use this for one slide, use batch_generate_scripts for multiple slides' or similar.

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 reveals that audio will be generated and whether scope is project-wide or slide-specific, but it does not say whether generation is synchronous or async, whether existing audio is overwritten, or whether a script must exist 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?

The description is two short sentences with no filler. It front-loads the action and immediately provides the key usage distinction. Every word earns its place.

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 zero required parameters in the schema but instructions implying at least one ID must be provided, the description does not clarify what happens if both are omitted or both are provided. There is no output schema and no mention of return behavior or pipeline prerequisites, leaving important gaps for an agent.

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

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

Schema description coverage is 100%, so the schema already documents all parameters. The description's project_id/slide_id explanation adds no meaning beyond the schema descriptions; it merely repeats the single-slide vs all-slides distinction.

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 action and resource: "Generate text-to-speech audio." It is distinct from sibling tools like generate_script, render_slides, and generate_video. The project_id/slide_id distinction also clarifies the two modes of 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 gives clear scope-based usage: use project_id for all slides or slide_id for a single slide. It does not explicitly mention alternatives or exclusions relative to sibling tools, so it falls just short of full 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 usefully discloses the tool's inputs and role, but it does not mention side effects, long-running behavior, output format, or how the force parameter interacts with existing videos. This is helpful but incomplete.

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 short sentences with no filler. The action is front-loaded, and the second sentence adds pipeline context 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?

The schema covers all parameter semantics, but there is no output schema and no annotations. The description names dependencies and pipeline position, but does not clarify whether the operation is asynchronous, how results are returned, or how failures are surfaced. It is adequate but not fully 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 100%, so the schema already documents all parameters adequately. The description adds no parameter-specific detail beyond that; 'from rendered slides and TTS audio' provides context but does not explain fps, force, resolution, or project_id behavior.

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: 'Compile the final video from rendered slides and TTS audio.' It also distinguishes itself from sibling tools like render_slides and generate_tts by identifying itself as the final pipeline 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?

The description explicitly says 'This is the last step in the pipeline,' which implies it should be used only after render_slides and generate_tts have produced their outputs. It does not name alternatives or state explicit exclusions, but the pipeline context provides clear usage direction.

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

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

There are no annotations, so the description carries the full burden of behavioral disclosure. It clearly signals a read operation ('Get') and what data is returned (metadata, current status), but it does not mention potential errors, authentication requirements, or side effects, leaving 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 a single, focused sentence with no filler. The main action and object are front-loaded, and every word earns its place.

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 get-by-ID tool with one parameter and no output schema, the description gives enough context to select and invoke it. It could be more complete by describing the exact return structure or behavior when a project is not found, but these are minor gaps for this low-complexity 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 schema already has 100% description coverage for project_id ('Project ID to retrieve'), so the description adds no additional parameter-level meaning. A baseline of 3 is appropriate because the schema fully handles parameter semantics.

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 clear verb ('Get'), a specific resource ('a specific project'), and the kind of output ('detailed information ... metadata and current status'). This distinguishes it from list_projects (all projects) and check_status (status only), so an agent can select it without opening the 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 implies usage: use this when you have a specific project_id and need full details. It does not explicitly state when not to use it, nor does it name alternatives like list_projects or check_status, so the usage context is only inferred rather than clearly 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 provided, the description carries the full burden of behavioral disclosure, but it only says 'List all projects in the account.' It does not disclose pagination behavior, the effect of the limit parameter, or that 'all' may not be fully returned in a single call when the account exceeds the maximum limit.

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 with no filler or redundant information. It is concise, though slightly too sparse given the potential mismatch between 'all' and the limit parameter.

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

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

For a simple list tool with one optional parameter, the description and schema provide a workable baseline. However, the lack of pagination or limit context, especially given the 'all' wording, leaves an agent uncertain about behavior when more than 100 projects exist.

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 single limit parameter is fully documented in the schema. The description adds no parameter-level detail, which is acceptable because the schema already provides the default and maximum values.

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 a specific verb ('List') and a clear resource ('all projects in the account'), making the tool's function immediately obvious. It naturally distinguishes itself from siblings like get_project, create_project, and update_project by focusing on account-wide enumeration.

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 for retrieving all projects, which provides clear context for account-level listing. However, it does not explicitly say when to use this instead of get_project, nor does it mention any exclusions or pagination caveats.

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 usefully states that the result includes titles, scripts, and render status, but it does not explicitly confirm the operation is read-only or describe ordering, pagination, or empty-result behavior.

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

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

The description is a single, action-first sentence with no filler. It efficiently conveys the resource, scope, and primary output fields in one line.

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 one-parameter list operation with no output schema, the description provides adequate context by naming what the response contains. Minor details such as result ordering, sorting, or behavior for projects with no slides are not specified, but they are not critical for selecting or invoking this tool.

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

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

Schema coverage is 100%, and the only parameter, project_id, already has a clear schema description. The tool description adds only the generic phrase 'a specific project' and no extra detail about where the ID comes from or what values are valid, landing at the baseline.

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 specific action and resource: 'List all slides belonging to a specific project.' It also names the key output fields (titles, scripts, render status), making the tool's purpose immediately clear and distinguishable from sibling tools like list_projects or get_project.

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 clearly implies its use case: call this tool when you need all slides for a known project_id. However, it does not explicitly contrast it with alternatives such as get_project or list_projects, nor does it state when not to use it, so routing between siblings is left to inference.

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?

There are no annotations, so the description carries the full burden of behavioral disclosure. It accurately conveys that the tool lists voices and is non-destructive ('List all available TTS voices'), but it does not describe the return format, whether voice IDs are included, or how providers are represented. For a simple read-only list operation, this is adequate but not rich.

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 short sentences with no filler. The first sentence states the core function, and the second sentence provides valuable usage context ('before generating TTS'). Every word earns its place.

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, zero-parameter list operation with no output schema and no annotations. The description explains what it lists, the scope ('across all providers'), and when it is useful. It could mention the return structure, but the simplicity of the operation keeps the definition 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?

The input schema has zero parameters, and schema description coverage is 100% since there are no properties. With 0 params, the baseline is 4, and the description correctly implies that no input is needed. The description does not need to add parameter details because 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 uses a specific verb and resource: 'List all available TTS voices across all providers.' It clearly distinguishes itself from generation tools like generate_tts by focusing on discovery rather than generation. The purpose is immediately obvious and unambiguous.

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

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

The description states when to use it: 'Useful for choosing a voice before generating TTS.' This gives clear context about the intended workflow stage. It does not explicitly name alternatives or exclusions, but the no-parameter scope and unique purpose among siblings make the usage guidance sufficiently clear.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does state that each slide gets a background image from the image generation model, but it fails to disclose whether rendering is asynchronous, whether it overwrites existing slide images, whether it triggers additional costs or rate limits, or whether the operation is reversible.

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 concise sentences with no filler. The first sentence front-loads the verb and resource, and the second clarifies the per-slide output. Every clause earns its place.

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 tool has no output schema and no annotations, so the description must be more informative. It leaves out return behavior, whether rendering is synchronous or asynchronous, and operational side effects. Given siblings like check_status exist, an agent would benefit from knowing whether this renders immediately or starts a background job.

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 already covers 100% of the parameters with descriptions, so the baseline is 3. The description adds only a general tie to 'background image produced by the image generation model,' which reinforces the tool's purpose but does not clarify individual parameter syntax or behavior 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 names the verb ('Render') and the resource ('AI-generated slide images for a project'), making it immediately obvious what the tool does. It also distinguishes itself from content-generation siblings like generate_script and generate_video by focusing specifically on producing slide background 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 gives no guidance on when to invoke render_slides relative to sibling tools such as generate_outline, generate_video, or check_status. There is no mention of prerequisites, sequencing in the workflow, or conditions that would make an alternative tool more appropriate.

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

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

With no annotations, the description carries the behavioral burden. It discloses that the tool is asynchronous ('Poll check_status afterward'), that it produces slides by default, and that scripts and video are opt-in via flags. It does not detail side effects or errors, but covers the key behavioral traits needed to invoke and manage the operation.

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 filler. It front-loads the core purpose, then the default behavior, then the two key flags, and finally the required follow-up. Every sentence contributes actionable 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?

The description is adequate for a 9-parameter tool with no output schema and no annotations. It explains the pipeline behavior, conditional outputs, and post-call polling. Minor gaps remain around result retrieval and relationship to step-level siblings, but the schema carries the parameter detail and the description provides enough operational context.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a useful high-level summary of the include_scripts and include_video flags, but it does not provide meaning beyond the schema's parameter descriptions. No parameter documentation gap exists, so no higher score is warranted.

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 a specific action and resource: 'create a presentation from a topic' via a 'one-click pipeline'. It also clarifies the default output (slides only) and optional outputs (scripts, MP4 video), which distinguishes it from granular sibling tools like render_slides and generate_video.

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 clear usage context: use this for an end-to-end topic-to-presentation pipeline, set include_scripts for narration scripts, set include_video for video, and poll check_status afterward. It does not explicitly mention when not to use it or name alternative step tools, but the pipeline framing and follow-up guidance are sufficient.

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 bears the full burden of disclosing behavior. It only says 'Update project properties,' which largely restates the mutation implied by the name; it does not state whether updates are partial, require ownership or permissions, take effect immediately, or what is returned. No contradiction with annotations, but no value added beyond the verb.

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 focused sentence with the verb and resource front-loaded and a compact enumeration of the updatable fields. No filler or redundancy; every word earns its place.

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?

Adequate for a standard partial-update tool: one required project_id plus fully documented optional fields, so invocation is inferable. However, with no annotations and no output schema, the lack of behavioral detail (success semantics, permissions, partial vs full update) leaves the description thinner than ideal for a mutating operation.

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 schema already documents all seven parameters. The description adds marginal value by grouping the TTS-related properties and signaling which fields are updatable, but it supplies no format or constraint details beyond the schema. The baseline 3 applies since the schema does the heavy lifting.

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

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

States a specific verb ('Update') and resource ('project properties') and enumerates the modifiable fields (title, description, TTS provider, voice, language, speaking rate), covering essentially all settable parameters. It does not explicitly name a sibling, but the verb+resource pairing distinguishes it from create_project, get_project, and update_slide.

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 no guidance on when to use this tool versus alternatives. It never mentions that create_project is for new projects, get_project for reading, or how update_project relates to update_slide. No conditions, exclusions, or prerequisites are given.

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 behavioral disclosure. It only says 'Update', which implies mutation, but does not state whether the update is a partial merge or full replacement, whether omitted fields are affected, whether changes are reversible, or whether it invalidates downstream artifacts like rendered slides or generated audio.

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 with no filler. Every word contributes to identifying the tool's action, target, and scope.

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 partial-update tool with full schema coverage, the description is mostly adequate for identifying the call. However, with no annotations and no output schema, it leaves gaps about return values and behavioral side effects that would help an agent invoke it confidently.

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 schema already documents all parameters. The description adds no meaning beyond what the property descriptions provide, aligning with the baseline score of 3.

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

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

The description states a specific verb ('Update'), a specific resource ('an individual slide'), and the exact fields affected ('title or narration script'). This clearly differentiates update_slide from siblings like delete_slide, list_slides, and generate_script without needing to inspect schemas.

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: you would call this when modifying an existing slide's title or narration script rather than generating a new script or deleting the slide. However, there is no explicit when-to-use or when-not-to-use guidance, and no alternatives are 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 exist, so the description must bear the full behavioral burden. It only states the final effect (server begins processing) and does not disclose idempotency, side effects of early or repeated calls, failure behavior, or any required preceding steps beyond the schema's project_id hint.

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 redundant words. It states the action and its consequence efficiently, earning every word.

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 single-parameter tool with no output schema, the description plus schema covers the core invocation. However, it lacks explicit sequencing relative to upload_init and any note about expected return or error states, leaving a modest completeness 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 description coverage is 100% for the sole parameter, so the schema already documents project_id as 'Project ID returned from upload_init'. The description adds no parameter-level detail, keeping this at the baseline for good 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 uses a specific verb ('Mark'), a concrete resource ('a file upload'), and a clear outcome ('so the server can begin processing the uploaded presentation'). This action is naturally distinct from sibling upload_init, which would initiate rather than complete an upload.

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 called after a file has been uploaded, but it does not explicitly state sequencing, prerequisites, or alternative tools. No 'when not to use' guidance is provided.

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

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

With no annotations, the description must carry the full behavioral disclosure burden. It mentions the return values but omits important behavior: whether this creates state, whether the URL expires, whether the actual file bytes are sent later, and whether upload_complete must be called afterward.

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 sentence with no filler and front-loads the core action. The phrase 'existing presentation file' could be clearer, but overall it is appropriately concise.

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

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

The description does not explain the overall upload workflow or that a follow-up call to upload_complete is likely required. Since there is no output schema, the agent cannot infer how to proceed after receiving the pre-signed URL.

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

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

Schema description coverage is 100%, so the description does not need to add parameter details. It does add the constraint that files are PPTX/PDF, but the baseline of 3 is appropriate since the schema already documents title and filename clearly.

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 names the action ('Initialize a file upload session') and the resource ('presentation file (PPTX/PDF)'), and states the key result (pre-signed URL and project_id). It is distinguishable from the sibling upload_complete because 'initialize' and 'complete' indicate different phases.

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

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

No guidance is given about when to use this tool versus upload_complete or other siblings. The description does not mention that this is the first step in a multi-step upload flow, nor does it state 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.