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 only says 'Verify' but does not disclose what happens on success/failure, whether it returns a boolean, throws an error, or has side effects. For a check tool, this lack of behavioral detail is a significant gap.

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

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

The description is a single, well-structured sentence with leading verb and no fluff. It conveys the core purpose efficiently without wasting 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 is simple with no parameters and no output schema, the description is partially complete. It explains what it does but not what the agent should expect as a result (e.g., does it return a Boolean, throw an exception, or print a message?). The mention of 'Default' also lacks context about how the expected email is configured, leaving some ambiguity.

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 zero parameters, so the description does not need to explain any. The baseline for 0 params is 4, and the description correctly avoids adding unnecessary parameter details since the schema is empty.

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

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

The description clearly states a specific action (verify) and the exact subject (logged-in Google account) against an expected configured email. This distinguishes it from sibling tools like flow_status or flow_connect, which have different purposes.

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

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

The description implies the tool is used to ensure the correct Google account is active, but it does not explicitly state when to use it versus alternatives. For example, it doesn't mention using it after flow_connect or before other operations. Usage context is implied rather than stated.

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

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

With no annotations, the description carries the burden. It discloses the main side effect (launching Chrome) and the steps performed, but lacks detail on whether the connection is persistent, what happens on verification failure, or whether the browser closes after the operation. This is moderate transparency but not complete.

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

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

The description is a single sentence that packs four specific actions without fluff. It is front-loaded with the primary action ('Launch Chrome') and efficiently communicates the full flow.

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

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

The description does not mention return values (no output schema exists) or the fact that this tool likely establishes a required connection for other flow_* tools. Without annotations, it could benefit from noting that it is a prerequisite and what 'verify account' entails. This is adequate but not fully complete.

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

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

Schema description coverage is 100%: both 'headless' and 'open_flow' have clear descriptions in the schema, including a warning about headless mode. The tool description does not add additional parameter semantics, but since the schema already covers them, a baseline score of 3 is appropriate.

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

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

The description clearly states the tool's specific actions: launching Chrome, connecting CDP, navigating to Google Flow, and verifying the account. It distinguishes itself from sibling tools like flow_disconnect or flow_status by focusing on the connection setup.

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 does not provide explicit guidance on when to use this tool relative to alternatives. It implies it is a connection step but does not mention prerequisites, exclusions, or alternative tools. For example, it does not clarify whether this should be run before flow_status or flow_discover_ui.

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 and does well: it discloses the non-submitting default, the credit consumption risk on submit, and the post-submit rename of 'Untitled Character'. It omits auth/permission requirements and error behavior, but the mutation semantics and side effects are clearly stated.

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

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

Three tight sentences, front-loaded with the core action and then the branching behavior. Dense but every clause carries information; only the repeated auto_confirm restatement is mildly redundant with the schema.

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

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

For a 6-parameter mutation tool with no annotations and no output schema, the description covers the critical unknown (what happens on submit vs. not, including credits and the rename) and reveals the returned status token. The remaining params are fully documented in the schema, so the agent has enough to 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 description coverage is 100%, so name, description, campaign, project_name, reference_images and auto_confirm are already documented. The description's explanation of auto_confirm largely restates the schema, adding no format or syntax detail beyond it; baseline 3 applies.

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

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

States a specific verb+resource ('Create a new character in Google Flow Characters') and the required inputs, which cleanly separates it from siblings like flow_import_character and flow_create_scene.

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 two operating modes and their consequences (default fills only and returns ready_for_confirmation with no credits; auto_confirm=true submits), which is exactly the when-to-use decision an agent must make. It does not name sibling alternatives such as flow_import_character for existing characters.

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 behavioral burden. It does disclose one genuinely valuable trait — that the default is a non-mutating 'prepare only' state and auto_confirm=true performs the real creation — but says nothing about permissions, side effects, idempotency, or what 'prepares only' actually produces or how it is later confirmed.

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 compact sentences with the core action, then the mode caveat, both front-loaded. Slightly awkward parenthetical phrasing keeps it from being a model of efficiency, but there is no filler.

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

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

For a six-parameter creation tool with no output schema and no annotations, the description leaves important questions open: what a 'prepared only' invocation returns, how project/campaign reuse interacts with scene creation, and what happens on failure. The rich schema compensates for parameter gaps, but the workflow behavior is under-explained overall.

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

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

