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

With no annotations, the description carries the full burden and does deliver genuinely useful behavioral detail: an optional mask is guidance only, interpreted semantically rather than pixel-exactly. It is silent on whether the source file is overwritten, where the result is written, and any cost/latency, which matters for a model-inference call.

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, front-loaded with the action, and the mask caveat placed immediately after. No filler, though the line break mid-sentence slightly fragments the 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?

Seven parameters, three required, and the most consequential required input (edit_mode, six undocumented enum-like values) gets no guidance on selection or per-mode prerequisites such as which modes need a mask. Output schema exists so return values needn't be explained, but the mode-selection gap keeps this at minimum-viable.

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

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

Schema coverage is 100%, so the baseline is 3, and the description earns above that by explaining mask_path semantics (white = region to change, soft boundary guidance) and by framing prompt as what the mode-specific wrapper consumes. It adds no color on the model or output_format parameters, but those are self-describing.

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 ("Edit an image") plus the distinguishing mechanism: a specialized mode backed by a Gemini image model, with per-mode prompt tuning. It does not name or contrast with the obvious sibling edit_image, so an agent cannot be fully certain which of the two to reach for.

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 only implied. Nothing says when to prefer advanced_edit over edit_image, or which of the six edit_mode values fits a given intent. The mask note implies the inpainting modes benefit from a mask, but the other four modes are left uncharacterized.

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 supplied, so the description carries the full burden, yet it discloses nothing about cost/latency implications of the model choice, whether an external API call or credentials are required, or how grounding affects behavior. For a tool that apparently invokes a billed vision model, this is a substantial 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?

A single front-loaded sentence with no filler or repetition. It is efficient, though efficiency here comes partly at the cost of substance.

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?

An output schema exists and the input schema is fully documented, so the agent has enough to invoke the tool correctly. However, with zero annotations and a vision-model backend, the description should at minimum note that the call may incur cost or rely on an external service.

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 every parameter (model, prompt, image_path, use_grounding) is already documented in the schema with defaults and guidance. The description adds no meaning beyond that, which meets the baseline 3 when the schema does the heavy lifting.

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

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

The description gives a clear verb and resource ("analyze an image") plus a hint at the output ("detailed description"), but it does not distinguish this from siblings like extract_text, detect_objects, or compare_images, which are also image-analysis tools. An agent cannot tell from this text why it should choose analyze_image over those alternatives.

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 on when to use this tool versus the many related siblings, and no mention of prerequisites such as valid image paths or when the model override or grounding options should be used. The schema hints at these choices, but the description offers no routing logic.

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, yet it says nothing about that this is a pure text transform (no generation side effects), what happens with an unknown template_name, or whether output is a plain string prompt. It does at least imply the return is 'a ready-to-use prompt', which is the one behavioral fact conveyed.

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

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

A single front-loaded sentence with no filler; nothing is wasted. It is arguably too terse rather than verbose, but as a structural matter it is tight and clear.

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

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

An output schema exists so return values needn't be explained, and parameters are fully covered by the schema. However, with zero annotations on a tool that sits in a suite of image-generation siblings, the description should still clarify that it only produces prompt text and not an image, and how it relates to optimize_prompt/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?

Schema description coverage is 100%, so both parameters (template_name, subject) are already documented with examples and the list_templates pointer. The description restates that a subject is filled into a template but adds no syntax or format detail beyond the schema, matching the baseline-3 case.

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 ('apply') and resource ('prompt template') plus the outcome ('generate a ready-to-use prompt'), which is clear enough to distinguish it from image-mutation siblings like edit_image or transform_image. It doesn't explicitly differentiate from the nearest sibling list_templates (only the schema hints at that), so it stops short of a 5.

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 when-to-use or when-not-to-use guidance is given, and no alternatives are named despite siblings like list_templates, optimize_prompt, and generate_image that an agent could easily confuse it with. The only routing hint ('Use list_templates() to see all') lives in the schema property, not the description.

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 meaningful trait — parallel execution — which affects latency and error-handling expectations, but says nothing about partial failures, per-prompt error reporting, cost/rate implications, or whether shared model/quality settings apply to all outputs.

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

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

A single front-loaded sentence with no filler; the parallel/batch nature is stated first, which is the key decision-relevant fact.

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?

