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

Annotations already indicate this is a write operation (readOnlyHint=false) with possible side effects. The description adds key behavioral details: the operation is free, maintains order, and does not invoke the costly Extend feature. These go beyond what annotations provide.

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

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

The description is two sentences, front-loaded with the essential action, and every sentence adds value. There is no redundancy or unnecessary information.

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

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

For a simple one-parameter tool with annotations, the description is fairly complete. It explains the action, cost, and a key distinction from Extend. It implicitly assumes an open scene, which is clear from the title and first sentence. Missing details like error handling are not critical given the 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 input schema covers 100% of the parameter, describing it as 'Clip media ids, in the order they should appear'. The description reinforces this by stating 'in order' and specifying the source as 'library clips', adding slight additional semantic value.

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

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

The description uses a specific verb ('Add') and resource ('library clips' to 'open scene'), clearly stating what the tool does. It also distinguishes from the sibling 'Extend' feature, which is mentioned explicitly.

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

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

The description provides context on when to use the tool (adding clips in order to the current scene) and explicitly states that it does not use the Extend feature, which has a cost. However, it does not compare with other sibling tools like flow_create_scene or flow_export_scene.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint. The description adds specific behavioral context (what data is returned: endpoints, shapes, transport tier). No contradictions.

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

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

Single sentence, front-loaded, no redundant information. 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 read-only tool with one optional parameter and no output schema, the description completely explains the return value (endpoints, shapes, transport tier). Low complexity but fully adequate.

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

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

Schema coverage is 100% with a well-described parameter (response_format). The tool description adds nothing beyond the schema, so baseline 3 is appropriate.

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

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

The description clearly states the tool returns tRPC endpoints previously learned by flow_discover_api, with input/output key shapes and transport tier. It distinguishes from sibling flow_discover_api (learning vs reading).

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?

Implicit usage context (after flow_discover_api) is clear, but no explicit when-not or alternatives are mentioned. The description does not exclude misuse.

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

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

The description discloses behavioral details beyond annotations: the ceiling is enforced before every approval, causing rejection and no charge if exceeded. It also warns about authorization needs for raising the ceiling. Annotations indicate idempotent hint true, but description adds enforcement and authorization context.

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

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

Two sentences with no fluff: first sentence states purpose, second adds critical behavioral context. It is appropriately sized and front-loaded, earning its keep without unnecessary 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 simple tool with 3 optional parameters and no output schema, the description covers main behaviors (reading, setting, enforcement, authorization). It omits details on reset_spend action but overall is sufficient given annotations and schema descriptions.

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 67% (ceiling and response_format have descriptions). The description adds minimal parameter details beyond the schema, simply stating 'read or change'. It does not elaborate on action values or parameter usage beyond what the schema provides.

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 reads or changes the credit budget, specifying 'credit ceiling and spend'. It distinguishes from sibling tools like flow_estimate_cost (estimates cost) and flow_ledger (ledger entries) by focusing on budget management. The phrase 'Raise it only on explicit instruction from whoever owns the account' adds a critical usage caveat.

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 the tool (to read or change budget) and includes a caution about raising the ceiling only on explicit instruction. However, it does not explicitly state alternatives or when not to use this tool compared to siblings like flow_estimate_cost.

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

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

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds context by listing exactly what is checked (browser, sign-in, balance, etc.) and reaffirms that no charges occur. This provides valuable detail beyond annotations.

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

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

Two sentences with no wasted words: first lists reported items, second gives usage instruction. Information is front-loaded and every sentence is valuable.

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 optional parameter, read-only), the description fully covers purpose, usage, and behavior. No output schema exists, but the description implies a report format aligned with response_format. Completely adequate for an agent to select 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?

With 100% schema coverage, the single parameter (response_format) is well-documented in the schema. The description adds no additional meaning beyond what the schema already provides: 'markdown for reading, json for programmatic use.' Baseline 3 is appropriate.

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

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

The description clearly states the tool reports on Google Flow reachability and safety, listing specific checks (browser, sign-in, balance, project, 'Confirm before generating' gate). This distinguishes it from sibling tools that perform actions like generating or mapping.

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 'Call this first in any Flow session,' providing clear when-to-use guidance. Also notes 'Never charges,' helping agents decide to use it before credit-related operations.

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 explains the core behavior (wait and download) and cost. Annotations indicate non-idempotent, non-destructive, and open-world. The description aligns with these, but it doesn't detail polling behavior or error states. No contradiction.

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

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