Schema description coverage is 100%, so all six parameters (prompt, campaign, characters, auto_confirm, project_name, reference_image) are already documented in the schema. The description restates characters/prompt and the auto_confirm behavior, adding no syntax, format, or constraint detail beyond what the schema already supplies; baseline 3 applies.

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

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

States a specific verb and resource: 'Create a new scene in Google Flow Scenes', and names the key inputs (characters, prompt). It is clearly distinguishable from non-creative siblings like flow_status or flow_list_models, though it does not explicitly contrast itself with the nearby flow_create_character.

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 explains the auto_confirm mode switch (prepare-only vs. actually create), which implies a two-step workflow, but gives no guidance on when to prefer this tool over flow_generate_video, flow_create_character, or the other creation siblings. Usage context is only partially inferred.

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 declares the primary actions (closing browser, cleaning up connection) but does not disclose side effects such as terminating active sessions or preventing further operations. This is adequate for a simple cleanup tool but lacks deeper behavioral context.

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

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

The description is a single, well-structured sentence that directly states the tool's function without unnecessary words. It is perfectly concise and front-loaded.

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

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

For a parameterless tool with no output schema or annotations, the description provides the essential information about its role as a disconnect/cleanup operation. It lacks explicit usage context but is otherwise complete for its simplicity.

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 zero parameters and an empty schema, so the description adds nothing about parameters. Since there are no parameters to explain, the baseline of 4 is appropriate.

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

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

The description uses specific verbs 'Close' and 'clean up' to describe the resource (browser and MCP connection), clearly indicating this is the teardown counterpart to flow_connect. It distinguishes itself from sibling tools by its focus on disconnection and cleanup.

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 does not explicitly state when to use the tool or contrast it with alternatives like flow_connect. Usage must be inferred from the name and context, so the agent receives no direct 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 carries the full burden and does disclose an important non-obvious side effect: it 'Updates the internal selectors map.' That mutation info is valuable. But it omits auth requirements, browser-state effects, error behavior, and how the result is surfaced, leaving substantial 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?

Two tight sentences with the action front-loaded and the side effect trailing. Every clause earns its place with 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?

All four parameters are fully documented in the schema, but with no output schema the description does not explain what 'discover' returns (a list of elements? just the internal map?) or how the agent accesses the discovered elements. Adequate but leaves the return/usage outcome underspecified.

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

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

Schema description coverage is 100%, so the schema already documents url, page, campaign, and project_name in detail, including enum-like options and host restrictions. The description adds no parameter meaning beyond that, 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?

Specific verb+resource: 'Navigate to a Google Flow page and discover all interactive elements (buttons, inputs, links, headings),' which clearly describes the action and its scope. However it does not distinguish itself from sibling flow_open, which also appears to navigate to Flow pages, leaving the agent to guess which to select.

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 purpose ('for robust automation') but gives no explicit when-to-use, when-not-to-use, or alternatives. It never explains how it relates to flow_open or when discovering UI should precede another sibling like flow_generate_image.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It only states select 'most recently generated' but does not explain whether the file is returned as content, a URL, or saved locally, nor any side effects or permissions.

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

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

The description is a single, clear sentence with no filler. It is front-loaded with the main action and resource, making it highly concise and easy to process.

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 no output schema and no annotations, the description is incomplete. It does not specify what the agent should expect as a result (file path, binary content, URL) or how this tool fits into the flow with sibling generation tools (e.g., used after flow_generate_image).

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

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

The input schema has zero parameters, so the description need not elaborate on parameter meaning. The description implicitly communicates that no user input is required, aligning with the baseline for a parameterless tool.

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 'Download' and a clear resource 'the most recently generated file from Google Flow.' It distinguishes itself from sibling tools (e.g., flow_generate_image, flow_connect) by being the only download-focused 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?

