imagelato

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

Explicitly discloses that it changes stored data, is non-idempotent, fires a 'project.created' webhook, and that repeating it creates another project. This aligns with and adds detail beyond the annotations (destructiveHint=true, idempotentHint=false), and the user-confirmation instruction adds further behavioral context. No contradiction.

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

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

Two sentences that front-load the action, then state side effects, then give a user-confirmation instruction. No filler, 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?

For a simple create operation with one parameter, the description covers the action, side effects, idempotency, and a safety instruction. An output schema exists, so return value explanation is not required. Nothing an agent needs 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?

The input schema fully documents the single 'name' parameter with constraints and a description (1-120 characters). The tool description adds no additional meaning about the parameter beyond the schema, so the baseline of 3 applies given 100% schema coverage.

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

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

States the specific verb 'create' and resource 'one Imagelato project in the caller organization', which clearly distinguishes it from sibling tools that get, list, update, or delete projects. The purpose is unambiguous and unique among the provided 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?

Provides a clear usage instruction to confirm the name with the user before invoking, which is a valuable safety guideline. It does not explicitly name alternative tools or when-not-to-use conditions, but the create vs. get/list/update/delete context is implicit from the tool name and description. No misleading 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?

Annotations already flag mutation and non-idempotence, but the description adds valuable context: it changes stored data, repeating can create another template, it does not generate an image, and user confirmation should precede invocation. This goes well beyond the structured 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?

Three sentences front-load the core action and then add high-value caveats about non-idempotence, image generation, and user confirmation. There is no filler or repetition of schema details.

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 full schema coverage, an output schema, and informative annotations, the description supplies the missing context: repeat behavior, no image output, and confirmation requirements. Everything needed to invoke this tool correctly is covered.

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 parameters are already fully documented with types, defaults, enums, and patterns. The description only adds that project, name, formats, and sizes should be user-confirmed, which is a usage caveat rather than new 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?

States the specific verb 'Create' and resource 'Imagelato resizing and reformatting preset,' making it clear this is a template-creation operation. The phrase 'does not generate an image' and 'in an accessible project' further distinguish it from related operations.

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

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

Implies use when the user wants a new template preset and instructs confirming project, name, formats, and sizes before invoking. However, it does not explicitly name alternatives like update_template or describe when not to use this tool.

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

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

Annotations already flag destructive and idempotent hints, but the description adds substantial behavioral context: permanent deletion, inclusion of original/output/resized/reformatted files, the fired 'batch.deleted' webhook, and the required user confirmation. This goes well beyond the bare annotation flags without contradicting 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?

Three tightly written sentences cover the deletion scope, irreversibility, webhook side effect, and user-confirmation requirement. There is no filler, redundancy, or repetition of structured schema fields.

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 single-parameter destructive tool, the description plus annotations and output schema fully cover what an agent needs: what is deleted, side effects, irreversibility, the confirmation step, and where to source the batch id. Return value behavior does not need to be described because 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%; batchId is already documented with exact-id semantics and a source hint ('obtain it from list_batches or get_batch'). The tool description reinforces 'exact id' but contributes no new parameter-level syntax or format details. The schema carries the parameter burden, 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 states a specific action ('Permanently delete'), a precise resource ('one tenant-scoped Imagelato batch by exact id'), and the deletion scope ('original, primary output, and resized or reformatted files'). It clearly distinguishes delete_batch from its siblings because none of the listed siblings is a delete operation.

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 an actionable precondition: 'Confirm the exact batch with the user before invoking.' The schema further reinforces usage by saying the id should be obtained from list_batches or get_batch. It does not explicitly state when not to use the tool, but since it is the only delete-batch sibling, this is a minor gap.

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 cover read-only, idempotent, non-destructive, and non-open-world behavior, so the safety profile is known. The description adds useful behavioral context beyond annotations: the signed-in organization scope, the 'processed' batch constraint, the allowlisted metadata, and the 20-variant cap. No claims 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?