An output schema exists, so return values need not be described. However, for a batch mutation-style tool with zero annotations and five parameters, the absence of any statement about partial-failure behavior or per-prompt result mapping leaves a real gap for an agent deciding whether to batch or loop over 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?

Schema description coverage is 100%, so all five parameters including the prompts array, model, quality preset, aspect ratio, and output format are already documented inline. The description only echoes that generation is driven by a prompt list and adds no constraints or format detail beyond the schema, making the baseline 3 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 ('Generate'), resource ('images'), and distinguishing scope ('multiple ... in parallel from a list of prompts'). This implicitly separates it from the sibling generate_image, but it never names that sibling, so the differentiation requires the agent to infer it.

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

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

Usage is only implied: 'a list of prompts' suggests batching rather than one-off generation, but there is no explicit 'use generate_image for a single image' routing, no guidance on batch size (1-10 lives only in the schema), and no mention of when a batch is a poor choice.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the call is read-only versus mutating, whether it consumes paid model credits (relevant given the estimate_cost sibling), what permissions are needed, or what form the analysis output takes beyond the bare phrase 'analyze differences'.

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, purpose front-loaded, with a compact use-case list that follows. No filler, though the use-case list is somewhat generic relative to the tool's capability.

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?

An output schema exists, so return values need not be described. However, with zero annotations the description should have covered safety/mutation semantics and cost implications, which are missing; the enumerated use cases only partially compensate.

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 (model, prompt, image_paths, use_grounding) are already documented in the schema. The description adds no parameter-level guidance such as how to phrase the prompt or when grounding is worth enabling, 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?

States a specific verb and resource ('compare two or more images') plus the action taken ('analyze differences'), so the operation is immediately understandable. It does not distinguish itself from the sibling analyze_image, which likely handles single-image inspection, leaving the boundary implicit.

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 lists broad application scenarios (A/B testing, design review, before/after, change detection), which implies when the tool is appropriate. It never states when to choose it over analyze_image or edit_image, and offers no 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?

With no annotations, the description does carry the burden, and it usefully discloses the backend, the zero-shot nature (no example images needed), and the exact coordinate scale/order including the non-obvious [y_min, x_min, y_max, x_max] ordering. It says nothing about failure modes (non-image paths), cost, latency, or how many objects are returned, so the operational profile is incomplete.

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

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

Three short sentences, front-loaded with the action and followed by the two facts an agent most needs (mechanism and coordinate format). The coordinate-order detail partially overlaps the output schema but is dense enough to earn its place.

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

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

With an output schema present, return values need not be re-explained, and all four params are fully covered by the schema. What remains missing is selection guidance relative to the other image tools; otherwise the definition is sufficient 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 all four parameters (image_path, objects, model, use_grounding) are already documented, including the model override guidance and the objects filter example. The description adds no parameter guidance beyond that, 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?

States a specific verb and resource ('detect objects in an image with bounding boxes') and adds the mechanism (Gemini zero-shot detection). It never names or contrasts with the closest sibling, analyze_image, so an agent must infer why it should pick this over a general image analysis call.

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 only implied by the output format: wanting bounding boxes selects this tool. There is no explicit when-to-use, no when-not-to-use, and no reference to analyze_image, extract_text, or compare_images, all of which could plausibly be chosen instead.

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 supplied, so the description carries the full behavioral burden and says nothing about whether the source image is overwritten or a new file is written, what output path is used, cost implications, or any permission requirements. For a mutation tool with zero annotation coverage this is a substantial 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?

A single front-loaded sentence with no filler. It is efficient, though the terseness borders on under-specification rather than true conciseness.

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

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

With six parameters, an output schema, no annotations, and several overlapping siblings, the description should at minimum disambiguate edit vs transform vs advanced_edit and note the non-destructive or destructive nature of the operation. It covers return values via the output schema but leaves the selection and side-effect questions unanswered.

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 including model, temperature, output_format, and output_filename is already documented in the schema. The description adds no parameter meaning beyond that, 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?

States a specific verb and resource: edit an existing image via a text prompt, which cleanly separates it from generate_image. However, it offers no distinction from the closely related siblings transform_image and advanced_edit, which an agent must choose between.

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 when-to-use guidance, no prerequisites, and no routing to alternatives despite at least three overlapping siblings (transform_image, advanced_edit, generate_image). The only hint about scale of edit appears in the model parameter schema, not in the description.

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 disclosure burden. It explains that the tool shows pricing per model per operation, but does not explicitly state that it is a read-only estimate, that it does not execute the operation, or how exact the estimate is.

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, front-loaded with the core purpose and followed by useful budgeting context. There is no unnecessary wording.

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 three-parameter, read-only estimation tool with a complete input schema and an output schema, the description is largely sufficient. The main remaining gap is the lack of explicit behavioral clarification that this estimates cost rather than performing the image operation.

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

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

