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

With no annotations provided, the description must carry the behavioral disclosure burden. It does add useful context by stating the key is stored locally and persists across sessions, but it does not mention overwrite behavior, security implications, or what happens if an invalid key is provided.

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 concise sentences with no filler. The primary action and scope are front-loaded, and the persistence detail is a valuable addition that 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 configuration setter with a single parameter and no output schema, the description covers the essential behavior: what it does, where the key is stored, and that it persists. It could mention that this key is required before using generate_image, but the sibling context makes that inference straightforward.

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

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

The schema already provides 100% coverage for the single parameter, including a clear description and a URL for obtaining the key. The tool description does not add additional parameter semantics, which is acceptable given the schema's completeness.

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 ('Set or update') and names the exact resource ('Gemini API key for image generation'), making the tool's purpose immediately clear. It also distinguishes itself from sibling tools like configure_openai_api_key and configure_google_login.

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

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

The description clearly implies this tool is used to configure the Gemini key needed for image generation, and that it can be used both for initial setup and updating an existing key. It does not explicitly name when not to use it or direct to alternatives, so it misses the top score.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses that this is an unofficial auth mode, that cookies are stored locally, that re-extraction may be needed on expiration, and that video is not supported. It omits side effects such as whether existing API key settings are overwritten, but overall the key behavioral traits are surfaced.

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 focused sentences deliver the core purpose, capability scope, and operational instructions without filler. Each sentence carries distinct information, and the main action 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 moderate complexity and absence of both annotations and output schema, the description covers the essential operational context: what mode it switches to, what it supports, how to obtain cookies, and their persistence/expiration. Some gaps remain around reversible configuration and exact impact on other auth methods, but the tool can be invoked correctly with the provided information.

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

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

The input schema already covers both parameters at 100%, giving a baseline of 3. The description adds practical value by telling the user to extract cookies from browser DevTools at the specific location, which helps correctly obtain the cookie values. It also warns that cookies expire, adding context not present in 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 uses a specific verb ('Switch to') and names the exact resource ('free, unofficial gemini-web auth mode'), making the tool's purpose immediately clear. It also distinguishes itself from API-key-based siblings by explicitly saying 'instead of an API key' and noting its feature scope (image generation/editing, no video).

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

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

The description clearly implies when to use this tool: when the agent should use a consumer Gemini session instead of an API key. It contrasts with API-key configuration and defines supported capabilities (image, not video). It does not explicitly name alternatives like configure_api_key or state when not to use it, but the context is strong enough for correct selection.

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

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

With no annotations provided, the description must carry the behavioral disclosure burden. It does disclose persistence across sessions, which is an important side effect. However, it does not mention authorization needs, whether this overwrites an existing setting, or any other side effects beyond persistence.

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 four sentences, front-loads the primary purpose, and each sentence adds information about persistence or model/quality mapping. It could be more concise, but there is no filler or redundancy.

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

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

The tool has no output schema and no annotations, so the description must be more complete. It omits any explanation of the required 'model' parameter and the relationship between 'model' and 'quality'. The persistence and default model mappings are helpful, but the missing required-parameter guidance is a significant completeness gap.

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

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

Schema coverage is 100%, and the description does add useful meaning by mapping 'quality' values to concrete model IDs and defaults. However, it creates a serious ambiguity: the schema marks 'model' as required, yet the description tells the agent to use the 'quality' param to set the model tier and never explains how 'model' and 'quality' interact. An agent could reasonably call the tool with only 'quality' and fail validation.

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

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

The description uses a specific verb and resource: 'Set the default Gemini model for image generation and editing.' It clearly distinguishes this tool from sibling configuration tools like configure_api_key and configure_google_login by scoping it to the Gemini image model default.

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

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

The description gives clear context: use this tool when you want to change the persistent default Gemini model for image generation/editing. It does not explicitly state when not to use it or name alternatives, but the purpose is obvious enough among the sibling tools.

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

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

With no annotations, the description carries the behavioral disclosure burden and does state the mutation ('Set or update') and local storage. However, it leaves out persistence/reversibility details, whether the key is validated, and how it affects sibling generation tools.

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

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

Two short sentences with no filler; the action, resource, and scope are front-loaded and every sentence adds 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 one-parameter setter with no output schema, this is nearly complete: it states the action, scope, and storage location. It could be slightly stronger by mentioning when to use it relative to configure_api_key, but nothing needed to invoke it correctly 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 coverage is 100% and the apiKey parameter already includes its own description, so the tool description adds little parameter-level meaning. The image-generation context is useful but does not change how the parameter is supplied.

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 ('Set or update'), identifies the resource ('OpenAI API key'), and scopes it to image generation, which also differentiates it from the generic configure_api_key sibling. The local-storage detail adds further precision.

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

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

