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

With no annotations provided, the description fully discloses behavioral traits: requires Playwright and chromium installation, no LLM call, server-side execution, how slide_indices empty means all, and iteration versioning. The return structure is also described.

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 efficient, with a clear structure: introductory sentence, requirement note, Args list, Returns list, and Next step. Every sentence adds value 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?

Despite the tool being part of a larger pipeline (many siblings like prepare_* and ingest_*), the description provides sufficient context: it is Phase 1 of visual QA, has an output schema (though description already explains returns), and lists required setup. No additional information is needed 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?

The schema has 0% description coverage, so the description carries the full burden. It explains each parameter: project_id is required, slide_indices are 1-based comma-separated (empty means all), and iteration is 0-based for versioning. This adds essential meaning beyond the schema.

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

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

The description clearly states the tool captures slide screenshots via Playwright, server-side, and distinguishes it from siblings by positioning it as Phase 1 of visual QA. The verb 'captures' and resource 'slide screenshots' are specific 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 provides clear context: it is used for visual QA, Phase 1, and explicitly states the next step is to call prepare_visual_qa_analysis. It does not explicitly state when not to use it or mention alternatives, but the sequential usage guidance is strong.

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

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

No annotations are provided, so the description carries full burden. It discloses that the operation is 'pure file removal + reindex', involves no LLM call, and returns a JSON with project_id and new slide_count. It also notes the necessity to refresh HTML afterward. This level of detail is excellent for a mutation tool.

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

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

The description is very concise, using a few sentences plus bullet points for parameters and return. The most critical information (action, params, return, post-call) is front-loaded. Every sentence earns its place without redundancy.

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

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

Given the tool's simplicity (delete a slide with two required parameters, an output schema inferred from the return description), the description covers all essentials: what it does, how to use it, what to expect back, and a necessary follow-up action. There is no obvious missing information for an AI 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 0%, so the description must fully explain parameters. It does so clearly: project_id as 'Target project ID (required)' and slide_index as 'Slide position to delete (1-based).' These descriptions add essential meaning beyond the schema's type and title.

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 'Deletes a slide' with the verb 'deletes' and resource 'slide'. It adds 'No LLM call — pure file removal + reindex', which confirms the nature of the action. Though it does not explicitly compare to siblings, the verb and resource are unambiguous and clearly differentiate from other tools like move_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 description includes a post-use instruction ('After this call, call export_html...'), which provides some workflow guidance. However, it does not explain when to use this tool versus alternatives (e.g., move_slide for reordering, or capturing slides). No explicit when-not or alternative comparisons 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, description fully discloses deterministic vs auto-load mode, output file structure, and return fields. No contradictions or omissions.

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?

Well-structured with sections, but slightly verbose (3 paragraphs). Front-loaded purpose but could trim examples of mode 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?

Given two parameters, no required fields, and presence of output schema, description provides all needed context for correct invocation without gaps.

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?

Both parameters (design_spec_json, project_id) are explained with their roles and defaults. Schema coverage is 0%, so description compensates fully.

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?

Clear verb 'Generates' with specific output (per-slide HTML files and iframe container). Distinguishes from siblings like export_pptx by format. Two modes further clarify 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?

Explicitly describes two operational modes and when to use each, but does not state when to avoid this tool or name alternative tools for different 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?

With no annotations, the description carries the full burden. It discloses two modes and return format but omits prerequisites, side effects, and error conditions. It implies read-only behavior but does not explicitly state 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?

Reasonably concise with a clear mode breakdown. The Args section partially repeats info from the mode descriptions, slightly reducing efficiency.

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

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

The description covers the return format and modes but lacks prerequisites (design spec existence), error handling, and differentiation from export_html. Output schema exists but does not fully compensate for missing 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 coverage is 0%, so description compensates by explaining the behavior of each parameter (direct generation vs auto-load). Adds meaning beyond the schema's titles and defaults, though could specify the format of the JSON string.

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 exports the design spec as a PPTX file, with specific verb and resource. It explains two modes of operation but does not differentiate from sibling tools like export_html.

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 internal mode guidance (recommended auto-load) but no external guidance on when to use this tool vs alternatives such as export_html. Missing when-not-to-use and alternative mentions.

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 that no LLM call is made, builds slides.html, runs lint, and requires overflow_json. Also specifies return fields. No annotations provided, so description carries the burden well.

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 core action, then structured into args, returns, and important follow-up. Every sentence adds value with no fluff.

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

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