Schema description coverage is 100%, so the schema already documents model, operation, and number_of_images in detail. The description adds only the high-level idea of 'per model per operation' pricing, which is a baseline contribution rather than new parameter meaning.

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

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

The description gives a specific verb-and-resource pair: 'Estimate the cost of an image operation.' This is clearly distinct from sibling tools that actually generate, edit, or analyze images, though it does not explicitly name those siblings as alternatives.

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 'to help with budgeting' implies the tool is used before or alongside image operations, but the description does not explicitly state when to use it versus alternatives or any 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 burden alone. It discloses the underlying engine and that it is an OCR extraction, but says nothing about cost, latency, rate limits, or permissions — meaningful gaps for a model-backed vision call, though the read-only nature is implicit in 'extract'.

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, front-loaded with the core action, with no filler. The second sentence's input-type list is somewhat loose but still informative.

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?

An output schema exists, so return values need not be explained. However, with zero annotations the description should have covered behavioral aspects like cost or whether grounding affects billing/accuracy tradeoffs; it only gestures at this via 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?

Schema description coverage is 100%, so all three parameters (image_path, model override, use_grounding) are already documented in the schema, including the model recommendation. The description adds no parameter-level 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?

Names a specific verb and resource ('Extract text from an image using OCR'), and the second sentence clarifies the engine (Gemini vision) and scope of input types. It does not explicitly differentiate itself from the closest sibling, analyze_image, which an agent could plausibly confuse it with.

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 examples ('screenshots, documents, signs, handwriting') imply when the tool is appropriate, but there is no explicit when-to-use versus when-to-use-analyze_image guidance and no 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 behavioral burden, yet it mentions nothing about cost, latency, file writes to disk, safety filtering, or model-specific limits. For a generative tool with 13 parameters and real side effects, this is a significant omission.

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

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

One sentence, front-loaded, zero waste. It is efficient, though its brevity is partly under-specification rather than disciplined concision given the tool's complexity.

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 13 parameters, an output schema, no annotations, and a crowded sibling set, a single sentence is not enough. It should have flagged cost implications, output location/file writing, and how text-to-image differs from the editing siblings.

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%, with rich per-parameter docs covering model tiers, quality presets, image_size constraints, reference image counts, and the person_generation compatibility note. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

Clear verb ('Generate') plus resource ('an image') and names the underlying engine (Google Gemini). An agent can distinguish it from edit_image or transform_image by the 'from a text prompt' framing, though the differentiation is implicit rather than stated.

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 versus the 17 siblings, notably edit_image, transform_image, batch_generate, or estimate_cost. An agent must infer the boundary between text-to-image generation and image-to-image editing from names alone.

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, yet it adds nothing about failure modes (invalid/nonexistent ID), whether the generation must be complete, or side effects. It essentially restates the tool name and relies on the output schema to explain what is returned.

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

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

A single front-loaded sentence with no waste. It is efficient, though its brevity borders on under-specification rather than tightness.

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

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

For a simple one-parameter getter with an output schema and fully documented parameter, the essentials are covered. Still, the description says nothing about error behavior or what 'details' encompasses, leaving minor gaps for an agent calling it cold.

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 parameter is documented as coming from list_history, which is more informative than the description. The description adds no syntax or format detail 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?

States a specific verb ('Get') and resource ('details of a specific generation') scoped by ID, which is unambiguous. It does not name or differentiate itself from siblings like list_history, so it falls short of a 5.

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

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

The description gives no when-to-use guidance, prerequisites, or alternatives. The only hint that IDs come from list_history appears in the schema, not the description, so an agent gets no routing help from the text itself.

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

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

No annotations exist, so the description carries the disclosure burden, and it does not explicitly state that this is a non-mutating read-only introspection call or whether any auth/scope is required. It does disclose the content of the response (configuration, capabilities, tools), and the presence of an output schema removes the need to describe return structure, keeping the gap moderate rather than severe.

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

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

