HTML/CSS to Image API

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

The annotations already declare readOnlyHint=true and destructiveHint=false, so the description adds some context beyond that by detailing the exact return fields and the meaning of overages_enabled. However, it does not disclose behavior like API rate limits or caching, but given the tool is simple and read-only, the description sufficiently supplements the annotations without contradiction.

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

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

The description is three sentences long, tightly packed with useful information. It leads with the core purpose)Skip the exact fields returned, then provides practical usage guidanceches and an interpretation of the fields. Every sentence contributes significant value without redundancy.

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

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

Given that the tool has no parameters and a read-only nature, the description is fully complete. It explains the output fields and their semantics, and it mentions usage scenarios. The presence of an output schema further fills in structural details, so nothing essential is missing for an agent to invoke and interpret the tool correctly.

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

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

The tool has zero parameterschers, so the description's job is to explain the output, which it does thoroughly. It defines what each field means and how to interpret them (e.g., the formula for remaining credits). This adds substantial value beyond the schema, which is empty.

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

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

The description clearly states the tool's purpose: it returns the organization's current image-credit usage, listing the specific returned fields. This is distinct from sibling tools that focus on creation, deletion, or listing of resources, making it clearly identifiable as a read-only utility.

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

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

The description explicitly says when to use it: 'to check capacity before rendering or explain a usage-limit error.' This provides clear context for use, and although it doesn't name specific alternatives, the purpose is so unique that the agent can infer it is the go-to for usage queries, distinguishing it from sibling tools that manage assets.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, and idempotentHint=false, so the safety profile is carried structurally. The description adds genuinely useful behavior beyond them: the default/variation merge rule and the plan-limit gating via get_max_batch_size. It does not elaborate on what the destructive aspect means for existing assets, which keeps it short of a 5.

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?

Five short sentences, each carrying a distinct load: purpose, prerequisite, limit rule, merge semantics, and return shape, with the alternative-tool guidance last. Nothing is padded and the primary purpose 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?

For a two-parameter tool with a full output schema, the definition covers everything an agent needs: the prerequisite call, the limit-0 fallback, the override relationship, the response fields (item), and the sibling alternative. Return-value details are not required since an output schema exists, yet the brief mention adds orientation without bloat.

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's own variations description already states that supplied parameters override default_options, so the description's merge sentence largely repeats structured data. It adds the useful batch-level framing but no new per-parameter syntax or constraints, matching the baseline for fully documented schemas.

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 opens with a specific verb and resource ('Creates multiple image assets') and immediately frames the two-parameter model (shared default_options + individual variations). It also names the sibling alternative ('individual creation tools'), so an agent can distinguish it from create_image and create_url_image without opening 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?

Explicit prerequisites and routing rules: 'Call get_max_batch_size first', a returned limit of 0 means fall back to individual image calls, and single-image or inline-preview needs should use the individual tools. This covers when-to-use, when-not-to-use, and which alternative to pick.

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

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

Adds substantial context beyond annotations: merge semantics ('Shared template_values merge recursively... arrays, scalars and explicit null replace defaults'), template_id/version reset behavior, deduplication ('Identical images reuse existing assets'), and return format. Doesn't contradict annotations. Missing explicit statement about the destructiveHint=true implication (e.g., overwrite semantics) and plan limit details, but otherwise covers behavioral traits well.

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

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

Dense but front-loaded: core purpose first, then operational constraints. Every sentence carries information, though the description is somewhat long and could be structured with bullets for the merge rules. 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?

Output schema exists, so return value explanation isn't required, yet the description still notes 'Returns IDs, URLs and format information in response order' which is helpful. Covers batch workflow prerequisites (get_max_batch_size, list_templates) and merge semantics. Missing explicit note on destructiveHint=true/overwrite behavior and plan limit details.

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 schema already documents both parameters in detail. Description reinforces merge behavior and ID resolution which are informative but largely duplicates schema guidance. 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?

Specific verb+resource: 'Creates multiple images from one or more saved templates.' Clearly distinguishes from create_templated_image ('Use create_templated_image for a single image') and from create_batch_images, and names it 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?