Covers prerequisites, parameters, return fields, and required follow-up. Given output schema exists, the description supplements it well.

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

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

Schema coverage is 0%, but description clarifies project_id as required and overflow_json as optional JSON array with default ''. Provides meaningful context beyond 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?

Clearly states it finalizes a deck by building slides.html and running lint. Distinguishes from siblings like ingest_design_slide and export_html by specifying the procedure order.

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 call once after all slides are ingested via ingest_design_slide and provides a follow-up step to call export_html. Lacks explicit when-not-to-use but positive guidance is strong.

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

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

With no annotations provided, the description carries full burden. It discloses 'No LLM call' and implies a build action, but does not detail side effects (e.g., overwriting previous exports), permissions, or error conditions. The return type is mentioned. This is adequate but lacks depth, warranting a 3.

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: two sentences plus optional args/returns. It front-loads the main action and usage constraint. Every sentence earns its place with no redundancy. This is an exemplary concise description.

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

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

Given the tool's simplicity (one parameter) and the presence of an output schema, the description covers the essential purpose and usage. It lacks detail on what 'rebuilds the deck container HTML' entails (e.g., does it delete previous content?), but for a straightforward finalization step, it is sufficiently complete. Score 4.

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 mentions the only parameter 'project_id' and states it is required, adding the modifier 'target' for context. The schema lacks parameter descriptions (0% coverage), so the description compensates minimally. However, it adds no additional meaning beyond the schema (type string, required). Score 3 is baseline for basic parameter mention.

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 ('Rebuilds the deck container HTML + full export') and context ('after visual QA fixes'). It distinguishes from sibling tools like ingest_visual_qa_fix and export_html, but does not explicitly differentiate from export_html or export_pptx, which are similar. A score of 4 is appropriate for clear purpose without explicit sibling 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 explicitly states when to use: 'Call ONCE after all fix iterations are done.' This provides clear context. However, it does not mention when not to use or alternatives, so it scores 4 rather than 5.

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

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

Describes the import process: reads PPTX, extracts design elements, creates new project, generates HTML preview. With no annotations, this adequately discloses core behavior, though some potential constraints (e.g., file size limits) are omitted.

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?

Compact yet comprehensive. Front-loaded with main purpose, followed by detailed behavior, post-import tool list, parameter descriptions, and return info. No wasted words.

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 input (file_path, project_id), process (extraction, project creation), output fields (JSON with project_id, num_slides, etc.), and follow-up tools. Missing edge cases like error handling, but overall sufficient for a complex 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 0%, but the 'Args' section gives clear explanations: file_path requires absolute path; project_id is auto-generated if omitted. This fully compensates for the schema's lack of descriptions.

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

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

Clearly states verb 'imports', resource 'PPTX file', and outcome 'converts to a design spec'. Distinct from sibling ingest tools by focusing on external PPTX files.

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?

Explains the tool's use case for importing PPTX files and lists subsequent tools to use. Does not explicitly exclude alternative approaches, but context is 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?

No annotations provided, so description carries full burden. It discloses that the tool saves the backfilled design_doc and returns available_components. However, it does not describe side effects, destuctiveness, auth needs, or error conditions. Basic behavior is clear but lacks depth.

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

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

One compact paragraph covering purpose, workflow, parameters, and return value. No wasted words; front-loaded with the main purpose and key workflow instruction.

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 workflow-specific tool: explains when to call, what it does, what it returns, and next action. Could add parameter validation info or error cases, but overall 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?

Input schema has 0% coverage, so description must add meaning. It describes each parameter: project_id as target project ID, slide_index as 1-based, backfill_json as client-generated. Adds some context but not full details like format or constraints.

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

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

Clearly states it ingests a design_doc backfill for an imported slide with stage='backfill'. The verb+resource is specific, and the description distinguishes it from siblings like `ingest_modify_component` by specifying this is the backfill step.

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

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