A single front-loaded sentence with the verb first and the three returned artifacts listed compactly. There is no filler and nothing that could be trimmed without losing 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 zero-parameter read tool with an output schema covering the return payload, the description is nearly sufficient: it names what is returned and requires no argument knowledge. The only missing piece is the read-only/self-inspection framing, which would help an agent trust it as a safe discovery call.

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 takes zero parameters, so the baseline is 4; there are no arguments whose meaning could be ambiguous or under-documented. Nothing in the description is needed to supplement 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?

Specific verb + resource: 'Get MCP server configuration, capabilities, and available tools' tells the agent exactly what is retrieved and enumerates the three content areas. It is clearly distinguished from the image-processing siblings, though it does not explicitly separate itself from discovery siblings like list_available_models or list_templates, which overlap in intent.

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 only implied: an agent can infer this is the introspection call to make before using the other tools, but the description never states when to prefer it over list_available_models or list_templates, nor any preconditions. No explicit when/when-not guidance is present.

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 disclosure burden. It does state the returned fields (speed, quality, resolution support, best use cases), which is useful, but says nothing about whether the list is static, requires auth, or is cached/rate-limited — modest coverage for an unannotated 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 short sentences, front-loaded with the verb and resource, and each adds information (what's returned, why to call it). Slightly verbose on the return-value recap given an output schema exists, but no real waste.

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

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

With zero parameters and an output schema present, the description need only justify when to use the tool, which it does. The remaining gap is minor: no guidance on what to do with the returned model identifiers before calling 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 tool takes zero parameters, so there is nothing to disambiguate and the baseline is 4. The description correctly implies a parameterless, no-argument call.

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 ('List all available image generation models') plus what the results contain. Sibling tools like list_templates and list_history clearly cover different resources, so the agent can distinguish it without reading schemas, though no sibling is named 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?

Provides clear usage context: 'Use this to pick the right model for your task,' which tells the agent when to call it relative to the generation workflow. It stops short of explicit exclusions or naming which sibling to call instead once a model is chosen.

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 disclosure burden. It never states ordering (newest first?), whether history is scoped per user/session/workspace, how far back 'recent' reaches, or that the call is non-destructive — only the verb 'List' weakly implies read-only.

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

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

One short sentence is front-loaded and free of waste, but at this length the brevity reflects under-specification rather than efficiency — there is no second sentence to establish scope or ordering.

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?

An output schema exists so return values need not be described, but for a tool with zero annotations the description should at least pin down ordering and history scope. Neither is present, leaving the agent to infer key behavior before calling.

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 limit, offset, and tool_filter are already fully documented with defaults (including the listed tool names). The description adds nothing to parameter meaning; 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 resource ('generation history'), plus a scope hint ('recent'), so the agent knows this is a read-only listing of past generations. It does not distinguish itself from the closest sibling, get_generation_details, or clarify that history spans the image tools listed as siblings.

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 on when to call this versus get_generation_details (single-entry lookup) or the individual generation tools. The only implied usage is 'recent', with no statement of recency window 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, and it discloses almost nothing: no indication of whether results are paginated, ordered, or scoped to a workspace, and no permission requirements. "List" implies a read-only operation, but that is inferred rather than 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?

A single front-loaded sentence with no filler; it earns its place but is thin enough that it leaves obvious questions unanswered. Efficient in form, minimal in content.

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

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

This is a simple zero-required-parameter listing tool with a fully documented schema and an output schema that covers return values, so the description need not explain them. What is missing is only the bridge to apply_template, keeping it below a 5.

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 category parameter's allowed values are fully enumerated in the schema, so the description need not repeat them. It adds no extra meaning about filtering behavior, so baseline 3 applies.

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

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

The description names a specific verb and resource ("List available prompt templates") and adds the domain (image generation), so the purpose is unambiguous. It does not differentiate itself from the closely related sibling apply_template, which is the main reason it stops short of a 5.

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 statement of when to use this tool versus siblings such as apply_template, list_history, or list_available_models, nor any mention of what to do with the returned templates. The only implicit cue is "available," which merely hints at a browsing use case.

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, so the description carries the full behavioral burden. It discloses that an AI/text model performs the rewrite and what dimensions get enriched, which is genuinely informative, but it omits cost implications (notably given the estimate_cost sibling), latency, and whether the original prompt is preserved or mutated.

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 purpose and the enhancement dimensions are front-loaded in the first two sentences with little waste. The closing line ('The #1 way to improve generation quality') is marketing filler rather than operational 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?

With an output schema present and full parameter coverage in the schema, the description need not explain return values, and it adequately conveys what the tool does and what the enhancement covers. The remaining gap is workflow placement relative to generate_image and cost expectations.

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%, including enumerated style values and model-override guidance, so the schema does the heavy lifting. The description adds no parameter-level meaning (no advice on when a style choice matters or what happens if style is null), leaving this at the baseline.

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

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

Specific verb ('enhance') plus resource ('prompt') and an explicit outcome ('better image results'), with a sentence on what the AI adds (lighting, composition, colors, textures, techniques). It is clearly a prompt-rewriting step rather than generation, but it never names generate_image or another sibling, so differentiation is implicit.

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 #1 way to improve generation quality' hints that this should precede image generation, but the description never states a workflow ('call before generate_image'), a when-not condition, or what to do if the prompt is already detailed. Usage is implied rather than instructed.

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 does disclose the mechanism (AI subject isolation) and the quality dependency, which is real behavioral context. However, it omits that the tool produces a new image file on disk, whether existing files can be overwritten, and any cost or rate considerations — material for an unannotated write-style 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 short sentences, front-loaded with the action, then mechanism, then the one caveat that affects success. 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?

An output schema exists and all three params are fully documented, so return values need not be explained. The remaining gap is the absence of any note about where the resulting file lands or whether the operation is billed, which an agent would want before invoking.

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 fully documents image_path, output_format, and output_filename. The description adds nothing about parameter behavior (e.g., that png preserves transparency for the cutout), 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+resource: 'Remove the background from an image,' which an agent can immediately distinguish from siblings like edit_image, transform_image, and upscale_image. It doesn't explicitly name the neighboring tools it is not, but the operation is unambiguous on its own.

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?

'Best results with clear subjects against distinct backgrounds' gives a quality precondition, which is useful, but the description never says when to choose this over edit_image/advanced_edit or what happens if the subject is unclear. Usage is implied rather than routed.

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 for a mutation-style image tool. It implies image modification but does not state whether the original file is overwritten, where output is written, whether permissions are required, or what side effects 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 single sentence is front-loaded and free of filler, but it is under-specified rather than genuinely concise for a tool with 16 parameters. It does not earn its brevity by conveying enough information.

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

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

Given the complexity of a 16-parameter image mutation tool with no annotations, the description is far too thin. Although an output schema exists and the input schema documents many parameters, the description still lacks operation semantics, file-handling behavior, and sibling differentiation.

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 75%, so most parameters are documented in the schema, but the description adds no meaning beyond it. With 16 parameters and several undocumented numeric fields such as x, y, width, and height, the one-sentence description does not compensate for the remaining gaps.

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 generic verb and resource ("Transform an image") and mentions the underlying library, but "transform" is broad and does not distinguish this tool from siblings like edit_image, advanced_edit, upscale_image, or remove_background. It also omits the actual supported operations that are buried in the schema.

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

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

There is no guidance on when to use this tool versus the many other image-manipulation siblings, nor any prerequisites or exclusions. An agent must infer its role entirely from the name and schema.

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 and delivers the most important non-obvious trait: the result is a generative re-render, so 'fine details can differ from the source' — a crucial caveat an agent could not infer from the schema. It omits cost/latency, whether existing files are overwritten, and where output lands when output_filename is null.

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, zero filler, with the core capability front-loaded and the sibling escape hatch placed second. Every clause earns its place.

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

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

An output schema exists so return values need no explanation, and all five parameters are fully described. The only remaining gap for a mutation-style, potentially costly generation tool is side effects (overwrite behavior, cost, latency), which the description does not address.

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 every parameter including the model choice and upscale_factor capping behavior is already documented in structured fields. The description reinforces the size-tier concept but adds no syntax or format detail beyond the schema; 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 ('Upscale an image') plus the mechanism ('re-rendered at a higher size tier with a Gemini image model') and the output tiers (1K/2K/4K). It explicitly contrasts itself with the sibling transform_image, so an agent can distinguish the two without opening either 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?

Names the alternative explicitly with its exact invocation: 'for exact pixel scaling use transform_image(operation="resize")'. The condition selecting each tool (generative upscale vs. deterministic resize) is stated, not inferred.

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