The phrase 'for image generation' implies the tool should be used before OpenAI image generation, but it never explicitly states when to choose this over configure_api_key or configure_model, and offers no alternatives 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It does usefully reveal the stateful behavior of automatically selecting the most recent image, but it does not describe mutation effects, error behavior if no prior image exists, or what the tool returns. For a tool that performs editing, this 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 two short sentences with no filler. The core action is stated first, and the key automatic behavior is added in the second sentence. Every word earns its place.

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

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

The central ambiguity—which image to edit—is resolved clearly. However, the tool has no annotations or output schema, and the description omits failure behavior, return format, and whether the operation modifies session state beyond the previous image. It is adequate for a simple invocation but not fully complete.

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

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

Schema description coverage is 100%, so all four parameters (prompt, model, quality, referenceImages) are already documented in the input schema. The description adds no parameter-specific semantics, but the schema already handles that burden, so a baseline 3 is appropriate.

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

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

The description uses a specific verb-resource pair ('Continue editing the last generated or edited image') and clearly identifies the target as the most recent session image. This automatically distinguishes it from sibling tools like edit_image or generate_image, which would operate on a newly specified image or create a new one.

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 correct use case: after at least one image has been generated or edited, apply further edits to that same image. However, it does not explicitly state when to use this tool versus edit_image, nor does it mention prerequisites such as 'requires an existing image in session' or what happens if no prior image exists.

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 responsibility for behavioral disclosure. It does not state whether the original file is overwritten, whether a new image path is returned, or what side effects editing has. 'Edit an existing image' leaves persistence and output behavior ambiguous.

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

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

Two short sentences with no filler. The core action is front-loaded, and the second sentence reinforces the key required input without repeating schema verbosity.

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

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

With no annotations and no output schema, the description must compensate. It leaves essential execution context undisclosed, such as whether the edit is in-place, what the return value is, and which image formats are supported. Despite complete parameter documentation, the behavioral picture is 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?

The schema describes all five parameters with 100% coverage, so the baseline is 3. The description merely restates 'file path' and 'text instructions', adding no extra meaning for model, quality, or referenceImages.

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

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

The description states a specific verb ('Edit'), a clear resource ('existing image'), and the method ('based on text instructions'). The word 'existing' distinguishes it from sibling generate_image, making the tool's function 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?

Usage is implied: use this when an image already exists and needs modification. However, the description does not explicitly contrast with closely related siblings like generate_image or continue_editing, nor does it state when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It does disclose two important behaviors: the tool returns the generated image and saves it to disk, and it identifies the model provider. However, it does not specify where the image is saved, what output format to expect, or whether any system state changes beyond the file save occur.

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, efficient sentence. The core action is front-loaded ('Generate a new image from a text description'), followed by the key side effect and return behavior. Every clause contributes meaningful 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 tool with no output schema and no annotations, the description is adequate but incomplete. It conveys the essential action and result, but leaves gaps such as the save location/filename, whether an API key or model configuration is required, and how it relates operationally to the sibling edit_image tool. These gaps add uncertainty when an agent decides whether this is the right tool and what consequences invocation will have.

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 documents all three parameters with 100% coverage, so the description does not need to carry much parameter weight. The description adds only a loose connection between 'text description' and the prompt parameter, and 'Gemini AI' with the model concept, but no parameter-specific guidance 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 a specific action — 'Generate a new image from a text description' — and names the provider ('Gemini AI'). This distinguishes it from siblings like edit_image, continue_editing, and generate_openai_image, so an agent can immediately understand 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?

The phrase 'new image from a text description' implies this is for generation rather than editing or continuing, and the mention of 'Gemini AI' distinguishes it from OpenAI-based siblings. However, the description does not explicitly state when to use this tool over alternatives, nor does it mention prerequisites 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?

With no annotations, the description carries the full burden of behavioral disclosure, but it only describes the action and model. It does not mention API-key prerequisites, cost or quota implications, external network calls, output format, or side effects such as history storage, even though sibling configuration tools indicate these are relevant.

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, conveying the action, input, and model choice efficiently. It loses a point because it omits routing or behavioral detail that the schema cannot provide.

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

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

The tool is simple and the schema fully documents its three parameters, making the description minimally viable. However, with no output schema and no mention of prerequisites, cost, or alternatives among the many siblings, it leaves material gaps for an agent deciding whether to call this tool versus generate_image or edit_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?

Schema description coverage is 100%, so prompt, size, and model are already documented. The description adds no meaningful parameter-level detail beyond restating that the prompt is a text description, so the baseline of 3 applies.

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

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