Explicit when-to-use and alternatives: 'Call get_max_batch_size first', 'resolve unknown IDs with list_templates', 'Use create_templated_image for a single image or inline preview.' Names specific sibling tools and the conditions that select them.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, and idempotentHint=false, so the safety profile is covered structurally. The description adds value by disclosing the return payload (asset ID, URL, format info in item) and the cost/latency tradeoff of include_image_data, though it says nothing about auth, rate limits, or plan restrictions that surface in the schema.

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

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

Four tight sentences, front-loaded with the core verb and resource, followed by sibling routing and two parameter hints in descending order of importance. No filler or repetition.

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 create operation with a rich nested schema, full annotations, and an output schema that documents return values, the description covers everything an agent needs: what it does, which sibling to choose instead, and the two non-obvious parameter behaviors.

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 nested content object is exhaustively documented, so the schema carries the burden and baseline 3 applies. The description's parameter notes (selector cropping, include_image_data for previews) largely restate what the schema already says rather than adding new 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?

States a specific verb and resource ('Creates an image from supplied HTML and CSS') and immediately differentiates itself from the two nearest siblings, create_url_image and create_template, by naming the condition that selects each. An agent can pick the right tool without opening a 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?

Explicit routing guidance: this tool for a single graphic/card/document, create_url_image for capturing an existing page, create_template for a reusable design. It also gives conditional advice for optional behavior (selector for cropping, include_image_data only when an inline preview is needed).

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false, destructiveHint=false, so the write/non-idempotent profile is covered. The description adds real context beyond that: what is returned ('in item, including id ... and domain_id') and the entitlement gate ('Requires a plan that supports OG configurations'). It omits auth specifics and rate limits, so not a full 5.

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

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

Four sentences, no filler, and the core purpose plus the branch-selection rule are front-loaded before the return/entitlement/alternative details. Slightly dense but every sentence carries weight.

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 complex nested-object creation tool with a declared output schema, the description supplies the mode selection, the plan requirement, the return shape, and the sibling routing. Nothing an agent needs to call it correctly is missing; return values need not be expanded further since an output schema exists.

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% on a single nested content parameter, so the baseline is 3. The description restates the html_css/templated split and the default_options/extract_values relationship, but that guidance is already in the schema's content description, so little new meaning is added.

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 ('Saves a new Open Graph image configuration for pages on an HTTPS website') and immediately disambiguates the two config_type branches. An agent can separate this from create_url_image, create_template, and update_og_config without opening any schema.

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

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

Explicitly routes between the two modes ('Use config_type: html_css ... or templated ...') and names the two nearest alternatives with their distinguishing conditions: create_url_image for a single page screenshot, update_og_config to change an existing configuration. Also states the plan prerequisite.

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

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

The description adds useful behavioral context beyond the annotations by stating that the response includes the proxy ID and configuration but omits passwords. It makes the mutation side effect obvious and provides security-relevant return behavior, though it does not describe error cases or name-conflict handling.

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 purpose and the important return behavior are front-loaded, and every clause adds operational value.

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

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

The input schema is complex with nested objectsaging and 100% coverage, and the output schema is noted as present, so the short description is sufficient for invocation. The only real gap is lack of explicit alternative routing, but that is already accounted for in usage_guidelines.

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 every nested property already has detailed meaning in the input schema. The tool description contributes no significant parameter-specific guidance beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses a specific verb and resource: it creates an organization proxy for routing image requests registry. This is clearly differentiated from sibling tools like update_proxy, delete_proxy, and get_proxy, and it tells the agent the core return value (ID and config without passwords).

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 verb 'creates' makes the lifecycle intent clear, so an agent can infer this is for new proxies rather than updates or deletes. However, the description never explicitly says to use update_proxy for changes or provides exclusions, leaving alternative routing 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?

Annotations only declare readOnlyHint=false, idempotentHint=false, and destructiveHint=false; the description adds genuinely useful traits beyond that: a side-effect write test before creation, best-effort cleanup ('deleted when possible'), conditional success/failure tied to the disabled flag, and a promise that the response excludes secret access keys. This materially exceeds what annotations alone provide.

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

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

Four dense sentences, front-loaded with the primary action. Every sentence earns its place: purpose, cleanup caveat, enable/disable condition, and response-content guarantee. No repetition of schema 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?