No guidance is provided on when to use this tool versus alternatives, prerequisites, or typical usage contexts. The description simply states the action without explaining when it is appropriate or what conditions must exist (e.g., a file must have been generated first).

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 and does so well: it discloses credit consumption, the exact steps taken in each mode (fill prompt, select model/ratio, screenshot, return 'ready_for_confirmation'), that Generate is NOT clicked by default, the pre-flight verification of mode and model, and the wait-for-images behavior. This is far richer than a typical schema would convey.

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 credit warning is front-loaded, and the two modes are laid out as parallel clauses rather than repetition. Density is high with virtually no filler despite covering a complex flow.

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 10-parameter, side-effectful generation tool with no annotations and no output schema, the description covers the critical unknowns: cost implications, what is and isn't executed per mode, and the partial return value ('ready_for_confirmation'). Nothing essential to safe invocation is missing.

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

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

Schema description coverage is 100%, so every parameter is already documented with defaults, formats, and examples. The description reinforces auto_confirm's semantics but adds no parameter meaning beyond the 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?

States a specific verb+resource (generate image) and explicitly scopes the model family ('NANO/BANANA image models only'), which cleanly separates it from sibling flow_generate_video. The two-mode behavior is front-loaded so an agent knows immediately what the tool does.

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

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

Explicitly contrasts the two operating modes: auto_confirm=false prepares only, auto_confirm=true verifies and clicks Generate. It also specifies prerequisites (UI must be in IMAGE mode, model must be an image model). It does not name sibling alternatives for video generation, but the scoping note covers the main branch point.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses the default no-spend prepare behavior, which counteracts the misleading 'generate' name, but it says nothing about the paid confirm_generate path, required auth, or polling/credit consumption beyond what the schema param already states.

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

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

Three front-loaded fragments lead with the single most important behavior (prepare-only, no spend) and waste no words. The terseness makes 'Fast tests, Quality finals' slightly cryptic, but nothing is padding.

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 22-parameter, annotation-free tool with no output schema, the description covers the core safety profile but is thin on the surrounding workflow (how it pairs with flow_list_models, flow_list_mention_options, or the confirm/poll path). The rich schema compensates for parameters, but behavioral coverage is minimal.

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

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

Schema description coverage is 100%, so all 22 parameters are already documented, giving a baseline of 3. The description adds only a marginal cross-parameter rule ('ingredients need 8s', quality tiers) beyond what the individual param descriptions already say.

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

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

States a specific verb (Prepare) and resource (Veo video) and immediately disambiguates against its own name by noting 'prepare-only, no spend'. An agent can tell it produces a video plan rather than a video, though it never names the sibling flow_generate_image or explains how it relates to the image 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?

'Fast tests, Quality finals' implies a quality-tier decision and 'ingredients need 8s' gives a conditional constraint, but there is no explicit when-to-use vs alternatives, no exclusion of the live-generate path, and no prerequisites (auth, project) stated.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only states the high-level action, without detailing side effects (e.g., overwriting existing characters), validation of the JSON, error handling, or any prerequisites. This is a significant gap for an import 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 a single, front-loaded sentence with no filler or redundant information. Every word earns its place, making it highly concise and easy to parse.

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

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

The core purpose is clear and the schema covers parameters, but the description lacks usage guidance relative to sibling tools and does not disclose behavioral traits (e.g., whether it overwrites or merges). For a tool with no annotations and no output schema, this is adequate but leaves gaps for an agent deciding between import and create.

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 provides descriptions for all three parameters (campaign, file_path, project_name), giving 100% schema coverage. The description itself adds no parameter-specific detail, so the baseline of 3 is appropriate since the schema handles parameter semantics.

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

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

The description uses a specific verb ('Import') with a clear resource ('character') and source/destination ('saved JSON file' into 'Google Flow'). This clearly distinguishes it from siblings like flow_create_character (which creates from scratch) and flow_open_characters (which opens existing characters).

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 when a saved JSON character file exists, but it offers no explicit when-to-use or when-not-to-use guidance, and does not mention alternative tools such as flow_create_character. The context is inferred from the phrase 'saved JSON file' rather than stated directly.

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 burden of disclosure. It transparently states the side effect of opening Flow's '@' reference popup and reading its options, which goes beyond a generic 'list' description. It does not detail safety permissions, but the read-only nature is inferred and no harmful behavior is hidden.

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

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

The description is a single, front-loaded sentence that is both concise and information-dense. It includes the action, target, mechanism, and context without redundancy or filler.

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

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