Explicitly says to call AFTER `prepare_modify_component` that returned stage='backfill' and explains the next step. Provides clear workflow context but lacks explicit when-not-to-use or alternative tools.

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

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

With no annotations provided, the description carries full burden for behavioral disclosure. It states that the tool saves DESIGN.md and returns a JSON with project_id and design_doc_path, but it does not mention side effects (e.g., overwriting behavior), permissions required, or whether the operation is reversible. This leaves gaps for an AI 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 concise: two sentences for purpose and sequence, then bullet-like args and return. Every sentence adds value without redundancy. It is front-loaded with the core action and usage hint.

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 moderate complexity (3 params, 2 required) and existence of an output schema, the description covers the essential: what it does, when to call, parameter details, and return shape. It could be improved by mentioning potential errors or idempotency, but the context is largely complete.

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

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

The input schema has 0% coverage, but the description adds meaning beyond the raw schema. It explains that draft_json contains 'theme + tone + page_requests' and comes from the client, and that color_theme is 'stored into the theme'. This helps the agent understand the parameter content and source, compensating for the schema's lack of detail.

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 'Ingests the client-generated DESIGN.md draft and saves DESIGN.md.' It specifies the action (ingest and save) and the resource (DESIGN.md draft/file). It also distinguishes itself from siblings by explicitly saying 'Call AFTER prepare_design_doc_draft', which ties it to a specific preceding tool.

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

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

The description provides clear context by stating 'Call AFTER prepare_design_doc_draft with the draft JSON you generated.' This indicates the correct sequence. It does not explicitly list when not to use it, but the temporal dependency is sufficient guidance.

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

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

With no annotations, the description details the internal operations (validate, normalize, save, render, lint) and the return fields. While side effects are implied but not fully detailed, this is a reasonable level of transparency for a tool lacking 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 well-structured with a summary, usage instruction, parameter list, return description, and workflow note. It is concise and front-loaded, with each sentence serving a purpose.

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

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

The description covers purpose, usage guidelines, parameter semantics, and return values, and provides workflow context relative to siblings. For a tool with an output schema, this is sufficiently complete for an agent to invoke it correctly.

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

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

Schema coverage is 0%, but the description compensates by explaining each parameter: required fields, 1-based slide_index, color theme options, and the nature of spec_json. This adds meaningful context beyond the raw schema.

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

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

The description clearly states the tool's purpose: 'Ingests the client-generated slide spec: validate, normalize, save, render, lint.' It also distinguishes its role in the workflow by referencing sibling tools like prepare_design_slide and finalize_design_spec.

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 instructs to 'Call AFTER prepare_design_slide' and 'After ingesting ALL slides, call finalize_design_spec once.' This provides clear sequencing and context for when to use the tool.

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 provided, so description carries full burden. It describes the process (validate, apply, save, render) and mentions returns (modified_element, slide_html_path, optional lint). It does not disclose destructive potential or auth needs, but for a mutation tool, it gives reasonable transparency.

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 very concise, with clear front-loading of purpose, a prerequisite note, argument list, return values, and a post-call instruction. No unnecessary words, well-structured.

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

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

Given the tool has 5 parameters (4 required), no enums, and an output schema, the description covers the essential workflow, arguments, and returns. It mentions the output schema fields and provides the critical instruction to share slide_html_path. Minor omissions: no error handling or edge cases, but overall adequate for this 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 coverage is 0%, so description must compensate. It lists parameters with basic explanations: project_id, slide_index, component_id, modify_json, color_theme. For modify_json, it specifies 'generated by the client' and for color_theme, provides allowed values ('dark' or 'light'). However, further details like modify_json format or constraints are missing, so it adds some but not comprehensive 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 clearly states it ingests a single-component edit with validate, apply, save, render steps. It specifies it works on exactly one element, distinguishing it from batch edits. However, it does not explicitly differentiate from sibling tools like ingest_slide_edit, but the prerequisite reference helps.

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 'Call AFTER a prepare_modify_component that returned stage="modify"', providing clear prerequisite. Lacks when-not-to-use or alternatives, but the context is well-defined.

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, description fully informs about the tool's behavior: validation, injection, saving, and the return format. Also notes the required user confirmation step, providing complete transparency for a non-destructive data ingestion.

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 concise, well-structured with clear sections for Args and Returns, and uses bold for important warnings. Every sentence adds value 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?