Two sentences: the first states what the tool does, the second provides usage context and cost. No wasted words, front-loaded, and very efficient.

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

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

Given no output schema, the description adequately explains the action (wait and download) and input parameters. It could mention the return value (downloaded file path) but is otherwise sufficient for an agent to use 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 100%, and the description adds meaningful context: known_media_ids are 'media ids that existed BEFORE the batch was submitted' and out_dir is a 'Subdirectory under FLOW_OUTPUT_DIR'. This goes beyond the schema descriptions.

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

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

The description clearly states the tool's function: wait for new media (not in known_media_ids) and download it. It distinguishes itself from siblings by explicitly positioning it as a follow-up to flow_generate_video with no_wait=true, which is unique among the sibling tools.

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

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

The description gives explicit when-to-use context: after submitting a parallel batch with flow_generate_video(no_wait=true). It also notes the cost implication ('Charges nothing'). However, it does not explicitly state when not to use it or list alternatives, though the context is strong enough.

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

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

Annotations indicate not read-only, not idempotent, open-world. Description adds that the tool is free and that it breaks chat carry-over, a behavioral side effect beyond what annotations convey. No contradiction.

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

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

Two succinct sentences, front-loaded with purpose, no filler. 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?

Low complexity tool with one optional parameter and no output schema. Description covers purpose, usage guidance, and a behavioral trait. Adequate for an agent to decide when to invoke.

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?

Only one optional parameter 'name' with schema description 'Optional project name'. Tool description adds no further nuance; schema coverage is 100%, so baseline 3 is appropriate.

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

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

Clearly states it creates a new Flow project, with a specific verb and resource. Distinguishes from siblings like flow_open_project by emphasizing fresh start to break carry-over chat anchors, which is a unique differentiator.

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 recommends using this tool per batch to avoid carry-over effects, providing clear context. Lacks explicit when-not-to-use or alternatives, but the advice is strong and actionable.

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

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

Annotations provide readOnlyHint=false, openWorldHint=true, idempotentHint=false, destructiveHint=false. The description adds only 'FREE' which is minor. It does not disclose side effects, return values, or any behavioral details beyond the annotations, leaving the agent without important context about state changes.

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

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

The description consists of two short sentences that pack purpose and a key usage note with no fluff. Every sentence adds value, achieving maximum conciseness.

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

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

Given zero parameters and no output schema, the description is minimally adequate. It lacks information about what the tool returns (e.g., scene ID) or what 'Scenebuilder scene' means, which could leave an agent uncertain about how to use the result.

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

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

The input schema has zero parameters, so schema description coverage is 100%. Baseline is 4 per guidelines. The description adds nothing about parameters, but there are none to describe.

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 'Create' and resource 'Scenebuilder scene' with purpose 'for stitching clips'. The sibling tools include other scene-related actions like flow_export_scene and flow_add_clips_to_scene, making this tool's purpose distinct.

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 statement 'Flow's chat agent cannot do this — it is a UI-only surface' provides clear context that this tool is the only way to create scenes programmatically, giving a strong when-to-use indication. It lacks explicit when-not or alternative tool comparisons, but the context is valuable.

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 emphasizes permanence and irreversibility, adding the useful detail that a deleted clip 'cannot be reliably re-added to a scene'—beyond the destructiveHint annotation. No contradiction with annotations.

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

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

Two concise sentences, front-loaded with the core action, followed by a critical warning. 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 simple delete operation with one parameter, strong annotations, and no output schema, the description covers all essential context: what it does, when to use it, and behavioral implications.

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 100% schema description coverage for the single parameter (media_ids), the tool description adds no further semantic value. Baseline 3 is appropriate.

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

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

The description clearly states the action ('permanently remove') and the resource ('media from the Flow project library'), distinguishing it from sibling tools like flow_list_media and flow_upload_media.

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

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

The description advises to delete only what has been 'explicitly ruled out,' providing clear context. However, it stops short of naming specific alternatives or conditions when not to use.

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

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