Despite the tool's complexity (7 provider variants, nested required fields, conditional secrets), the description plus a 100%-covered schema and an output schema cover everything an agent needs. Prerequisites like bucket existence and IAM trust policy live in the schema; the description supplies the behavioral glue (test flow, cleanup, conditional failure, no secrets in response).

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 carries parameter documentation, giving a baseline of 3. The description adds only marginal parameter meaning by clarifying the disabled flag's interaction with test results — a nuance the schema partially states ('Enabling requires a successful connection test'). No additional syntax or provider-specific info is needed from the description.

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

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

The description opens with a specific verb and resource — 'Creates a storage destination' — and adds a distinctive behavior (testing a write to the bucket) that sets creation apart from the update/get/delete/list storage-destination siblings. An agent can tell this from create_proxy, create_template, and update_storage_destination without opening 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?

The description gives clear conditional guidance: enabled destinations require a successful test while explicitly disabled destinations may be saved with a failed test. It does not explicitly name alternatives such as update_storage_destination for modifying existing destinations, but the create verb and clear context make the intended use evident.

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

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

Adds value beyond annotations by explaining what is returned (asset ID, URL, format information in item) and what include_image_data does. Annotations already flag destructiveHint and readOnlyHint, so the description does not need to repeat those. It does not expand on state-changing side effects, but the annotation covers that.

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

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

Four sentences with no filler; the main action and key workflow guidance are front-loaded. Each sentence contributes either to understanding the tool or to selecting the right template/version path. It is concise while remaining 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?

The description is complete for a tool with a rich input schema and output schema. It covers how to find a template, how to choose a version, what the response contains, and when to use create_template. No critical behavioral or workflow information is missing.

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

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

Schema description coverage is 100%, with detailed parameter descriptions already present. The tool description paraphrases some parameter behavior ('Omit version to use the latest version', 'include_image_data requests an inline preview') but adds little new semantic meaning beyond the schema. Baseline 3 is appropriate.

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

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

States a specific verb and resource: 'Creates an image from a saved template using template_values for its variable substitutions.' This clearly distinguishes it from generic create_image and ties it to templates. The mention of list_templates and create_template further clarifies its role among sibling tools.

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

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

Provides clear operational guidance: use a known template_id, resolve unknown names via list_templates, omit version for latest, and use create_template to save a reusable design before rendering. It does not explicitly say when NOT to use this tool versus create_image or create_batch_images, so it stops short of a full 5.

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

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

Annotations cover the safety profile (readOnlyHint=false, destructiveHint=true, openWorldHint=true), and the description adds material facts beyond them: rendering loads the page's resources and 'executes its JavaScript', plus that include_image_data triggers an eager inline preview with progress reporting. It does not explain the destructiveHint semantics (stored output) but adds real render-behavior context.

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

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

Five tight sentences, front-loaded with purpose, then rendering behavior, key controls, return shape, and sibling routing. No filler; each sentence earns its place.

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

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

For a complex tool with 100% schema coverage and an output schema, the description is nearly complete: purpose, JS execution behavior, cropping controls, and return fields (asset ID, URL, format via item) are covered. Minor gaps (plan-gated features like proxy/dedupe, the destructiveHint implication) are handled in the schema, so nothing critical 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%, so the schema already documents every parameter in depth. The description restates content.full_screen, content.selector, and include_image_data purposes that the schema already establishes, adding little beyond the structured fields. Baseline 3 applies.

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

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

Specific verb+resource: 'Creates a screenshot of an existing web page at content.url.' It immediately distinguishes itself from siblings by naming create_image (HTML/CSS directly) and create_templated_image (saved template). An agent can route correctly without opening any schema.

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

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

Routes to explicit alternatives with conditions: 'Use create_image when supplying HTML/CSS directly, or create_templated_image when rendering a saved template.' The core 'when' (an existing URL needs capturing) is clear from the first sentence, giving when-to-use plus named alternatives.

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

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

The annotation set already declares destructiveHint=true, idempotentHint=true, and readOnlyHint=false. The description adds the return behavior 'Returns true on success' and names the resource being destroyed, which is consistent with the annotations but not substantially richer than them.

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

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

The description is a single sentence that front-loads the action and then states the return behavior. There is no filler or redundant 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 one-parameter deletion tool with strong annotations and an output schema, the description is complete. It states what is deleted and what the successful result is, with no missing operational detail.

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 covers the single parameter 'id' with a clear description, reaching 100% coverage. The tool description adds no additional parameter semantics, so the baseline score of 3 is appropriate.

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

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

