Imagelato Image Processing

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

Annotations already declare readOnlyHint=false, idempotentHint=false, and openWorldHint=true, and the description reinforces the non-idempotent nature while adding a genuinely new side effect: it fires the project.created webhook. It does not explain the destructiveHint=true annotation (what, if anything, gets displaced), leaving one behavior unexplained.

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

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

Three short sentences, front-loaded with the trigger condition and tightly scoped. 'Each call creates another project' mildly restates the non-idempotency annotation, but the redundancy is small and arguably useful emphasis.

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 creation tool with an output schema and rich annotations, the description covers purpose, trigger, exclusions, non-idempotency, and the webhook side effect. An output schema exists, so the brief mention of returned fields is sufficient and nothing an agent needs 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 single 'name' parameter is already documented with its 1-120 character bounds. The description adds no format, uniqueness, or naming-convention guidance beyond the schema, so the baseline of 3 applies.

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

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

The description gives a specific verb and resource ('create one Imagelato image project') and states the grouping purpose (processed batches and resize presets). It also draws an explicit boundary against a related sibling capability ('Not for adding a resize preset'), so the agent can separate this from add_template.

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 supplies a clear triggering condition ('Use this when the user wants to create one Imagelato image project') plus an exclusion, and warns that 'Each call creates another project'. It stops short of naming an alternative sibling tool for edge cases, so it is strong but not fully routed.

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

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

Goes well beyond the annotations: it states that each call creates another preset (explaining the non-idempotentHint), that template.created fires to configured webhooks, and critically that it does not process an image, which prevents a likely misuse given the destructiveHint.

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-loaded with the trigger, then defaults, side effects, and the exclusion — every clause carries information. It is slightly dense with three separate clauses in one sentence, but nothing is wasted.

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 full schema coverage and an output schema, the description supplies everything extra an agent needs: the trigger, the side effects, the image-processing misconception, and the sibling boundary.

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

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

Schema description coverage is 100%, so the schema already documents name, sizes, formats and projectId, including the enum set and defaults. The description restates the defaults (jpg/webp; 512, 256, 128, 64) without adding format, syntax, or interaction rules beyond what the schema 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?

States a specific verb and resource ('create one Imagelato preset that specifies widths and formats') and its downstream effect ('for future image processing'), which clearly separates it from update_template and list_templates among 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?

Opens with an explicit trigger ('Use this when the user wants to create...') and closes with an explicit exclusion ('Not for editing a preset'), routing the agent to the update sibling without requiring schema inspection.

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 destructiveHint=true and idempotentHint=true, but the description adds substantial detail beyond them: the original, main output, and every resized/converted file are erased, the batch.deleted webhook fires, and there is no undo. It also states the return payload (id, slug, project), which is exactly the kind of operational context an agent needs before an irreversible call.

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

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

Three tight sentences with zero filler: trigger first, then consequences, then the exclusion. The irreversible nature is front-loaded and nothing is repeated from the schema or annotations.

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 covers trigger, blast radius, side effects (webhook), reversibility, and return shape. Even though an output schema exists, the extra mention of the returned fields is harmless, and nothing an agent needs to call this safely 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?

Only one parameter exists and schema description coverage is 100%, so the schema already documents batchId fully. The description adds the notion of operating on exactly one batch but no format, sourcing, or syntax detail beyond what the schema provides, which is the expected baseline 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?

States a specific verb (permanently delete) and resource (one Imagelato processed-image batch and its associated files), and explicitly carves out what it is not for ('Not for removing a resize preset'). This lets an agent distinguish it from get_batch and list_batches 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?

Opens with an explicit trigger ('Use this when the user wants to permanently delete...'), giving clear context for invocation. It also supplies a when-not clause about resize presets, though it names the excluded action rather than a sibling tool to use instead, so routing is slightly less complete than a fully explicit alternative.

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 and openWorldHint=false, so the safety and idempotency profile is fully covered. The description's remaining substance is largely return-shape detail (fields, up to 20 variants), which the existing output schema already carries; the 20-variant cap is the one piece of genuinely additive behavioral context.

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

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

Front-loaded with the usage trigger, then the return payload, then the exclusion. Three sentences with no filler, though the enumeration of returned fields is somewhat redundant given the output 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 read-only, single-parameter lookup with a full output schema and rich annotations, the description covers trigger, scope and exclusion adequately. The only mild gap is not naming list_batches as the multi-batch alternative.

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?