Annotations already declare readOnlyHint and destructiveHint. Description adds valuable context: 'submits nothing and charges nothing', 'Only endpoint shapes are stored; no prompts, media, or tokens.' No contradictions.

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

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

Four sentences with no wasted words. Each sentence serves a purpose: purpose, safety, when-to-use, data limits. Well 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?

Lacks information about return value or success/failure signals. Since no output schema, description should clarify what the tool returns (e.g., success status or map reference). Adequate but incomplete.

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 100% description coverage for both parameters. Description adds usage guidance but no additional parameter specifics beyond schema. 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?

Description clearly states verb 'Record' and resource 'tRPC endpoints' with outcome 'write a reusable API map'. Explicitly distinguishes from siblings like flow_api_map by stating it writes the map rather than reads it.

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

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

Explicitly states when to run: 'after any Flow redeploy, or when another tool reports a 404 on a procedure'. Provides clear context but could explicitly name flow_api_map as alternative for reading.

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

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

Annotations already indicate it's not read-only (readOnlyHint false), not destructive (destructiveHint false), and idempotent (idempotentHint true). The description adds context about writing to disk, verifying file types, and no charges. No contradictions.

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

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

Two sentences, each serving a distinct purpose: first explains the action, second provides usage guidance. No redundant or filler content. Information 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 the tool's simplicity (2 parameters, no output schema, rich annotations), the description covers the core behavior, usage recommendation, and important behavioral traits. It feels complete for an AI agent to decide when and how to invoke it.

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

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

Schema coverage is 100% with descriptions for both parameters. The description adds extra meaning: 'Media id from flow_list_media' for media_id and 'relative paths resolve under FLOW_OUTPUT_DIR' for out_file, providing useful context 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 resolves a media ID to a signed CDN URL and writes bytes to disk, verifying the file type. This specific verb+resource combination distinguishes it from sibling tools like flow_list_media or flow_delete_media.

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

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

The description explicitly recommends using this tool over Flow's Download button due to reliability issues in automated profiles. It also mentions 'Never charges,' providing cost context. While not covering when not to use it, the guidance is clear and helpful.

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

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

The description adds key behavioral traits beyond annotations: it costs exactly zero, a rejected proposal is never charged, and it involves submitting and rejecting a request. The readOnlyHint annotation is consistent with this, and the description provides valuable context about the transient nature of the proposal.

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, each carrying weight: first explains the action, second explains the benefit and use case. It is front-loaded with the critical info and wastes no 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 tool's simplicity (1 param, no output schema, clear annotations), the description fully explains the workflow and outcome. It covers what the tool does, how it works, and why to use it, leaving 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?

The lone parameter 'prompt' has full schema coverage (100%) with maxLength and minLength constraints. The description adds that the prompt is what you intend to run, but this adds little beyond the schema description. Baseline 3 is appropriate.

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

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

The description clearly states the tool's purpose: submit a request, read the quoted cost, then reject it to avoid charges. It uses specific verbs ('submit', 'read', 'REJECT') and identifies the resource (cost estimation). This distinguishes it from siblings like flow_budget or flow_ledger, which deal with budget management, not zero-cost estimation.

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 context: 'Use this to confirm the project's model tier before committing to a batch.' It implies when to use (pre-commitment check) and that it costs zero. However, it doesn't explicitly mention when not to use it or list alternatives, but the sibling tools are available for actual generation.

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

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

Annotations already include readOnlyHint=false and destructiveHint=false. The description adds valuable context: credit behavior (stitching free, never uses costly Extend) and that the tool captures the export payload directly because Flow's export doesn't write a file. This goes beyond annotations, though it omits potential side effects like job creation or state changes implied by readOnlyHint=false.

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: four sentences, each serving a distinct purpose (purpose, cost, credit behavior, technical detail). It is front-loaded with the core action and does not waste 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?

For a tool with 2 parameters, no output schema, and simple behavior (export scene to file), the description is mostly complete: purpose, cost implications, and technical nuance. It lacks explicit error handling or prerequisites (e.g., scene must be open, file write permissions), but the title partially covers the prerequisite. Overall adequate.

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

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