Two sentences with no waste: the first states the core action and target, and the second gives return constraints and a key non-effect. The description avoids repeating schema properties and front-loads the most decision-relevant 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 single-required-parameter tool with a full output schema and rich read-only annotations, the description is complete enough for correct invocation. It covers the selection criterion (exact id), the scope (signed-in organization), the return type, and behavioral limits. An agent does not need additional guidance to use 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 schema already documents batchId as the exact batch id from list_batches with length constraints, so schema description coverage is 100%. The description adds only minor parameter-related context such as 'exact id' and organization scope, which is helpful but not substantial enough to exceed the baseline for fully documented parameters.

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 ('Fetch'), identifies the resource ('one processed image batch'), and states the retrieval method ('by exact id') and result shape ('allowlisted metadata plus at most 20 first-party resized or reformatted variants'). It also differentiates from mutating operations by explicitly stating it does not create or transform media, making it clearly distinct from siblings like delete_batch.

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

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

The description clearly implies when to use the tool: when the agent has a specific batch id and needs the batch-detail view for the MCP App. It provides an explicit exclusion ('does not create or transform media') but does not explicitly name alternatives such as list_batches for finding ids or delete_batch for removing a batch, leaving a small inference gap.

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 cover readOnly, idempotent, and non-destructive behavior, so the bar is lower. The description adds value by disclosing that the response is an 'allowlisted project configuration' without organization ownership fields, which is a meaningful behavioral detail beyond 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?

Two sentences with no filler, the key scoping and matching rules are front-loaded, and every phrase contributes meaning. The description is easy to parse quickly.

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 one well-documented parameter, an output schema present, and annotations covering safety and idempotency, the description is fully sufficient for an agent to invoke this tool correctly. No critical 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%, and the schema already explains that projectIdOrName is an exact project id or name from list_projects. The description restates this but adds no significant new parameter semantics, so the baseline 3 applies.

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

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

The description uses a specific verb ('Fetch') with a clear resource ('one Imagelato project') and scope ('in the signed-in organization'). It also specifies matching by exact id or name and notes the return contains an allowlisted configuration, making it clearly distinct from list_projects and other 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?

The description tells the agent exactly how to identify the project ('exact id or name from list_projects') and scopes it to the signed-in organization. It doesn't explicitly name alternatives or state when not to use it, but the context is clear enough for correct selection among 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 declare readOnlyHint, idempotentHint, and non-destructive behavior. The description adds value beyond this by noting determinism, that the response is an allowlisted configuration, and that no media is processed or generated, which clarifies side-effect expectations 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?

Two compact sentences convey the core purpose, scope, determinism, and a key exclusion without redundancy. Key constraints are front-loaded and every word earns its place.

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

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

For a simple, single-parameter read-only tool with rich annotations and an output schema, the description is complete. It specifies what is returned (allowlisted configuration), scope, lookup semantics, determinism, and non-processing behavior, leaving no critical ambiguity for 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 single parameter is already well documented as an 'Exact template id or name from list_templates'. The description reinforces the exact-match semantics and signed-in organization scope, but it does not add meaningful information beyond what the schema already provides.

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

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

The description names a specific verb ('Fetch') and resource ('one deterministic Imagelato resizing and reformatting preset'), and clarifies it fetches by exact id or name. It also distinguishes itself from media-processing tools by stating it does not process or generate media, and the singular focus differentiates it from sibling list_templates.

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 usage context is clear: fetch a single preset in the signed-in organization by exact id or name, and it explicitly excludes media processing. It does not name alternative siblings like list_templates or update_template, but the 'exact id or name' constraint and deterministic nature give the agent sufficient context for when 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, idempotentHint=true, destructiveHint=false, so the agent knows it's safe. The description adds that it returns compact processing metadata and does not read the shared object bucket or process media, which is useful behavioral context beyond the annotations. No contradiction.

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

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

Two sentences with no waste. The core purpose is front-loaded, followed by the explicit non-scope statement, and the cursor usage is mentioned. Every sentence adds value.

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

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

The tool is a simple paginated list with a clear output schema (indicated by has output schema true). The description covers the key aspects: pagination, optional filter, scope (organization), and what it does not do. Nothing an agent needs 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% (all parameters have descriptions in the schema). The description mentions the optional project id and the cursor for pagination, but does not add new meaning beyond the schema's parameter descriptions. Baseline 3 is appropriate when the schema covers all parameters.

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

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