There is a single required parameter with 100% schema description coverage ('Exact batch id'), so the schema already does the work. The description adds nothing about the id's format or source beyond what 'one existing batch' implies, which is the expected baseline 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?

States a specific verb (read) and resource (output metadata and first-party file links for one existing processed-image batch), and the phrase 'one existing batch' implicitly separates it from the list_batches sibling. It stops short of naming list_batches or delete_batch, so the sibling differentiation is left partly to inference.

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?

'Use this when the user wants to read ... for one existing ... batch' gives a clear trigger condition, and 'Not for resizing or converting a new image' supplies an explicit exclusion. Neither names the actual sibling tool an agent should fall back to, so it is clear context without full alternative routing.

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 readOnly, idempotent, non-destructive, closed-world behavior, so the safety profile is covered. The description adds value beyond that by disclosing the exact-match lookup semantics and the not-found outcome, though it does not discuss lookup cost or any partial-match 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?

Two sentences, no filler, with the primary use case front-loaded and the exclusion last. 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?

For a single-parameter read tool with annotations covering the safety profile and an output schema covering the return shape, the description supplies everything else an agent needs: exact-match selection, the returned fields, and the not-found case.

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 fully documented ('Exact project id or name'), so the schema carries the burden. The description's phrase 'selected by its exact name or identifier' reinforces the same idea with no added syntax, format, or ambiguity guidance, so baseline 3 applies.

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

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

States a specific verb and resource: 'read metadata for one Imagelato image project selected by its exact name or identifier.' It also names the shape of the identifier (exact name or id) and explicitly excludes a nearby sibling use case ('Not for a quick look at its latest processed images'), so an agent can separate it from list_projects and show_project_overview 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 clear trigger ('Use this when the user wants to read metadata for one project') and a negative condition ('Not for a quick look at its latest processed images'). The alternative tool is only implied rather than named, so routing is clear but not fully 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 cover readOnly/idempotent/non-destructive/openWorld=false, so the bar is low. The description still adds value by disclosing that lookup is exact-match only and that a not-found outcome is possible, which annotations cannot express.

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

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

Three short sentences, front-loaded with the trigger condition, then return content, then the exclusion. 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?

With an output schema present, the description needn't enumerate return fields, and it correctly focuses on trigger, exactness, and the not-found case. Only the modify-path alternative tool routing is left implicit.

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?

Only one parameter and schema coverage is 100%, so the schema already documents templateIdOrName as 'Exact template id or name.' The description echoes the exactness requirement without adding format, case-sensitivity, or fallback behavior, so baseline 3 is right.

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 (read) + resource (one Imagelato resize preset) + the selector (exact name or identifier). It also implicitly separates itself from list_templates (plural listing) and update_template via 'Not for changing it.'

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

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

Gives a clear trigger ('when the user wants to read one... selected by its exact name or identifier') and an explicit exclusion ('Not for changing it'), which rules out update_template. It stops short of naming the alternative tool for the modify case, so an agent must infer the routing.

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 readOnly, idempotent, non-destructive and closed-world behavior, so safety is covered. The description adds real behavioral context beyond that: which fields each batch carries (id, slug, output format, template id) and the default page size of 25, implying cursor pagination. It does not cover ordering 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?

Three short sentences with no filler: trigger and scope first, return shape and pagination second, exclusion last. Every sentence carries distinct information and the most important framing 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?

An output schema exists, so return values need not be spelled out further, and annotations carry the full safety profile. For a zero-required-parameter, read-only list tool, the description supplies everything an agent needs: trigger, scope, pagination default, and the boundary against get_batch.

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 descriptions already explain limit (defaults to 25), cursor (nextCursor of previous page), and projectId (all projects when absent). The description restates the project scoping and page-size default but adds no format or edge-case detail beyond the schema, so the baseline of 3 applies.

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

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