The description uses the specific verb 'Deletes' and identifies the exact resource, 'Open Graph image configuration'. This clearly distinguishes the tool from sibling delete_proxy and delete_storage_destination, as well as from create_og_config, update_og_config, and list_og_configs.

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

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

No guidance is given on when to use this tool versus alternatives such as update_og_config or create_og_config. There is also no mention of prerequisites or side effects beyond the deletion itself, leaving usage context implied rather than explicit.

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

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

The description goes beyond the destructiveHint and idempotentHint annotations by adding concrete behavioral details: repeated deletion succeeds and the tool returns true on success. This gives the agent confidence about idempotent retries and expected return behavior without contradicting the annotations.

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

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

The description is concise and front-loaded, with the core action stated first, followed by the consequence, idempotency note, and return value. Each of the three sentences adds distinct useful information with 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?

This is a simple single-parameter deletion tool with rich annotations, full schema coverage, and an output schema. The description covers the outcome, idempotent behavior, and return value, so nothing essential is missing for an agent to invoke it correctly.

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

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

The schema has 100% coverage, with the id parameter already described as 'ID of the proxy to delete.' The description does not add parameter-level detail, but the schema fully documents the only parameter, so baseline 3 is appropriate.

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

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

The description starts with the specific verb 'Deletes' and names the exact resource, an organization's proxy. It also states the purpose ('so it can no longer be used for rendering'), which clearly differentiates this from get, update, and list proxy tools.

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

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

The description clearly implies this tool is used when a proxy should be removed and made unusable for rendering. It does not explicitly name alternatives or state when not to use it, but for a straightforward deletion tool the usage context is reasonably evident.

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

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

The annotations already indicate destructive and idempotent behavior. The description adds meaningful context beyond this: stored credentials are deleted, the underlying bucket/files are preserved, repeated deletion succeeds, and it returns true on success. This gives the agent a fuller picture of side effects and behavior.

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

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

Four short sentences, each carrying distinct useful information: what is deleted, what is not deleted, idempotency, and return value. The most important scoping detail is front-loaded, and there is no redundant or filler text.

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 with a single required parameter, annotations cover the safety profile, an output schema exists, and the description covers side effects and success behavior. Nothing critical is missing for an agent to invoke this tool correctly.

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

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

The input schema has 100% description coverage for the single 'id' parameter, and the description does not add parameter-specific meaning. The schema fully documents what the parameter is, so the description adds no additional semantic value here.

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: 'Deletes the storage destination configuration and its stored credentials.' It clearly identifies what is being deleted and distinguishes this from sibling deletion tools like delete_og_config and delete_proxy by naming the storage destination resource.

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

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

The description provides clear scope boundaries, especially that the bucket and stored files are not deleted, but it does not explicitly state when to choose this tool over alternatives or mention related lifecycle tools like create_storage_destination or update_storage_destination. Usage is implied rather than directly guided.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by naming the exact returned values and clarifying that no storage destination ID input is needed. It does not contradict the annotations.

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

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

The description is two sentences, front-loads the return values, and immediately follows with actionable usage instructions. Every sentence earns its place with 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?

This is a low-complexity, zero-parameter, read-only tool with an output schema and rich annotations. The description fully covers what is returned and how to apply those values, so nothing needed for correct invocation is missing.

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

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

With zero parameters and 100% schema coverage, the schema leaves little to explain. The description still adds value by explicitly stating 'No storage destination ID is required,' which prevents confusion with sibling tools that do require a destination ID.

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: 'Returns the current organization's external_id and HCTI writer_role_arn.' It also distinguishes itself from storage-destination-specific tools by noting 'No storage destination ID is required,' making its purpose unmistakable.

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 for when to use this tool: when configuring S3 storage, specifically using external_id as sts:ExternalId and writer_role_arn as Principal.AWS. It does not explicitly name alternative tools or state when not to use it, but the 'No storage destination ID is required' line implies a distinction from get_storage_destination.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, covering the safety profile. The description goes beyond these by disclosing the specific return semantics: 'Returns 0 when batching is not supported' and the recommended fallback action. This adds behavioral context that annotations do not provide.

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

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