The description sufficiently explains the tool's purpose and behavior for a listing tool. It lacks an explicit return format, but that is partially mitigated by the absence of an output schema and the simplicity of the feature. It is complete enough for an agent to 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?

The input schema already provides full descriptions for both 'campaign' and 'project_name' (100% coverage). The tool description adds no additional parameter meaning, so the baseline score of 3 applies.

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

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

The description clearly states the action ('List'), the resource ('images and characters'), and the context ('current project' and 'via @name in an image/video prompt'). It distinguishes this from sibling tools like flow_open_characters by specifying the popup-reading mechanism.

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 on when to use the tool (when needing @name references for image/video prompts) and implies the popup interaction. It does not explicitly name alternatives or exclusions, so it stops short of a 5 but is clear enough for an agent.

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 the live-vs-cache duality and the once-per-session constraint, but omits whether a connected/open Flow UI is required, what the call costs, and whether results are exhaustive. For a read-only discovery tool this is minimally adequate rather than rich.

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

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

Two short sentences, no filler. The resource list is front-loaded and the calling constraint follows immediately, so an agent can act after one read.

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

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

For a one-parameter listing tool with full schema coverage and no output schema, the description covers what is returned (models, ratios, durations) and when to call it. The remaining gap is the undeclared dependency on a live Flow UI session, which matters for a browser-driven 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 description coverage is 100% and the single 'refresh' parameter is fully documented in the schema. The description's 'live or cache' phrasing mirrors that schema text rather than adding syntax or format detail, so the baseline 3 applies.

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

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

States a specific verb ('List') and concrete resources (video/image models, ratios, durations), and scopes the source (Flow UI live or cache). It does not name a sibling explicitly, but 'before generating' clearly separates it from the flow_generate_* 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?

Gives explicit timing guidance: 'Call once per session before generating.' That is a clear when-to-use directive tied to the generate workflow, though it names no exclusions or alternatives (e.g., what to do if the cache is stale besides refresh).

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, and it does disclose real behavior: navigation reuses the existing connection and a host allowlist rejects anything that is not https://flow.google.com/... It omits what happens if no session exists or if navigation fails, so it is not exhaustive.

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, zero filler, with the core action front-loaded and the host restriction immediately after. Every clause carries 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 low-complexity navigation tool with only two well-documented parameters, the description covers the action, the precondition, and the input constraint. It does not say what the call returns or how failures surface, which is the only remaining gap given there is no output schema.

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

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