Specific verb (list) plus resource (processed-image batch metadata) and an explicit scope qualifier (optionally scoped to a project). The closing sentence 'Not for one batch's variant files and links' separates it from get_batch, so an agent can distinguish it from siblings 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 clear trigger condition ('Use this when the user wants to list existing processed-image batch metadata') and a negative boundary excluding the single-batch variant/links case. It stops short of naming the alternative tool explicitly (get_batch), so the routing is described rather than directly pointed at.

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, destructiveHint=false and openWorldHint=false. The description adds useful context beyond them: the returned fields (id, name) and the default page size of 25, which tells the agent to expect paginated, summary-level output. It does not explain what happens at the end of the cursor chain, but that is minor.

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 compact sentences, front-loaded with the usage trigger and followed by return shape and exclusion. No filler or restatement of the title; every sentence carries information.

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

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

An output schema exists, so return-value detail is not required, and annotations cover the safety profile. The description supplies the trigger, scope, pagination default, and a boundary condition, leaving little for an agent to guess.

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

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

Schema description coverage is 100%, so both limit and cursor are already documented with defaults, ranges, and format. The description only echoes the 25-per-page default and says nothing about cursor behavior, so it adds little beyond the schema — baseline 3 is appropriate.

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

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

States a specific verb+resource (list image projects for the connected account) and adds the scope of returning identifiers for later project operations. The negative clause 'Not for a project's processed images' helps separate it from image-level siblings, though it never names get_project as the single-project alternative.

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?

Opens with an explicit trigger ('Use this when the user wants to list image projects...') and adds a when-not condition. It stops short of naming the sibling to use for a single project (get_project), so an agent still has to infer the routing for non-list cases.

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, non-destructive and closed-world, so the safety profile is covered. The description adds real value beyond that: the fields returned (display name + roles), the explicit exclusion of emails/phone numbers/user ids, and the 25-per-page default.

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: trigger first, then return shape/pagination, then the exclusion. No filler and the most decision-relevant 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?

Output schema exists, so return-value detail is not the description's burden, yet it still flags the field-level privacy scope. Combined with the annotations and full schema coverage, an agent has everything needed to invoke this correctly.

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

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

Schema description coverage is 100%, so both limit and cursor are already fully documented in the schema. The description's '25 per page by default' restates the schema default rather than adding new meaning, so the baseline 3 applies.

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

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

States a specific verb and resource ('list the display names and assigned roles of members') and scopes it to the connected Imagelato organization. No sibling tool is named list_team_members or overlaps with this resource, so no further differentiation is required.

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?

Opens with an explicit trigger ('Use this when the user wants to list...') and adds a negative boundary ('Not for inviting or removing members'). It does not name a concrete alternative tool, which is a minor gap given the sibling list contains no member-management tools anyway.

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, openWorldHint=false and destructiveHint=false, so the safety profile is fully covered without the description. The description adds the page size ('25 per page by default') and the returned field set, but says nothing about rate limits, auth requirements, or ordering. That is modest added context on top of comprehensive 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 short sentences, front-loaded with the usage trigger followed by scope, return shape and exclusion. 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?

For a read-only, zero-required-parameter list tool with an output schema, this covers purpose, scope, pagination and exclusion adequately; return-field detail is arguably redundant given the output schema. A model would still lack guidance on ordering or cursor invalidation, but 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 description coverage is 100%, so limit, cursor and projectId are each documented in the schema itself; baseline is 3. The description only restates project scoping and the default page size, adding no format or syntax detail beyond the schema.

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

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

States a specific verb and resource ('list existing Imagelato resize and format presets') plus scope ('optionally scoped to one project'), and explicitly excludes the adjacent entity ('Not for the images processed with them'). An agent can distinguish this from list_projects, list_batches, or list_webhook_subscriptions 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?

Gives an explicit trigger ('Use this when the user wants to list existing... presets') and an explicit exclusion ('Not for the images processed with them'). It stops short of naming the alternative tool for listing processed images, so the routing guidance is clear but not complete.

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 read-only, idempotent, non-destructive behavior, and the description layers on genuinely new operational context: default page size of 25, the 20-consecutive-failure auto-disable rule, and the fact that the listing surfaces endpoints' origin, events and active flag. That is meaningful, non-obvious behavior beyond the structured fields.

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-loaded with the when-to-use condition, then the return content, then the scope exclusion. No filler and nothing repeated needlessly.

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-value detail is optional, and annotations already cover the safety profile. The description nonetheless supplies the disable-after-20-failures rule and pagination default, leaving nothing an agent needs to call this correctly.

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

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