Given the tool's simplicity (2 params) and presence of output schema, the description provides all necessary context: workflow ordering, user interaction requirement, and error handling via re-call. No gaps.

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

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

Despite 0% schema description coverage, the description provides detailed explanations for both parameters, including source (project_id from prepare_outline) and expected format (outline_json matching a specific 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?

Description clearly states the tool's action: validates, injects presenter info, and saves outline JSON. It differentiates from siblings like prepare_outline by specifying it is called after preparation.

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 instructs to call after prepare_outline, highlights the need to show outline to user for confirmation before proceeding, and explains how to handle user requests for changes by calling again.

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 provided, so the description carries the burden. It discloses key behaviors: validates, returns issues, is report-only, and does not auto-regenerate. It also describes the return structure. However, it does not clarify whether the review is stored permanently or any side effects beyond reporting.

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

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

The description is front-loaded with purpose and usage, followed by args and returns. Each sentence is informative, but the first two sentences could be combined for slight conciseness. Overall efficient and well-organized.

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

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

Given the tool's simplicity (3 params, no annotations, output schema exists), the description covers key aspects: purpose, usage order, behavioral constraints, parameter meanings, and return fields. It could discuss error handling or more detail on review_json content, but it is largely complete.

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

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

Schema description coverage is 0%, so the description must compensate. It lists parameters with brief descriptions: project_id (required), slide_index (1-based), review_json (generated by client). This adds meaning beyond names but lacks detail on expected format or constraints for review_json.

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 verb and resource: 'Ingests a slide's review result: validate, return issues (report-only).' It distinguishes itself from siblings like prepare_review (which must be called first) and ingest_slide_edit (which applies edits), and provides context about its report-only nature.

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

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

Explicit guidance on when to use: 'Call AFTER prepare_review.' It also states what it does not do ('Does NOT auto-regenerate') and provides alternative action when has_high_severity: 'pass it into prepare_slide_edit(action="update")'.

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. It discloses that the tool validates, saves (insert for add), renders, and lints. It describes the return JSON fields. It does not detail error conditions or side effects beyond state modification, but the behavioral traits are sufficiently conveyed for a mutation tool.

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

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

The description is well-structured with a concise opening line, a clear usage instruction, bulleted parameter list, return details, and a highlighted follow-up. Every sentence adds value, and the critical information is front-loaded. No unnecessary text is present.

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 explains the return type with key fields, and the output schema exists to provide full details. It notes a required follow-up, which is crucial for the tool's workflow. Given the complexity of 5 parameters and the presence of many sibling tools, the description provides sufficient context to use the tool correctly, though it could briefly mention prerequisites like project existence.

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

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

Schema description coverage is 0%, so the description must compensate. It provides explicit explanations for each parameter: project_id as mandatory, action with values 'add' or 'update', slide_index as 1-based and same as prepare, spec_json as client-generated, and color_theme with default 'dark'. This adds significant meaning beyond the schema's minimal type/default 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 verb 'ingests an add/update slide spec' and the resource 'slide spec'. It lists the sequence of actions: validate, save, render, lint. It distinguishes from the sibling 'prepare_slide_edit' by explicitly stating to call it after that tool, making its role in the pipeline 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 explicitly instructs to call this tool 'AFTER prepare_slide_edit with the same action/slide_index and your spec JSON'. It also notes a required follow-up call to 'export_html'. While it does not explicitly state when not to use it, the context of sibling tools and the sequential instruction provide clear 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?

No annotations are provided, so the description must cover behavioral traits. It discloses validation, issue reporting, and that no fix is applied. However, it does not state whether the tool has side effects (e.g., storing data) or is idempotent, leaving some uncertainty.

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: two sentences of purpose, then bullet-pointed args and returns. Every sentence adds value, and key info 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?

Given that an output schema exists, the description adequately summarizes return values (has_issues, issues, overall_quality) and the workflow. It lacks details on storage or error handling, but overall provides sufficient context 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 0%, so the description fully documents parameters. It adds meaning: 'project_id' is Target project ID and required, 'slide_index' is 1-based, and 'analysis_json' is the client-generated JSON. This is clear and useful, though could detail the JSON structure.

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 the tool ingests client-generated analysis, validates it, reports issues, and explicitly says 'No fix applied.' It also mentions the correct preceding step (prepare_visual_qa_analysis), distinguishing it from sibling tools like prepare_visual_qa_fix.

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 workflow guidance: 'Call AFTER prepare_visual_qa_analysis' and 'If has_issues, call prepare_visual_qa_fix...' No ambiguity about when to use.

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 burden. It discloses validation, saving, re-rendering, restoration of images/slide_type, and re-running capture/analysis. It does not mention authorization or failure handling beyond status, but covers core behavior well.

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

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

The description is efficiently structured: a one-line summary, followed by usage guidance, then Args, then Returns. Every sentence adds value 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?

Given 3 required parameters, no enums, and presence of output schema, the description covers purpose, usage, parameters, and return values comprehensively. It is complete for an AI agent to understand and invoke correctly.

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

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

Despite 0% schema description coverage, the description's Args section adds meaning: project_id is required, slide_index is 1-based, fix_json is the corrected slide spec JSON. This goes beyond the bare schema.

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

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

The description clearly states the tool ingests a client-generated fix, with actions validate, save, re-render HTML. It distinguishes itself from the sibling 'prepare_visual_qa_fix' by specifying it should be called after that step.

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

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

Explicitly says 'Call AFTER prepare_visual_qa_fix', providing clear sequencing. Also mentions it restores LLM-unproducible content and re-runs verification up to max_iterations, giving context for when to use.

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 burden. It describes the directory check, returned fields, ordering, and source semantics. Lacks explicit mention of error handling (e.g., missing directory) but is otherwise transparent for a read-only list 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?

The description is well-structured with clear sections, including a 'When to use' block and return description. It is slightly verbose but front-loads the main action and uses bullet points for fields. Could be more concise without losing clarity.

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

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

Given no parameters and presence of an output schema, the description fully covers the tool's role: listing projects with field explanations, ordering, and how to interpret the source field. It fits seamlessly into the sibling tool ecosystem by providing pipeline 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?

The tool has no parameters, and schema coverage is 100% (trivially). The description adds no param info, but the baseline for zero parameters is 4. The description does not need to add param 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 clearly states that the tool retrieves the list of existing projects from a specific directory, includes detailed field information, and orders by recency. It distinguishes itself from sibling tools by positioning itself as the first call 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 provides explicit guidance on when to use the tool: 'Always call this tool first before starting the PPT generation pipeline.' It then outlines decision points based on results (no projects, existing projects, imported projects), offering clear 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?

With no annotations provided, the description carries the full burden. It discloses the return structure (design_spec_dir, slide_count, slide_files) and implies a read operation (load/retrieve). However, it does not mention error handling or side-effects, but the core behavior is transparent.

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

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

The description is concise, with two short paragraphs plus args/returns. It is well-structured, though the return section is slightly redundant. Overall, no wasted words.

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 output schema exists, the description provides adequate context: what the tool does, what it returns, and a hint about downstream usage. It could be more complete by clarifying its place in the workflow (e.g., after finalize_design_spec), but it is mostly 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?

The schema description coverage is 0%, so the description must add meaning to the parameter. It only repeats 'Project ID' and uses it in an example without elaborating on format or constraints. This adds minimal value beyond the schema.

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

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

The description clearly states the verb ('Loads'/'Retrieves'), the resource ('design spec'), and the scope ('from the project directory'). It distinguishes from sibling tools like load_outline and export_html/pptx by specifying it retrieves a previously generated PptxSlideSpec JSON.

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 hints at usage by mentioning project_id can be passed to export tools, but it does not explicitly state when to use this tool versus alternatives, nor does it provide when-not-to-use or prerequisites. The guidance is implicit and could be improved.

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 describes the return format (path, slide_count, optionally slides) but does not mention error handling, prerequisites, or whether the operation is read-only. This is adequate but leaves some gaps.

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

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

The description is clear but includes a docstring-style Args section that largely repeats the schema, making it slightly longer than necessary. The first sentence is efficient, but the rest could be condensed.

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 parameters and existence of an output schema, the description covers the main functionality and return values well. It could briefly mention error cases, but overall it is sufficiently complete for a straightforward loader.

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

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

With 0% schema description coverage, the description compensates well by explaining include_content's behavior (returns full content if True, else only path and count) and its default value, adding meaning beyond the schema's minimal titles.

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 loads a saved outline JSON from the project directory, and mentions its use as input for downstream tools like prepare_design_slide and export_html, distinguishing it from siblings like prepare_outline or save_outline_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?

It provides explicit context for when to use the tool by stating the loaded result can be used as input for other tools, but does not explicitly compare to alternatives like capture_slides or mention when not to use it.

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

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

No annotations exist, so description carries full burden. It explains the 'source' field meanings, details return value (JSON string including source), and implies a read-only operation. No hidden behaviors or 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?

Well-structured with a clear intro, detailed paragraphs for source field and imported projects, and explicit Args/Returns sections. No unnecessary words; every sentence adds value.

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 output schema exists, the description appropriately summarizes the return value. It covers purpose, parameter, and special usage instructions for imported projects, making it complete for this 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 coverage is 0%, so description must compensate. It adds an 'Args' section but only says 'project_id: Project ID', which is minimal. The parameter meaning is clear from context, but the description does not add much beyond the schema's title.

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 loads project status and metadata, listing specific items (topic, slide count, completion status). It distinguishes between generated and imported projects, providing unique value beyond the tool name.

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

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

Description provides explicit context for when to use: to check status before further operations. It gives specific instructions for imported projects to skip outline steps and use other tools, helping the agent decide when not to use this tool.

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 burden. It discloses atomic reordering of related files, no LLM call, and the need for a subsequent export. However, it does not mention potential side effects like undo ability or failure modes.

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

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

The description is well-structured with clear sections. It starts with the main action, then key notes, then Args and Returns. Every sentence adds value, no wasted words.

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 tool with 3 simple parameters and an output schema, the description covers the main purpose, parameter semantics, side effects, and required follow-up. It doesn't detail the output schema but states what fields are returned, which is 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 description coverage is 0%, so description compensates. It explains all three parameters, noting that indices are 1-based, which adds meaning beyond the schema types. No further constraints like valid ranges are given, but it's adequate.

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 'Moves a slide from one position to another' with a specific verb and resource. It also mentions it's a file reordering without LLM call, distinguishing it from siblings like delete_slide or export_html.

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

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

The description explicitly states a required post-action: 'After this call, you must call export_html to refresh HTML.' This provides clear usage context, but could be stronger on when to use this tool vs alternatives, though siblings are quite distinct.

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

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

No annotations are provided, so the description carries the full burden. It discloses that no LLM call is made, returns skip if DESIGN.md exists, and returns prompts. It also instructs the agent to generate the draft externally. However, it does not explicitly state side effects (e.g., whether it modifies any state), though it appears to be read-only.

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: purpose first, then behavior, then instruction, then args, then returns. It front-loads key info. However, it is somewhat lengthy and repeats parameter details that could be streamlined.

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 presence of an output schema (so return values are partially covered), the description adds preconditions (DESIGN.md existence), dependencies (loads outline from project), and a clear action for the agent (call ingest_design_doc_draft). It covers the tool's role in the workflow despite missing annotations.

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

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

Schema description coverage is 0%, so the description must compensate. It explains each parameter: project_id loads outline from saved project, color_theme with default 'dark', and outline_json as optional. It adds value by linking project_id to saved outlines and color_theme to dark/light options. However, the format of outline_json is not detailed.

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: 'Prepares the prompt for the CLIENT to draft DESIGN.md (design intent).' It distinguishes from siblings like 'ingest_design_doc_draft' by explicitly instructing to call this once before generating slides and then use its output to call the ingest tool.

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

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

The description provides clear usage context: call this 'ONCE before generating slides' and what to do if DESIGN.md already exists (returns skip). It also guides the agent to generate the draft and call ingest_design_doc_draft. However, it does not explicitly list when not to use it or mention 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?

Although no annotations are provided, the description discloses key behavioral traits: no LLM call, returns a prompt and schema, and slides are independent for parallel execution. This fully informs the agent of the tool's safe, non-destructive role.

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-loads the core purpose and key constraint ('No LLM call'), but the description is slightly verbose with the 'Returns' list and could merge some lines without losing clarity.

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

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

Given no annotations and an output schema listed but not detailed, the description sufficiently covers the tool's role in the pipeline, its dependencies (prepare_design_doc_draft), and the expected output fields, making it fully actionable 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?

The description adds meaning beyond schema names by explaining each parameter's role (e.g., slide_index is 1-based, outline_json optional, total_slides default infers). However, it does not specify the JSON format for outline_json or validate constraints, leaving some ambiguity.

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

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

The description clearly states it prepares the prompt and JSON schema for generating one slide's design spec, distinguishing it from related sibling tools like ingest_design_slide and prepare_design_doc_draft.

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 instructions to generate the slide spec JSON conforming to response_schema and then call ingest_design_slide, plus guidance on parallelization across slides and ordering relative to prepare_design_doc_draft.

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 description carries full burden. It discloses that no LLM call is made, describes the return object with stage field, and explains the two-stage workflow including backfill process. Lacks details on error handling or idempotency but covers main behavioral traits.

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 moderately long but well-structured with clear sections. The opening sentence is direct, followed by usage context and then parameter list. A bit wordy in the stage explanation but efficient overall.

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 5 parameters, no annotations, and presence of output schema (not shown), the description explains the return JSON structure and workflow stages. It provides enough context for an agent to use the tool correctly, but could include more about possible stage values and error scenarios.

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

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

Schema coverage is 0%, so description compensates by listing each parameter with brief semantic descriptions (e.g., '1-based slide position', 'Natural-language description of the change'). Adds useful context beyond schema but could provide more constraints or examples.

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 prepares a narrow single-component edit on a content slide, using specific verbs and resource. It explicitly distinguishes from sibling `prepare_slide_edit` by noting the broader scope of that tool.

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 when-to-use (narrow changes like 'make the LLM box red') and when-not-to-use (broader changes, use `prepare_slide_edit`). It also explains the two possible stages and subsequent actions needed for each.

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

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

With no annotations, the description fully explains what the tool does (normalize inputs, create/load project, save metadata, return prompts and schema) and what it does NOT do (LLM call). It could mention side effects like overwriting existing project data, but the detail is high.

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 well-structured with sections (main purpose, important notes, args, returns, next step). Despite length, every sentence adds value. Front-loaded with key 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 9 parameters (1 required), no annotations, and an output schema, the description covers workflow, user confirmations, output format, and next step. It leaves no ambiguity for the 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 has 0% description coverage, but the description provides detailed semantics for each parameter, including user confirmation requirements for key parameters (purpose, audience_type, presentation_minutes, etc.). This adds meaning far beyond the schema defaults.

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 prepares prompts and schema for outline generation, explicitly says it does NOT call an LLM, and distinguishes from sibling `ingest_outline` by specifying this tool is for preparation and the client generates the outline.

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

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

Description provides explicit required checks before calling, listing four items to confirm with user. It also gives a clear next step: generate outline JSON and call ingest_outline. This guides the agent precisely on when and how to use the tool.

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 that no LLM call is made and describes the return format (review prompt + response_schema). Without annotations, this is helpful but could mention mutability or side effects. The description is straightforward about its non-destructive nature.

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?

Highly concise with two well-structured paragraphs covering purpose, usage, arguments, and return. Uses formatting (bold, bullet-like) to highlight key points. Every sentence adds value 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?

Given the tool's simplicity (2 required params, clear output schema), the description covers all essential aspects: purpose, output format, workflow integration (call ingest_review), and parallelization hint. No gaps are apparent.

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 crucial details: project_id as 'Target project ID' and slide_index as '1-based slide position'. Since schema had 0% description coverage, this fully clarifies the parameters' meaning and usage.

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 it prepares a design-rule review for ONE slide, distinguishes it from other 'prepare_*' siblings by specifying the review focus and mentioning mechanical lint. It also directs to call ingest_review, clarifying its role in the workflow.

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 instructions: generate review JSON then call ingest_review, and suggests reviewing slides in parallel. Does not explicitly state when not to use or compare to alternatives, but the context implies it's the only tool for this task.

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 key behaviors: no LLM call, shifts files for add, updates outline, returns prompt and response_schema. Lacks explicit mention of side effects or permissions, but overall good transparency.

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?

Well-structured: summary, usage guidance, parameter list, return value. Front-loaded purpose, every sentence adds value. No fluff.

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

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

Complete coverage: explains what tool does, how to use, parameter details, return value, and next step (ingest_slide_edit). Output schema exists but description still covers return JSON.

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?

All 9 parameters are described with defaults, allowed values, and conditional requirements. The schema has 0% description coverage, so the description fully compensates and adds significant meaning.

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 prepares to add or update one slide, updating outline and returning a generation task. Distinguishes from sibling by naming prepare_modify_component for narrow tweaks.

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 (add/update slide) and when not (use prepare_modify_component for single-element tweaks). Also provides conditional requirements for title and content_summary.

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 burden. It states 'No LLM call' and describes the return structure, but does not disclose potential side effects or idempotency. The lack of destructive/readOnly hints makes the behavioral transparency adequate but not thorough.

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

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

The description is concise and well-structured: a summary sentence, an important instruction in bold, and an Args section with bullet points. No fluff; every sentence adds value.

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 presence of an output schema, the description explains the return fields (system_prompt, user_prompt, response_schema, images, etc.) and the workflow (analyze in parallel, then call ingest). It is nearly complete, though could elaborate on 'analyze against the spec'.

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

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

Schema coverage is 0%, so the description compensates by explaining each parameter: project_id (required), slide_index (1-based position), iteration (default 0). This adds meaning beyond the bare schema. Could include valid ranges or constraints but suffices.

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 prepares the vision analysis task for one slide, explicitly notes 'No LLM call', and instructs the agent to read the screenshot, analyze, and call ingest_visual_qa_analysis. This differentiates it from sibling prepare_* tools by specifying its scope and next 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 tells when to use this tool (after capturing slides, before ingesting analysis) and advises to analyze slides in parallel. It explicitly mentions calling ingest_visual_qa_analysis next. It does not provide explicit when-not-to-use scenarios, but context is clear enough among siblings.

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

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

With no annotations, the description carries full burden. It explicitly states 'No LLM call.', which is a key behavioral trait. It discloses that the tool returns a fix prompt, response schema, and images, and that the agent must generate full slide spec JSON before calling the ingest tool.

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

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

The description is concise, around 10 sentences, front-loaded with purpose and key return info. The 'Args' section is well-formatted. It could be slightly more structured by separating input and output, but it's efficient and readable.

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 4 parameters, no annotations, and an output schema (not shown), the description covers inputs, outputs, and workflow context (next step). It mentions the return structure but does not detail the output schema fields, which is acceptable since output schema exists. Minor gap: no mention of prerequisites or errors.

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

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

Schema description coverage is 0%, so the description must compensate. It does: each parameter is explained with context (e.g., 'issues_json: JSON array of issues from ingest_visual_qa_analysis', 'slide_index: 1-based slide position', 'iteration: Iteration counter matching the capture'). This provides full semantics beyond the bare schema.

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

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

The description clearly states 'Prepares the fix task for a slide with detected issues.' It uses a specific verb (prepares) and resource (fix task for a slide), and implicitly distinguishes from the sibling tool 'ingest_visual_qa_fix' by explicitly instructing to call that tool afterward.

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 after 'ingest_visual_qa_analysis' through the 'issues_json' argument, but does not explicitly state when to use this tool versus other prepare tools like 'prepare_visual_qa_analysis'. It provides the next step but not 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?

Discloses overwrite behavior and return value, but lacks details on prerequisites (e.g., project existence) and error conditions. No annotations to contradict.

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?

Well-structured with sections, bullet points, and code examples; no wasted sentences despite thoroughness.

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 usage flow, return value, and parameter details, but does not address error handling or prerequisites like project existence.

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?

All 8 parameters are described with meaning, examples, and defaults in the 'Args' section, fully compensating for zero schema description 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 'Saves (overwrites) a single slide outline to the project' and distinguishes from sibling tools like prepare_slide_edit by specifying when to use each.

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 provides when to use (before prepare_slide_edit for updates) and when not to (use prepare_slide_edit directly for additions), with step-by-step instructions.

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