Schema coverage is 100% so baseline is 3, but the description adds a genuine constraint on the url parameter (only https://flow.google.com/... accepted, other hosts rejected) that the schema does not state. The waitFor parameter is left entirely to 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?

Specific verb (navigate) plus resource (already-connected browser to a Flow URL), and the phrase 'without reconnecting' implicitly separates it from flow_connect and flow_open_tools_gallery. An agent can select it correctly without opening any schema.

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

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

The precondition 'already-connected browser' and 'without reconnecting' tell the agent this is for an existing session rather than establishing one, which routes it away from flow_connect. It never names the alternative explicitly, so the routing is inferred rather than stated.

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

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

No annotations are provided, so the description carries full burden. It states the tool opens a page and lists characters but does not disclose potential side effects, such as creating a new project if none matches (as implied by the schema's project_name description). Lacks details on permissions or reversibility.

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 with action and purpose. 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?

The description is adequate for a simple navigation/listing tool but lacks context on project selection mechanism and output nature. With no output schema or annotations, it could benefit from explaining the relationship between campaign and project_name and whether the list is returned as data.

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% coverage, so baseline is 3. The description adds no parameter-specific information; it relies entirely on schema descriptions for campaign and project_name.

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 uses specific verb 'open' and resource 'Characters page', and further clarifies it lists existing characters. This clearly distinguishes it from sibling tools like flow_create_character and flow_import_character, which perform different operations.

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 such as flow_create_character or flow_import_character. The description implies usage for viewing existing characters but doesn't state exclusions or prerequisites.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states what the tool does (opens a gallery and lists tools) but does not disclose any side effects, permissions required, or whether it returns data in the response. For a simple tool this might be acceptable, but the lack of explicit behavioral context is a gap.

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

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

The description is a single, compact sentence with no wasted words. It front-loads the action and resource clearly, making it immediately understandable.

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 (no parameters, no output schema, minimal annotations), the description covers the essential purpose. However, it leaves slight ambiguity about whether 'list available tools' means returning a list in the response or opening a UI gallery. This prevents a perfect score.

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 accepts zero parameters, so the schema coverage is trivially 100%. The baseline for 0 parameters is 4, and the description adds no confusion about parameters. Since there are no parameters to clarify, the description does not need to provide additional 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 the tool opens the Google Flow Tools Gallery and lists available tools. This is a specific verb+resource combination that distinguishes it from sibling tools like flow_download_latest or flow_create_scene.

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 discovering available tools, but does not explicitly state when to use this tool versus alternatives or mention any prerequisites. There are no exclusions or comparisons with siblings, so it relies on the name and context to convey intent.

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 convey behavioral traits. It states the action is 'forceful' and targets stuck jobs, implying a destructive/resetting behavior. However, it does not disclose potential side effects (e.g., loss of queued jobs, irreversibility, or required permissions), which are important for a reset 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 two sentences long, with the primary action front-loaded in the first sentence. The second sentence adds valuable usage context without any fluff or redundancy. Every word earns its place.

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

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

For a simple, zero-parameter tool, this description covers the purpose and the specific situation. There is no output schema, and the tool's return behavior is not described, but for a queue reset, the main point is the action itself. A small note about consequences (e.g., pending jobs may be cleared) would make it more complete, but it's adequate as is.

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 zero parameters, and the input schema is an empty object. Per the rubric, 0 params is a baseline of 4. The description correctly implies no configuration is needed, so no additional parameter explanation is necessary.

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 ('Forcefully reset the job queue') and the specific resource (the job queue). It also provides a concrete scenario (job stuck in 'running' state blocking others), which distinguishes it from sibling tools like flow_queue_status that likely just query status.

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

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

The description explicitly states when to use the tool: 'if a job is permanently stuck in "running" state and blocking other generations.' This gives clear context, though it does not mention when not to use it or explicitly name alternatives. Still, the use case 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?

Since no annotations are provided, the description carries the full burden. It clearly indicates a read-only operation ('Check') and lists the information returned, but it does not disclose any potential side effects, authentication requirements, or details about how history_limit affects results. It is minimally transparent but not deeply descriptive.

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

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

The description is a single concise sentence that front-loads the primary action and enumerates the specific aspects of the queue. There is no wasted 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 simple tool with one optional parameter and no output schema, the description adequately captures the main functionality. It names all categories of queue status without needing to explain return values extensively. The only minor gap is not explicitly stating that history_limit controls the number of history entries, but that is already in the schema.

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

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

The input schema provides 100% coverage for the only parameter (history_limit) with a clear description. The tool description does not add additional meaning beyond the schema, but since schema coverage is high, the 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 uses a specific verb ('Check') and resource ('job queue'), and enumerates the exact information covered (active job, pending queue, completed and failed job history). This clearly distinguishes it from sibling tools like flow_status, which likely covers broader status, and other flow_* tools.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as flow_status. The description implies that it is for checking queue information, but it does not state exclusions or mention alternative tools, leaving the agent without clear decision criteria.

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

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

No annotations are provided, so the description carries the full burden of disclosing behavioral details. It only states the action without mentioning where the screenshot is saved, whether it returns a file path, authentication requirements, or any side effects, leaving significant ambiguity for an 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 a single sentence with no filler, immediately conveying the tool's action. It is appropriately concise and front-loaded, making it easy for an agent to parse.

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

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

Given the tool's simplicity (one optional param, no output schema, no annotations), the description is minimally adequate but incomplete. It fails to explain what happens after the screenshot is taken (e.g., file location, return value), leaving the agent without enough context to predict the tool's full behavior.

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

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

The single optional parameter 'name' is fully described in the input schema (100% coverage), so the baseline is 3. The description adds no additional semantic detail about the parameter, but the schema already provides sufficient 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 a specific action ('Take a screenshot') on a specific resource ('the current Google Flow page'), making its purpose unambiguous. This distinguishes it from sibling tools like flow_download_latest or flow_create_scene, which serve different actions.

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 does not provide explicit guidance on when to use this tool versus alternatives. However, the intended use is implied by the action itself — taking a screenshot when a visual capture is needed — but no exclusions or alternative comparisons are mentioned.

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 transparently lists the exact status dimensions checked (browser, page, account, queue), which is useful. However, it doesn't disclose whether this is a read-only operation, how the response is structured, or whether it performs live checks or returns cached state.

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

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

The description is a single sentence of 12 words, front-loaded with the primary action and resource. Every word adds value, with no redundancy or filler.

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

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

For a simplistic status-check tool with one fully described parameter, the description covers core purpose and scope. However, without an output schema or annotations, it omits details about return format, potential latency, and any safety characteristics, leaving the agent uncertain about how to interpret 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 schema description fully documents the 'full' parameter ('Return full status with screenshot'), achieving 100% coverage. The tool description adds no parameter-specific context, so the baseline score of 3 applies.

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

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

The description uses the specific verb 'Check' and clearly enumerates the status components (browser connected, Flow page loaded, account verified, job queue state). It implies a broader scope than individual siblings like flow_account_check or flow_queue_status but does not explicitly name them for differentiation.

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

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

No guidance is provided on when to use this tool versus alternatives. It doesn't mention that flow_queue_status should be used for queue-only details or flow_connect for establishing a connection. The agent is left without explicit selection criteria.

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, and it does disclose one important trait: 'Prepare-only by default (auto_confirm=false)'. It also hints at project reuse via the schema, but it never says what happens after preparation, whether a separate confirm step exists, or what permissions/account state are required — significant gaps for an unattended UI-driving 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?

Three tight sentences with the core action front-loaded and the prepare-only caveat placed last where it matters most. No filler, though the middle sentence's field enumeration is largely redundant with the schema.

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

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

For a 9-parameter, no-annotation, no-output-schema tool, the description covers the primary flow and the safety default but omits the post-prepare lifecycle (what the caller does next) and any notion of the return value. It is minimally sufficient but leaves the agent guessing about the step after invocation.

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

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

Schema description coverage is 100%, so the baseline is 3. The description restates theme prompt, shot prompts, engine, ratio and visual logic — all already documented in the schema — and adds no format or constraint detail (e.g., valid engine names, visual_logic enum values, reference image path expectations).

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

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

States a specific verb+resource ('Open Grid Architect in Google Flow') and enumerates the fields it fills, so the agent knows exactly what operation this performs. It implies batch shot generation, which differentiates it somewhat from flow_generate_image, but it never names a sibling or explicitly contrasts the two.

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?

'Supports batch shot generation for brand campaigns' gives an implied use case, but there is no explicit when-to-use/when-not guidance and no mention of alternatives such as flow_generate_image or flow_create_scene for single-shot work. The agent must infer routing from the batch/campaign phrasing.

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 behavioral burden. It does disclose one genuinely important trait: the tool is prepare-only unless auto_confirm is set, so the agent knows opening a tool is non-destructive by default. It omits other relevant behavior — whether a connected session/project is required, what state the opened tool leaves behind, and what happens to params that don't match the target 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?

Two short sentences that are front-loaded with the core action, followed immediately by the most consequential behavioral caveat. The clause about optionally filling configuration parameters is mildly redundant with the schema, but there is no padding.

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 5-parameter tool (with a nested object) and no output schema and no annotations, the description is only minimally sufficient. It does not explain what an agent gets back after opening a tool, nor the relationship between project_name/campaign reuse and an already-open session — details the agent must have since there is no return schema to fall back on.

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

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

Schema description coverage is 100%, so the schema already documents all five parameters, including the campaign/project_name reuse semantics and the reserved auto_confirm flag. The description's only parameter-related statement ('optionally fill its configuration parameters') restates the schema rather than adding syntax, format, or validation meaning. 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 names a specific verb ('Open') and resource ('any tool by name in Google Flow'), plus the optional parameter-filling behavior. It implicitly distinguishes itself from the sibling flow_use_grid_architect (one specific tool) by saying 'any tool', but never names an alternative 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?

It gives one useful usage signal — 'Prepare-only by default (auto_confirm=false)' — which tells the agent the call will not execute anything by default. However, there is no guidance on when to prefer this generic opener over flow_use_grid_architect, flow_open_tools_gallery, or whether flow_connect must run first. Usage is only implied.

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