The description is a single, efficient sentence with two clauses: the core action and the special-case behavior. No filler, and the most important information (what the tool returns) is front-loaded before the conditional note.

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

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

For a parameterless getter, this is complete. It explains the primary purpose, the semantic meaning of the return value in cases where batching is unsupported, and provides a fallback instruction. The output schema presumably defines the exact response shape, so no further explanation is needed.

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

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

The input schema has zero parameters, and schema description coverage is 100% (since there are no params to cover). The description appropriately does not need to add parameter details. Baseline for 0-parameter tools is 4, and nothing here lowers that.

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 action ('Get'), a clear resource ('maximum number of images that can be created in a single batch'), and the scoping ('according to the user's plan'). It clearly distinguishes from sibling create_batch_images, which actually creates batches, by focusing on the limit rather than creation.

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

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

It provides actionable guidance for the 0-return case, instructing the agent to 'create images individually instead,' which implicitly tells when to avoid using the batch-creation sibling. It doesn't explicitly name the sibling tool or state 'use this before create_batch_images,' but the conditional fallback is a clear usage signal.

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

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

Annotations already declare the safety profile (readOnlyHint, idempotentHint, destructiveHint=false), so the bar is lower. The description still adds value by explaining that the read preserves existing settings ahead of a mutation and that returned options are mode-specific, though it says nothing about permissions or rate limits.

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

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

Two tight sentences, front-loaded with the core action and followed immediately by the usage routing. 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?

With an output schema present, the description needn't explain return values, yet it still sketches them; combined with full annotation coverage and a single fully documented parameter, nothing an agent needs to call this 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?

Single 'id' parameter with 100% schema description coverage, so the schema already documents it fully. The description adds no format, source, or constraint detail beyond what the schema provides; baseline 3 is correct 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?

States a specific verb and resource ('Retrieves one Open Graph image configuration by ID') and even enumerates the returned fields (mode, enabled state, domain_id, rendering options). An agent can distinguish it from list_og_configs and create_og_config without opening any schema.

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

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

Explicitly names two alternatives and the conditions that select them: 'Use this before update_og_config to preserve existing settings; use list_og_configs to discover an ID.' This is exactly the when/when-not guidance the dimension rewards.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint. The description adds meaningful behavioral context beyond that: it states that the username is returned and passwords are never returned, which is a security-relevant guarantee an agent needs to know.

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

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

Two concise sentences with no redundant content. The core action is front-loaded, and the additional return-value detail is both relevant and necessary.

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 a single required parameter, an output schema, and annotations covering read-only and idempotent behavior. The description fills the remaining gap by specifying return details, especially the password-never-returned guarantee, making it complete for safe invocation.

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

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

Schema description coverage is 100% and the only parameter 'id' is already documented as 'ID of the proxy to retrieve.' The description does not add extra parameter-level detail, 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 ('Gets') and resource ('organization's proxy configuration'), and clarifies what is included (enabled status, authentication configuration). This distinguishes it from sibling tools like create_proxy, update_proxy, and list_proxies.

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

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

The description implies the tool is for retrieving a single proxy configuration by ID, but it does not explicitly say when to prefer this over list_proxies or other related tools. Usage context is clear but not stated as explicit guidance with 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?

Annotations already indicate read-only, idempotent, and non-destructive behavior. The description adds meaningful context beyond annotations by explicitly stating that secret access keys are never returned, which is important behavioral information for an agent.

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

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

The description is two concise sentences that front-load the core purpose and add a valuable security-relevant note. Every sentence contributes information without redundancy.

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

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

For a low-complexity, single-parameter read tool with full schema coverage, rich annotations, and an output schema, the description is complete. It clearly states what is retrieved and the key non-returned value, leaving no significant gaps for correct invocation.

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

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

Schema description coverage is 100%: the single 'id' parameter is documented as 'ID of the storage destination to retrieve.' The description does not add parameter-specific detail, but the schema is sufficient, so the baseline score of 3 applies.

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

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

The description uses a specific verb ('Gets') and a specific resource ('a storage destination's configuration, enabled state, and most recent connection test result'). It clearly distinguishes from list_storage_destinations by focusing on a single destination and its detailed settings, and adds a differentiating security detail about secret access keys.

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

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

The description implies when to use the tool: when an agent needs a single storage destination's configuration, enabled state, or connection test result. However, it does not explicitly mention alternatives such as list_storage_destinations or state conditions for choosing this tool over siblings.

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

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

Annotations already establish the safe read profile (readOnlyHint, idempotentHint, non-destructive), so the bar is lower. The description still adds real behavior: descending creation ordering, inclusion of disabled configurations, and the null-cursor terminator for pagination.

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, all front-loaded with the highest-value facts first (scope/ordering, then pagination mechanics). No filler or restated name text.

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 shape need not be described; nonetheless the description names item.data and item.pagination.next_page_start, giving the agent enough to iterate pages correctly. Ordering, membership, and pagination are all covered for a two-parameter list tool.

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

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

Schema coverage is 100%, so baseline is 3, and the schema already documents count and page_start. The description goes further by explaining the cursor's origin (item.pagination.next_page_start) and the terminal condition (null cursor), which adds operational meaning for page_start.

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 ('Lists the organization's Open Graph configurations') and adds scope detail (descending creation order, includes disabled configs). It does not explicitly contrast itself with get_og_config, but the list-vs-get distinction is unambiguous given the resource is named.

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 rather than stated: this is the way to enumerate all OG configs (including disabled ones) when you don't have a specific ID. No explicit when-not or named alternative such as get_og_config is offered, leaving the choice to inference from the tool name.

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

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

Annotations already say read-only, idempotent, and non-destructive, and the description adds meaningful behavior beyond that: it includes disabled proxies by default, hides passwords in item.data, and explains pagination continuation with next_page_start and null cursor as the terminal marker. This gives an agent important operational expectations without contradicting annotations.

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

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

The description is compact and efficient: three sentences cover scope, security-sensitive return content, downstream use of IDs, and pagination. Every sentence earns its place and the most important information is front-loaded.

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

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

The tool is simple: two optional parameters, full schema coverage, a rich output schema, and annotations covering safety. The description fills the remaining gaps with pagination behavior, the password-exclusion guarantee, and how IDs should be used downstream. Nothing needed for correct invocation is missing.

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

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

Schema coverage is 100%, so the schema already documents count and page_start clearly. The description reinforces how page_start relates to item.pagination.next_page_start and when pagination ends, but it does not add substantial semantic meaning beyond what the input schema already states.

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 ('Lists the organization's proxies') and adds important scope detail ('including disabled proxies'), which distinguishes the list operation from get_proxy and the create/update/delete siblings. The downstream instruction about using an id as proxy_id further clarifies what the listed items are 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?

The description gives clear context for when to use this tool: to list all proxies, including disabled ones, and to obtain IDs for image or template requests. It does not explicitly name an alternative such as get_proxy for single-item lookups, but the purpose and pagination flow make the usage context reasonably clear.

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

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

Beyond the annotations (readOnlyHint, idempotentHint, destructiveHint), the description discloses key behaviors: disabled destinations are included, secret access keys are omitted from item.data, and pagination works via next_page_start with a null cursor marking the end. These are non-obvious traits that materially affect how an agent consumes the results.

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

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

Four sentences, each earning its place: purpose, security behavior, downstream usage of ids, and pagination. The most important scoping detail ('including disabled destinations') is front-loaded, and there is no repetition of schema or annotation 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, an explicit pagination contract, and annotation-provided safety profile, the description covers everything needed to invoke the tool correctly. The two optional parameters are fully documented in the schema, and the description clarifies the pagination flow and secret handling.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds a small nuance by stating that a null cursor marks the last page, reinforcing the schema's pagination guidance, but it does not meaningfully extend parameter meaning beyond what the schema already documents.

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 ('Lists') and resource ('storage destinations'), with a clear scope ('the organization's') and an important differentiator ('including disabled destinations'). This cleanly distinguishes it from sibling tools like get_storage_destination, create_storage_destination, and the list tools for other resources.

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 makes the list operation's purpose obvious and adds context about including disabled destinations, which implies when this is the right tool. It also tells how to use returned ids in image or template requests. However, it does not explicitly contrast with alternatives like get_storage_destination for a single destination, so it stops short of a fully explicit when/when-not statement.

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

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

Annotations already declare the read-only, closed-world, non-destructive profile, and the description adds real behavioral detail beyond them: newest-first ordering, that results land in `data`, and exactly when to stop paginating ('when data is empty or the cursor is null'). It does not discuss rate limits or failure modes, but the pagination contract is the meaningful extra.

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

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

Four short sentences, front-loaded with the scope, then usage, then the follow-up tool, then the pagination loop. Every sentence carries information an agent needs; nothing is padding.

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

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

With an output schema present, return values need not be described, and the definition still covers purpose, usage, response field, follow-on tool, and the full pagination protocol. Nothing needed to call 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%, so the baseline is 3, but the description adds cross-field meaning: it ties `max_version` to the response's `pagination.next_page_start` and pairs it with a concrete termination condition, which the schema alone states more mechanically.

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 ('Lists the connected organization's templates with their latest versions, newest first'), including ordering, and is clearly distinguishable from the sibling list_template_versions by scoping to templates rather than a single template's versions.

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

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

Explicitly says when to use it ('to find a template by name and inspect its content and rendering settings') and routes the agent onward ('pass an entry's id as template_id to create_templated_image'). It also gives the pagination loop condition, so the agent knows both why and how to call 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?

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=false, so safety is covered. The description adds meaningful context beyond that: newest-first ordering, the shape of returned data, and the exact cursor-based continuation and termination rules for paging.

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

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

Three tight sentences with zero filler: what it returns and ordering first, then when to use it and the sibling it pairs with, then the pagination rule. Every sentence carries distinct, 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?

With an output schema present, return values need not be spelled out, and the description still sketches the data payload. All three parameters are documented in the schema and the description adds the cross-call pagination workflow, so an agent has everything needed to call it repeatedly without looping incorrectly.

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 schema already documents count, max_version, and template_id. The description still adds value by explaining the pagination protocol end-to-end (feed next_page_start back as max_version unchanged), which goes beyond the per-parameter schema text.

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 precise verb+resource+scope: 'Lists saved versions of one template, newest first, with their content and rendering settings in data.' The 'one template' scoping and ordering clearly distinguishes it from the sibling list_templates, so an agent can pick the right tool 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?

Explicitly names use cases and downstream tools: inspect a template before updating it, or pick an older version for create_templated_image. It also gives a complete pagination loop ('pass pagination.next_page_start as max_version; stop when data is empty or the cursor is null'). No explicit when-not guidance (e.g., use list_templates to enumerate templates) keeps it from a 5.

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

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

Annotations cover the mutation profile (readOnlyHint=false, destructiveHint=false, idempotentHint=false, openWorldHint=false), so the description's job is to add what they don't say. It does: the consent gate before submission, the privacy prohibition on secrets/PII, and that a confirmation message plus feedback ID is returned. It stops short of describing delivery guarantees or rate limits, but the added context is substantive.

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

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

Front-loads what the tool does and what it is for, then layers on consent and privacy constraints. Four sentences with essentially no filler, though the closing sentence about the return value is largely redundant given the output schema exists.

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 required string parameter), annotations carry the safety profile, an output schema exists, and the description still supplies the two things an agent could get wrong: consent before sending and excluding confidential data. Nothing needed to call 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 description coverage is 100%, so all three parameters (message, subject, callback_url) are already documented, including the 20-character minimum and the null defaults. The description's 'what you tried, what you expected, what happened' phrasing reinforces the message parameter but adds no syntax or format detail beyond the schema, so baseline 3 applies.

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

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

States a specific verb (Sends) and resource (feedback to the HCTI team) and enumerates the subject matter it covers: the product, its API, and its MCP tools. No sibling tool does anything similar, so the agent can immediately place it among the create_*/update_*/list_* CRUD tools without ambiguity.

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

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

Explicitly enumerates when to use it (bugs, unexpected rendering results, feature requests, confusing behavior or docs, improvement suggestions) and adds a hard precondition: 'If the user did not ask you to send feedback, ask them before submitting.' It also gives an exclusion on content (no API keys, credentials, tokens, or personal/confidential data), which is actionable when/when-not guidance rather than implied usage.

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

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

Annotations already flag destructiveHint=true and idempotentHint=true, but the description goes further and explains exactly what the destruction looks like: omitted optional settings are cleared or reset to defaults, and only disabling is accepted after a plan downgrade (other changes silently ignored). It also discloses downstream impact on subsequent image requests and the response location, none of which the annotations carry.

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?

Five short sentences, purpose and replacement semantics front-loaded, then prerequisites, then edge cases. No sentence is redundant against the schema or the annotations; the plan-downgrade caveat earns its place by preventing failed partial updates.

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 deeply nested, config_type-discriminated payload with an output schema present, the description supplies everything structured data cannot: full-replacement semantics, the preserve-via-get_og_config workflow, and plan-gated degradation. Return values are already covered by the output schema, so nothing needed 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?

With 100% schema description coverage the baseline is 3, but the description adds real semantics beyond the schema: content is a full replacement rather than a patch, it must match the chosen config_type, and the enabled/disabled inversion is called out. It does not elaborate per-field defaults, which the schema already covers well.

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

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

States a precise verb and resource ('Replaces an existing Open Graph image configuration') plus the return contract ('returns the saved configuration in item'). The word 'Replaces' immediately separates it from the sibling create_og_config, which builds a new one, so an agent can route correctly without opening a 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?

Gives a concrete prerequisite ('Call get_og_config first to inspect settings that should be preserved'), the replacement discipline ('Supply the complete configuration for the chosen config_type'), and a plan-gated edge case where only disabling is honored. It names no alternative update path or when-not-to-use sibling, so it stops one step short of full routing guidance.

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

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

Beyond the annotations, it discloses the destructive full-replacement behavior, explains that omitted optional settings including authentication are cleared, and captures the non-obvious retain_password rule. It also tells the agent that returned configuration excludes passwords. This is precisely the kind of behavioral context that reduces mis-invocation.

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 and no filler. The full-replacement behavior is front-loaded, followed by the critical edge cases, and then the output behavior. Every sentence earns its place.

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

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

Given the rich nested schema, existing annotations, and output schema, the description covers the important nuances: overwrite semantics, clearing of omitted values, password retention requirements, and password redaction. Nothing substantial that an agent needs in order to call the tool 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?

The schema already provides 100% parameter coverage with detailed descriptions, so the description gets no credit merely for repeating those fields. However, it does add cross-cutting meaning by stating that omitted optional settings are cleared and by summarizing the authentication retention rule, which is useful before an agent reads through the nested 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 states a specific verb and resource: it replaces the complete proxy configuration. The phrase 'complete proxy configuration' clearly distinguishes it from create_proxy, delete_proxy, or get_proxy, so an agent can identify the right tool without opening 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?

The description makes clear that this is for full replacement of an existing proxy and flags the most important consequence: omitted optional settings are cleared. It does not explicitly name create_proxy or delete_proxy as alternatives, but the update-versus-create distinction is contextually clear enough for an agent to route between them.

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

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

Discloses non-obvious behaviors well beyond the annotations: omitted settings are cleared or reset, secret retention requires retain_secret_access_key: true with unchanged provider and key ID, changed connections and re-enabling trigger a bucket write test, failed tests prevent saving an enabled request, and plan downgrades restrict changes to disabling only. This complements rather than contradicts destructiveHint: true.

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?

Five sentences with zero filler: purpose is front-loaded first, followed by the clearing/secret caveat, the write-test side effect, the failure behavior, and the plan restriction. Every sentence earns its place and no information is repeated from the schema.

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

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

For a complex mutation tool with nested objects, seven provider variants, secret-handling rules, test side effects, and plan constraints, the description addresses every non-obvious behavioral aspect an agent needs. Combined with 100% schema coverage and an output schema, nothing critical for correct invocation is missing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds the global rule that omitted optional settings are cleared or reset, and highlights retain_secret_access_key's interaction with provider and access-key changes — cross-object semantics that the individual schema property descriptions do not convey.

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?

Opens with a specific verb-resource pair: 'Replaces a storage destination's configuration.' This clearly distinguishes it from the close siblings create_storage_destination, delete_storage_destination, get_storage_destination, and list_storage_destinations. The replacement semantics are unambiguous.

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

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

The replace semantics and required id parameter make clear this tool modifies existing destinations, and the plan-downgrade note adds useful conditional context. However, it never explicitly names create_storage_destination as the alternative for new destinations, so it provides clear context without stated exclusions.

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