The description states a specific verb and resource ('Generate a new image from a text description') and adds the model family 'OpenAI DALL-E', which helps distinguish it from video generation and editing tools. It does not explicitly contrast with the sibling generate_image, so it is clear but not fully differentiated.

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 intended use is implied: use this tool when creating a brand-new image from a text prompt rather than editing an existing image. However, there is no explicit when/when-not guidance or naming of alternative tools, leaving selection between this and generate_image mostly to inference.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It usefully discloses latency ('takes 1-6 minutes') and model options with the latest flagged. However, it omits output behavior, authentication requirements, and post-generation steps such as polling or checking video history.

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 three tight, front-loaded sentences covering purpose, modes, latency, and model availability. There is no filler, and every sentence contributes actionable information.

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

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

For a 9-parameter, long-running generation tool with no output schema and no annotations, the description omits what happens after generation: where the video is saved, whether the call is asynchronous, and how to retrieve the result. The sibling list_video_history hints at the missing flow, but the description itself is 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 description coverage is 100%, and the schema already documents defaults and parameter relationships (e.g., lastFramePath requires imagePath). The description mostly restates model names and modes that appear in the schema, adding minimal new parameter-level semantics.

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

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

The description states a specific verb and resource: 'Generate a video from a text prompt using Gemini Veo.' It also enumerates supported modes (text-to-video, image-to-video, first+last frame), which clearly distinguishes it from image-generation siblings like generate_image.

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 establishes clear context by framing the tool as video generation and listing the supported generation modes. It does not explicitly name alternative tools or state when not to use this tool, but the video-vs-image distinction is strongly implied.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. The word 'Check' implies a read-only operation and the description names the data that will be retrieved, but it does not explicitly state that no configuration changes are made, whether any side effects occur, or what the response structure looks like beyond the listed categories.

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 action and lists the key return areas without redundancy or filler. Every word contributes to understanding 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, parameterless status tool, the description covers the essential content: configuration status, active model, and last image/video information. It could be slightly more complete by explicitly noting the operation is read-only and has no side effects, but the context is adequately covered for the tool's low complexity.

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

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

The tool has zero parameters, so there are no parameter semantics to clarify. The description adds value by explaining what information the tool returns, which is more useful than the empty input schema alone. This matches 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 ('Check') with a clear resource ('current configuration status, active model, and last image/video information'). It is immediately distinct from sibling tools that configure or generate content, so an agent can identify what this tool is for without inspecting other definitions.

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

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

Usage context is implied by the verb 'Check' and the read-only subject matter, but the description does not explicitly state when to use this tool versus alternatives or mention exclusions. There is no direct guidance such as 'Use configure_model to change settings instead', though such guidance is not essential given the obvious distinction.

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 behavioral burden. It discloses the core behavior—listing recent images with prompts and timestamps—and implies a read-only operation via 'List.' However, it does not specify ordering, what 'recent' means, or whether the operation has any side effects, though those are less critical for a list 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, efficient sentence that front-loads the action and resource, then adds the valuable detail about prompts and timestamps. There is no unnecessary information or 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?

For a simple list operation with one optional parameter and no output schema, the description is mostly complete: it states what is returned and the scope. Minor gaps remain, such as the exact meaning of 'recent' and ordering behavior, but these are low-risk for correct invocation.

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

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

The input schema already fully documents the only parameter (count) with its default and maximum, so schema coverage is 100%. The description adds no additional parameter-level meaning, and the baseline of 3 applies.

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

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

The description uses a specific verb (List) with a clear resource (recently generated and edited images), and specifies the return content (prompts and timestamps). This distinguishes it from sibling list_video_history, which focuses on videos, without needing to inspect schemas.

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

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

The description clearly indicates the tool is for image history by explicitly scoping to 'generated and edited images.' It does not explicitly name alternatives or state when not to use it, but the resource scoping makes the usage context clear enough for an agent to select it over the video-history sibling.

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

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

With no annotations, the description must carry behavioral context. 'List' conveys a read-only operation and 'recently' implies temporal ordering/filtering, but the description doesn't disclose limits, pagination, ordering guarantees, or error behavior. This is minimal but acceptable for a simple listing 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?

A single, front-loaded sentence states exactly what the tool does with no redundant filler. Every word earns its place.

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

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

The tool is simple (one optional parameter, no output schema), and the description covers the key return fields. Minor omissions such as explicit ordering and the relationship to list_history keep it from being fully complete, but it is sufficient for an agent to call it correctly.

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

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

Schema description coverage is 100% and the only parameter, count, already has a description with default and max. The tool description adds no parameter-specific semantics, 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?

The description uses a specific verb ('List') and resource ('recently generated videos'), and specifies the returned fields (prompts, models, timestamps). This clearly distinguishes it from image-generation siblings and from the generic list_history sibling by narrowing scope to videos.

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 guidance about when to use this tool versus alternatives, especially list_history, which could overlap. The description states what it lists but says nothing about exclusions, prerequisites, or a decision rule between the history tools.

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