Schema coverage is 50% (only out_file has a description). The description adds no information about parameters beyond the schema, failing to explain timeout_seconds or provide usage examples. With low schema coverage, the description does not compensate, leaving the agent to infer parameter behavior from the schema alone.

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 'Export' and the specific resource 'currently open Scenebuilder scene' with output format 'MP4 on disk'. It distinguishes from siblings like flow_generate_video by specifying the source (open scene) and adds context about no credit cost for stitching, making the purpose 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 implies when to use (export the open scene) and notes that stitching is free and Extend is never used, providing cost guidance. However, it does not explicitly contrast with other tools like flow_generate_video or state prerequisites (e.g., the scene must be open). It gives clear context but lacks explicit 'when not to use' or alternative tool references.

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

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

Annotations already indicate non-idempotent, non-destructive write. Description adds valuable context: 'costs ZERO credits', 'downloads results', 'returns local file paths'. No contradiction with annotations.

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

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

Two sentences, 35 words. Every sentence adds value: purpose, cost, usage guidance, output format. No 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?

Covers purpose, behavior, usage context, and output. Lacks mention of prerequisites (e.g., open project) or error handling, but sufficient for a simple tool with good 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 covers 67% of params with descriptions; description adds minimal new meaning beyond schema. The 'full composition prompt' hint is already in schema. No param-specific elaboration.

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?

Specifically describes generating still images, emphasizes zero credit cost, and explicitly frames it as a composition sandbox before video. Differentiates from sibling `flow_generate_video` by cost and iteration purpose.

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 advises 'always compose in stills before spending anything on video', providing clear when-to-use guidance. Does not explicitly state when not to use but context implies avoiding for final output.

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?

Adds significant context beyond annotations: real credit spending, cost rejection mechanism, mode switching effect on prompt, warning against duplicate charges, and setting reminders. No contradiction with annotations (destructiveHint=true is consistent).

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 thorough but not overly verbose; every sentence serves a purpose. It could be slightly more streamlined, but the complexity (multiple modes, cost logic) justifies the length.

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 creation logic, cost, mode selection, duplicate handling, and directs settings elsewhere. Lacks explicit return value description, but the mention of 'Collect later with flow_collect' implies asynchronous return. No output schema exists, so this is acceptable.

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 high (88%), but the description enriches understanding by explaining how parameters interact (e.g., start_frame vs reference_media_ids switch modes and change prompt semantics), clarifies expected_max_cost role, and details no_wait usage for parallel batches. Adds meaningful value beyond schema descriptions.

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

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

The description clearly states 'Generate a video clip in Flow' and distinguishes three modes (Frames-to-Video, Ingredients-to-Video, Text-to-Video) based on which parameters are attached. It also suggests composing stills first, effectively differentiating from sibling tools like flow_generate_still.

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 tells when to use (generating video with cost checking against expected_max_cost and budget) and when not to (avoid duplicate calls, set model tier and aspect ratio via flow_settings, not here). Recommends an alternative workflow: compose in stills first then animate.

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

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

Annotations already declare read-only and idempotent behavior. The description adds value by specifying the content (prompt, costs, verdict, files) and noting it's an append-only log, which helps the agent understand the tool's nature without contradicting annotations.

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

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

Two sentences efficiently convey the tool's purpose and key details. The first sentence is dense with specific information, and the second adds context. No redundant or vague phrasing.

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 what the tool returns but omits details like pagination, ordering, or how to interpret the data. With no output schema, more context about the response structure would improve completeness.

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 50%, with only response_format having a description. The tool description does not mention or clarify parameters. The schema itself provides good constraints for limit and response_format, so baseline is acceptable but no extra value from the description.

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

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

The description clearly states the tool returns an append-only log of generation attempts with specific fields like prompt, cost, and verdict. It identifies the resource and action, though it does not explicitly distinguish from sibling tools.

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

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

No guidance on when to use this tool versus alternatives like flow_budget or flow_estimate_cost. The description implies it's for auditing spend, but lacks explicit usage context or exclusions.

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

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

Annotations already indicate readOnlyHint, idempotentHint, and non-destructive. The description adds that listing is free and warns that running apps may incur unquoted charges, providing valuable behavioral context beyond annotations.

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

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