The description clearly states the tool lists a bounded page of processed image batches in the signed-in organization, with optional exact project id filtering. It distinguishes from siblings by explicitly noting it does not read the shared object bucket or process media, and the sibling list (list_projects, list_templates, list_webhook_subscriptions) covers other resource types, making this specific to batches.

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 states when to use it (listing batches with optional project filter) and mentions the cursor to continue pagination. It doesn't explicitly say when not to use alternatives, but the context of siblings and the phrase 'does not read the shared object bucket or process media' implies it's a lightweight read, helping an agent decide it's not the heavy processing tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering safety. The description adds behavioral context beyond those: it reveals the result is a bounded page (pagination) and that only ids and names are returned, which is not implied by annotations. This enriches the agent's understanding of the response shape and iteration.

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

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

Two sentences, no wasted words. The primary purpose and scope are front-loaded, followed by the return field scope and pagination instruction. Every clause earns its place, and the structure is immediately scannable.

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 (signal indicates true), so the description does not need to detail return values. It covers the key operational details: bounded page, returned fields, and cursor continuation. It does not mention default sorting or behavior with no results, but these are likely captured in the output schema or are minor for a list tool. Overall, sufficient 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?

Both parameters (limit and cursor) have full descriptions in the schema, so schema coverage is 100%. The description's mention of 'opaque cursor' mirrors the schema's description without adding new meaning or constraints. The baseline of 3 applies because the description does not supplement the schema with additional parameter-specific guidance.

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 ('List') and resource ('projects') and clarifies scope ('bounded page' and 'in the signed-in organization'), clearly distinguishing it from siblings like list_batches and list_templates. It also notes the return fields (ids and names) which aligns with the intended follow-up use, leaving no ambiguity about the tool's purpose.

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

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

The description provides clear context for when to use the tool: it returns only ids and names needed for follow-up project, template, and batch calls, implying it's the entry point for those operations. It also gives pagination guidance ('Use the opaque cursor to continue'), but it does not explicitly state when not to use it or name alternatives, though the sibling set makes this inferable.

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 false, so the safety profile is covered. The description adds meaningful context about bounded pagination, excluded fields, and organizational scope, which go beyond the annotations without contradicting 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 two sentences with no wasted words. The main purpose is stated first, followed by exclusions and cursor guidance, making it easy for an agent to parse quickly.

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

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

For a read-only listing tool with two optional parameters and an output schema, the description fully covers what the tool returns, its organizational scope, paging behavior, and excluded fields. Nothing an agent needs 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%, with both limit and cursor already described in the schema. The description reinforces the cursor's purpose but does not add substantial meaning beyond the schema fields.

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: 'List a bounded page of display names and roles for members of the signed-in organization.' It also clarifies what is not included (emails, ids, phone numbers, etc.) and distinguishes itself from the sibling list tools by describing a distinct resource and output focus.

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 communicates the organizational scope and the pagination usage ('Use the opaque cursor to continue'). It does not explicitly provide exclusionary guidance versus alternatives, but the resource is distinct enough from all siblings that no confusion is likely.

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 provide readOnlyHint=true, idempotentHint=true, and destructiveHint=false, covering the safety profile. The description adds extra behavioral context: 'deterministic' results and 'does not process or generate media', which clarifies that this tool is purely a listing operation with no side effects beyond pagination. No contradictions with annotations.

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

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

The description is two sentences long, front-loaded with the core purpose and scoping constraints, and includes a clarifying caveat about not processing media. Every sentence serves a purpose with zero fluff, making it highly efficient and easy to parse.

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

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

Given the tool's simplicity (list with pagination and optional filter), the presence of a full output schema, and annotations covering safety, the description is complete. It explains the bounded page nature, the optional filter, and the opaque cursor, which is all an agent needs to call it correctly. No critical 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%: all three parameters (limit, cursor, projectId) are documented in the schema. The description adds minimal extra meaning—it mentions the opaque cursor and optional filter, but these are already implied by the schema. The description does not provide additional format or usage details beyond what the schema offers, so it meets the baseline for high coverage.

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

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

The description clearly states the verb 'List', the resource (deterministic Imagelato resizing and reformatting presets), and the scope (in the signed-in organization, optionally filtered by project id). It also explicitly distinguishes itself from media processing tools by stating 'It does not process or generate media.' This gives an agent a precise understanding of the tool's function.

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

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