Schema coverage is 100%, so limit, cursor and projectId are already fully documented in the schema, including the 25 default and 1-100 range that the description repeats. The description adds no syntax or semantics beyond what the schema provides, 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 names a specific verb+resource (read webhook subscription configuration and failure counts) and explicitly rules out an adjacent operation ('Not for adding or editing a webhook'). An agent can distinguish this from any sibling 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?

It gives an explicit trigger ('Use this when the user wants to read...') and an explicit exclusion ('Not for adding or editing a webhook'). There is no competing webhook sibling to name, so the guidance is complete for the available toolset.

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 readOnly, idempotent, non-destructive and closed-world behavior, so the safety profile is covered. The description adds valuable behavioral context beyond them: it returns up to 100 projects and exposes no ownership data or credentials, which helps an agent set expectations.

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?

It is short and front-loads usage context, but the phrasing is awkward and repetitive ('Use this when the user wants to ... when the user requests ...'). The two clauses could be merged into a single cleaner trigger statement without loss.

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

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

For a zero-parameter, read-only, closed-world tool with an output schema and rich annotations, the description covers trigger, scope, exclusions, and return cap adequately. Only the slightly vague UI 'open' action keeps it from being fully complete.

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

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

The tool takes zero parameters, so there is nothing for the description to clarify beyond the schema. Baseline of 4 applies for a parameterless tool; no additional parameter guidance is needed or missing.

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 (open the Imagelato project-selection sidebar / interactive browser) and the resource it surfaces (projects, processed batches, presets). It is distinguishable from siblings like list_projects or add_project, though 'open ... sidebar' is an unusual UI-oriented verb that leaves some ambiguity about what technically happens.

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 explicit trigger conditions ('when the user wants to open ... when the user requests an interactive browser') and an explicit exclusion ('Not for uploading, processing or generating images'). It stops short of naming which sibling or tool to use for the excluded operations, so it is strong but not fully routing.

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 real behavioral context beyond that: the hard cap of 8 batches and the 'read-only card' nature of the response, which is not derivable from 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?

Three sentences, all load-bearing: trigger, return shape, and exclusion. The usage condition is front-loaded and nothing is repeated from the schema or annotations.

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 need not detail the return payload, and it nonetheless summarizes the card contents and the 8-batch ceiling. Annotations cover safety, the schema covers the argument — nothing an agent needs to select or invoke this tool 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?

There is a single parameter and schema description coverage is 100%, so the schema fully documents projectIdOrName (including the 200-char limit). The description adds nothing about the parameter, which is the expected baseline when the schema does the work.

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 ('render a read-only overview') and resource ('one Imagelato project'), and quantifies the scope ('up to eight recent processed-image batches'). That cap plus 'overview' clearly differentiates it from get_project and 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?

Opens with an explicit trigger ('Use this when the user wants to render a read-only overview of one project') and adds an exclusion ('Not for every batch in the project'). It stops short of naming the sibling that handles the full batch list, so the agent must infer list_batches.

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?

Goes well beyond the annotations (readOnlyHint=false, destructiveHint=true, idempotentHint=true, openWorldHint=true) by disclosing the webhook side effect ('fires the template.updated webhook'), the return payload, the partial-update semantics ('replacing only the fields given'), and a hard scope limit ('cannot move the preset to another project'). No contradiction with destructiveHint, since sizes/formats replace the prior list.

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 dense sentences: trigger and scope first, side effects and constraints second. The mention of the return value is mildly redundant with the output schema but costs only a clause and reinforces the partial-update behavior.

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 four-parameter mutation with full schema coverage, an output schema, and safety annotations, the description supplies everything else an agent needs: the webhook side effect, the partial-replace semantics, and the project-move limitation.

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 names the updatable fields but adds no syntax, constraints, or format detail beyond what the schema already documents for name, sizes, formats and templateIdOrName.

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

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

States a specific verb+resource ('update ... fields on one existing Imagelato resize preset'), names the exact fields touched (name, output-format, width), and explicitly excludes the create case, which separates it from add_template. An agent can distinguish it from every sibling 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?

Opens with an explicit trigger ('Use this when the user wants to update...') and adds a negative boundary ('Not for creating a preset'). It does not name add_template as the alternative, but the exclusion is unambiguous enough for correct routing.

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