Two sentences, front-loaded with purpose. The list of examples is helpful but slightly verbose; could be tightened. Still efficient and clear.

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

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

Tool has one optional parameter, no output schema, and rich annotations. Description covers purpose, free nature, and cost warning. No missing critical info for a simple list operation. Slight gap on pagination or limits, but not essential.

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 one parameter with full coverage (description and enum). The description does not add extra meaning beyond what the schema provides, so 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 tool lists mini-apps in the current project's Tools gallery, providing specific examples to illustrate the resource, which distinguishes it from sibling tools like 'flow_open_app'.

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 mentions 'Listing is free' and a warning about costs, but it does not explicitly guide when to use this tool versus alternatives (e.g., when to list vs. open an app). Usage context is implied but not contrasted with 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?

Annotations already indicate readOnly, openWorld, and idempotent hints. The description adds the behavioral trait 'Never charges,' which is beyond annotations. However, it omits details on pagination or sorting.

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

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

Two sentences, no wasted words. The first sentence immediately conveys the primary action and resource, and the second adds a valuable note. Front-loaded and efficient.

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

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

Given no output schema and 3 parameters, the description adequately explains the tool's main purpose but does not cover pagination behavior or the effect of response_format. It is minimally viable.

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 33%, and the description does not explain the limit, offset, or response_format parameters. It only hints at the output containing IDs. The description fails to compensate for low coverage.

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

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

The description clearly states the tool lists media in the current Flow project and specifies that IDs are usable by flow_download and flow_delete_media. It distinguishes from sibling tools by noting the output's utility.

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 before downloading or deleting media, but does not explicitly state when not to use or provide alternatives. It does note the tool never charges, which is a usage assurance.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds that the tool is free and lists only visible projects on the current page, providing additional context beyond annotations.

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

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

Two concise sentences, no wasted words. Front-loaded with the action verb 'List' and immediately conveys the tool's 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?

For a simple listing tool with one optional parameter and comprehensive annotations, the description is complete. It explains the scope (current page) and relevance (per-project isolation via ids), 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 coverage is 100% (one parameter with full description in schema). The tool description does not add any further meaning about the parameter beyond what the schema provides, so baseline score is appropriate.

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

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

The description clearly states the tool lists Flow projects visible on the current page with their ids, and explains why knowing the id matters (per-project settings/media libraries). This distinguishes it from sibling tools like flow_create_project or flow_open_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 implies usage for listing projects and obtaining ids, but does not explicitly state when to use this tool versus alternatives like flow_list_media or flow_list_apps. No 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?

Discloses important behaviors beyond annotations: cost unknown, potential Veo calls, hands control to human, does not drive forms. Credit balance monitoring noted. No contradiction with annotations (readOnlyHint=false, destructiveHint=true align with description).

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?

Four sentences with no filler. First sentence states primary action, subsequent sentences explain critical requirement and rationale. Efficiently packed with necessary detail.

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

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

Given no output schema, description adequately explains behavior and risks. Could briefly mention what happens after app opens (e.g., returns control to human), but current text implies it. Complete for safety-critical 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% with descriptions for both parameters. Description adds crucial context: `app_name` validity (must be from flow_list_apps) and `acknowledge_unknown_cost` must be true with reasoning. Enhances schema 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?