The description implies usage: it is for listing templates with pagination and optional filtering. However, it does not explicitly mention when to use this over alternatives like get_template or list_projects. There is no explicit when-not guidance or reference to sibling tools, so the usage context is 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?

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, and the description adds substantial behavioral context beyond them: bounded pages, exact project filtering, the exclusion of full URLs/secrets/ownership fields, and the 20-consecutive-failures disable rule. This materially helps an agent understand side effects and data exposure.

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 carry exactly the needed information: what the tool lists, what fields are included/excluded, the failure threshold, and pagination behavior. It is front-loaded with the primary action and avoids repetition or filler.

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

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

The description is complete for a read-only list tool. It covers purpose, filtering, pagination, field privacy, and behavioral edge cases. An output schema exists, so return-value details are already available, and the annotations cover the safety profile.

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 reinforces the cursor as opaque and paginated and mentions exact project id filtering, but these mostly restate the schema descriptions. It does not add meaningful new parameter semantics beyond what the schema already provides.

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

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

The description names a specific verb and resource: listing a bounded page of webhook delivery health in the signed-in organization. It also sharpens the scope by naming supported fields and exclusions, and it is clearly distinct from sibling list_* tools because it targets webhook subscriptions.

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

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

It gives clear context for when to use the tool: for webhook health listing in the signed-in organization, optionally filtered by exact project id. It does not explicitly name alternatives or exclusions, but the narrow webhook-specific purpose plus pagination guidance makes invocation conditions clear enough.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint, but the description adds valuable behavioral context: 'bounded', 'at most eight recent processed batches', 'first-party asset URLs', and explicit exclusions of bucket enumeration and media transformation. This goes beyond the annotations and informs the agent about limits and side-effect-free 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?

The description is two sentences with zero redundancy. The primary action and scope are front-loaded, followed by a compact specification of contents and explicit exclusions. Every phrase earns its place, and the length is proportionate to 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?

Given the output schema exists, return values are already covered. Annotations cover safety and idempotency. The description adds the precise scope, content limits, and non-behaviors, leaving no critical gap for an agent to invoke the tool correctly. The definition is complete for a read-only overview 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?

The single parameter projectIdOrName is fully described in the schema (100% coverage) as 'Exact Imagelato project id or name, at most 200 characters'. The description adds no additional parameter-specific guidance, so it neither improves nor detracts from the schema's information; 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 states a specific verb ('render'), a precise resource ('bounded overview for one Imagelato project'), and explicitly differentiates from siblings by listing what it does not do (enumerate the shared object bucket, create or transform media). This makes the tool's purpose unmistakable and distinct from get_project or list_batches.

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 scopes usage to 'the signed-in organization' and clarifies the tool's non-destructive nature by stating it neither enumerates the bucket nor transforms media. However, it does not explicitly name an alternative like get_project for full details or list_batches for all batches, leaving some inference about when to prefer this overview tool.

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

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

Adds significant behavioral context beyond annotations: it discloses that the operation changes stored data (consistent with destructiveHint=true), fires the template.updated webhook, cannot move the template to another project, and does not generate an image. These details are not present in the annotations and give the agent a precise understanding of side effects and limitations.

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 sentences, each carrying distinct information: the action and scope, side effects and constraints, and a user-confirmation directive. No filler, and the most critical information (what it does and how it resolves the target) 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 4-parameter mutation tool with an output schema and annotations, the description covers all necessary operational details: target resolution, side effects, immutability constraint, non-image-generation, and confirmation requirement. The output schema handles return value documentation, so nothing essential 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 parameters are already well-documented. The description adds value by clarifying the resolution semantics for templateIdOrName (exact id or name) and the partial-update concept ('selected fields'), which the schema does not explicitly state. This elevates it above the baseline 3.

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 (overwrite), resource (Imagelato resizing and reformatting preset), and resolution method (exact id or name). Clearly distinguishes from siblings like add_template (creates new) and get_template (reads). The description also notes what it does not do (generate an image) and a key constraint (cannot move project), making its purpose unambiguous.

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

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

Provides clear context for when to use (updating an existing template) and includes an explicit user-confirmation requirement. It does not explicitly name alternatives like add_template, but the 'does not generate an image' and 'cannot move to another project' statements help delimit its scope. A dedicated when-not-to-use note would push this to 5.

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