Clear verb ('Open') and resource ('Flow's Tools-gallery apps') with specific action of handing control to human. Distinct from siblings like flow_list_apps (listing) and flow_generate_video (generation).

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 requirement for `acknowledge_unknown_cost=true` due to unquoted prices and potential internal Veo calls. Contrasts with blindly driving the app's own form, explaining when not to use it. Provides clear context on charge risk.

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

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

Beyond annotations (idempotent, non-destructive, open world), the description adds that the operation is free and that settings are per-project, requiring a re-read. This contextualizes behavior beyond what annotations provide.

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

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

The description is two sentences, front-loaded with the primary action, and includes a crucial caveat without excess. Every sentence serves 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?

For a simple tool with one required parameter and no output schema, the description covers the core action and a key behavioral note. It does not mention error cases, but the tool is straightforward enough that this is acceptable.

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 100% coverage and describes the parameter as 'Project id from flow_list_projects'. The description reinforces this by mentioning the source function, adding value over 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 action 'Switch the browser to a Flow project by id' with a specific verb and resource. It also notes that the action is free, and the tool's purpose is distinct from siblings like flow_open_app.

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 guidance to re-read flow_settings after switching due to per-project settings, which helps the agent avoid assuming tier continuity. However, it does not explicitly state 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?

Beyond annotations, description adds key behaviors: changes are free (cost impact), settings persist across turns, and suggests re-reading after switching projects. No contradiction with annotations.

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

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

Four sentences with clear front-loading of purpose, followed by persistence and cost example. No redundant information; each sentence 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?

Given 6 parameters and no output schema, description covers purpose, persistence, cost, and usage hint. It lacks guidance on when to use get vs set, but schema provides action parameter.

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

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

Schema covers 83% of parameters with descriptions; description adds value by explaining persistence and cost implications but does not detail each parameter 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?

Description clearly states the tool reads or changes project generation settings, with specific items: model tier, aspect ratio, outputs per prompt. Differentiates from sibling tools by focusing on project globals rather than generation or media management.

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 context that settings are project globals and persist across chat turns, aiding when to use. However, it does not explicitly exclude other tools or give alternatives, leaving some ambiguity.

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

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

Annotations already indicate a mutation (readOnlyHint=false) and not destructive (destructiveHint=false). The description adds 'Free' and a post-upload step, but lacks details on file limits or overwrite 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?

Two sentences with the purpose front-loaded and no redundant 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?

For a simple upload tool with one parameter and no output schema, the description adequately covers purpose and next steps, though it omits potential constraints like file size or formats.

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 100% coverage on the single parameter 'file_path' with a clear description. The tool description does not add further 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 it uploads a local image file into the Flow project for use as a start frame or reference, distinguishing it from sibling tools by mentioning confirmation with flow_list_media.

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

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

The description provides a usage step (confirm media id) and notes it is free, but does not explicitly state when to use this tool over alternatives or include when-not conditions.

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

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

Description discloses that 4K upscale bypasses the quote gate, is charged directly, and verified against balance. This adds significant context beyond annotations (destructiveHint=true, readOnlyHint=false). No contradictions.

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

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

Two sentences plus a note, all front-loaded and essential. 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 purpose, usage, behavioral traits, and parameter context. No output schema, so return values not needed. Adequately complete for an agent to select 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?

Schema coverage is 67% (media_id and acknowledge_4k_cost have descriptions; target is enum). Description adds meaning: explains cost and plan requirements for 4K, and that 1080p is free. Complements schema well.

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 title 'Upscale a clip' and description 'Upscale a generated clip' clearly state the tool's action and resource. It distinguishes from sibling tools like flow_generate_video and flow_download by focusing on upscaling.

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 advises using 1080p (free on paid plans, always taken at download) and notes 4K is rarely worth it for social content. It implies when to use but doesn't explicitly state when not to or list alternatives.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, idempotentHint=true, and openWorldHint=true. The description adds value by explaining why mutations are excluded (charging concerns) and the performance benefits (faster, parallelizable). No contradiction with annotations.

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

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

The description is two sentences with no wasted words. The first sentence states the main action and benefit, and the second adds a critical constraint. It is front-loaded and efficient.

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

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

For a simple tool with one parameter and no output schema, the description is fairly complete. It explains the purpose, the input source, and the behavioral constraint. However, it could briefly mention the return value or success criteria, though not critical.

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 100% coverage with a clear description for the only parameter 'procedures' ('Procedure names from flow_discover_api'). The tool description references 'discovered read-only GET endpoints' but does not add further semantic details beyond the schema, so baseline 3 applies.

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

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

The description clearly specifies the verb 'Test whether discovered read-only GET endpoints work' and the resource 'read-only GET endpoints from Node with the browser's cookies alone'. It distinguishes from sibling tools like flow_discover_api by explaining the verification purpose and the benefit of skipping pages.

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 that mutations are never tested due to cost implications, providing a clear when-not-to-use scenario. It implies that endpoints should be discovered via flow_discover_api first, but does not explicitly contrast with other sibling tools for when to use this versus alternatives.

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