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

Without annotations, the description carries the burden of behavioral disclosure. It does disclose an important behavioral distinction: merge is destructive ('bakes it in') while append is non-destructive. It does not mention broader side effects, whether the layer is modified in place, or what happens with opacity/blend_mode, so transparency is partial.

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, front-loads the core purpose, and uses the second sentence to convey the key mode distinction. There is no filler or redundant restatement of 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?

Given seven parameters, two required, no annotations, and zero schema description coverage, the description is too thin for reliable invocation. It clarifies mode but leaves the agent guessing about how to construct GEGL operation parameters, how opacity and blend_mode interact, and what output to expect beyond the presence of an output schema.

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

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

Schema description coverage is 0%, so the description must compensate for the schema's silence. It explains 'mode' well but leaves six other parameters unaddressed, including the critical 'op', 'params', 'layer_id', 'opacity', and 'blend_mode'. This is insufficient for a seven-parameter tool.

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

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

The description clearly states the action ('Apply a GEGL operation to a layer') and adds meaningful mode semantics: merge bakes it in, append adds a non-destructive effect. It is specific and readable, though it does not explicitly contrast itself with sibling tools like gimp_layer_effect or gimp_layer_effects.

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 useful context for choosing between the two modes, which helps usage. However, it offers no guidance on when to prefer this tool over sibling GIMP tools or when not to use it, leaving tool selection somewhat implied.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does disclose the main side effect—writing outputs to output_dir—and the recipe interface requirement. However, it does not mention whether existing files are overwritten, whether output_dir is created, or how errors are handled.

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 core batch behavior is front-loaded and the recipe contract is stated as a concise constraint. 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?

Given the five-parameter schema and zero schema documentation, the description is too thin for correct invocation without additional inference. It omits how the recipe is named, what params should contain, how output_ext is used, and whether output_dir must pre-exist. An agent could call this confidently only for the simplest cases.

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 0%, so the description must compensate, but it only explains two of five parameters (input_glob and output_dir). The meaning of name, params, and output_ext is left entirely to inference, and the relationship between params and the recipe invocation is not clarified.

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 ('Run a recipe') and the exact batch scope ('every file matching input_glob') while also specifying the destination ('writing to output_dir'). This clearly differentiates it from siblings like gimp_run_recipe, which presumably handles a single recipe execution.

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 communicates a clear usage context: batch processing over files matched by a glob. It also provides an important recipe contract ('Recipes must accept input_path and output_path'), which helps an agent decide whether this tool is appropriate. It does not explicitly name alternatives or when-not-to-use conditions, so it stops short of 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?

With no annotations provided, the description carries the full burden. It discloses a key behavior — that no saving occurs — which is important for a close operation. But it does not mention that the image is unloaded/closed, that unsaved changes are lost, or whether the operation is reversible or destructive, leaving gaps in the behavioral picture.

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 with every word carrying weight. It front-loads the action and key qualifier, making it maximally concise and easily parsed for an AI agent.

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 close operation with one integer parameter and an output schema, the description covers the essentials but omits important context: no usage guidelines, no behavioral side-effects beyond 'without saving', and no explanation of the return value or post-condition of the image handle. The output schema may cover return values, but the description alone leaves notable gaps for an agent deciding whether to invoke this 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 description coverage is 0% and the description does not compensate by explaining the image_id parameter. While the parameter name is fairly self-explanatory, the description provides no explicit mapping between 'an image' and the image_id property, nor any constraints or format hints. With low coverage, the description should add some parameter context.

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 ('Close') with a clear resource ('an image') and adds the critical qualifier 'without saving'. This clearly distinguishes the tool from siblings like gimp_export, implying no persistence of changes. It is unambiguous about the operation'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 phrase 'without saving' implies this tool is appropriate when the user does not want to persist changes, which contrasts with export tools. However, it does not explicitly state when to use this tool over alternatives, or mention any prerequisites or side conditions, leaving usage 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?

With no annotations, the description carries the behavioral burden. It usefully discloses that the extension chooses the format and that unknown option names return the valid list. However, it does not mention overwrite behavior, side effects on existing files, or what happens on invalid paths, which leaves some behavioral ambiguity.

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 front-loaded with the core purpose. Every sentence adds value, and the concrete examples clarify the options parameter without unnecessary prose.

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 covers the essential invocation details: format selection, option examples, and error feedback. An output schema exists, so return values are already covered. The main missing pieces are explicit image_id semantics and file-overwrite behavior, but these do not seriously hinder correct use.

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 0%, but the description significantly compensates by explaining that 'path' controls format via extension and by giving format-specific examples for 'options'. 'image_id' is not described explicitly, but its meaning is reasonably inferable from the tool name and parameter name.

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 identifies the action ('Export an image') and the resource, and explains the format selection via file extension. It is specific enough to understand the tool, though it does not explicitly differentiate it from sibling tools like gimp_render.

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 explains how format and options work, but it does not state when to use this tool versus alternatives or provide exclusion criteria. There is no comparison to gimp_render or other saving/rendering tools, so an agent gets little guidance on tool selection.

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

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

There are no annotations, so the description carries the behavioral disclosure burden. It does this well by stating that the tool reports properties rather than mutating anything, and by listing the kinds of information returned (names, types, ranges, defaults). It remains brief but honestly conveys a read-only inspection 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 one tight sentence with no filler. It front-loads the verb and resource, then adds a parenthetical detail list that earns its place by clarifying what will be described.

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

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

For a simple one-parameter read-only tool, the description captures the essential behavior and output categories, and an output schema exists to document return shape. However, it omits practical setup context, such as where valid GEGL operation names come from or how to discover them (e.g., via gimp_filter_search), so an agent may still be unsure what value to pass for 'op'.

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 0% and the description only loosely connects 'op' to 'GEGL operation'; it never defines op as an operation identifier or gives acceptable formats/examples. The word 'op' plus the description provides partial semantic context, but it does not adequately compensate for the missing schema documentation.

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 ('Describe') and resource ('GEGL operation's properties') and enumerates the relevant output categories (names, types, ranges, defaults). This distinguishes it from siblings like gimp_pdb_describe, which targets PDB procedures, and gimp_filter_search, which searches rather than describes.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives such as gimp_filter_search, gimp_pdb_describe, or gimp_apply_filter. An agent can infer a use case from the purpose statement, but there is no stated when-to-use or when-not-to-use context.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the tool searches filters and gives examples; it does not disclose matching semantics, empty-query behavior, whether results are names only, or the effect of the limit parameter. This is a minimal behavioral account.

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

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

A single, front-loaded sentence contains the core action, the target resource, and practical examples. There is no filler or repetition, and every word contributes to understanding.

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, has optional parameters with defaults, and has an output schema, which lessens the need to document return values. Still, the missing behavior around query matching and the unmentioned limit parameter leave an agent with some ambiguity when calling 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?

Schema description coverage is 0%, so the description must compensate. It clarifies 'query' indirectly through examples like 'blur' and 'noise', but it never explains the 'limit' parameter or its default behavior. With two parameters and only partial query guidance, this is insufficient compensation.

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 ('Search') and identifies a clear resource ('GEGL operations available as filters'), with helpful examples like 'blur' and 'shadow'. It distinguishes itself from generic GEGL/PDB search directions, though it does not explicitly name or differentiate sibling tools such as gimp_filter_describe or gimp_apply_filter.

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 you need to find GEGL filter names by keyword. However, it gives no explicit guidance about when NOT to use it or which alternative sibling tool to prefer, such as gimp_filter_describe for inspecting a filter or gimp_apply_filter for applying one.

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

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

With no annotations provided, the description carries the behavioral disclosure burden and does well by itemizing exactly what will be returned: layer tree, channels, paths, selection bounds, and resolution. This makes the read-only nature of the tool evident, though it omits prerequisites such as needing a valid open image.

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

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

A compact, front-loaded sentence that uses a colon-separated list to convey the full scope of the tool efficiently. There is 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 one-parameter tool with an output schema, the description covers the essential return categories and makes the tool's purpose clear. It could have mentioned that the image must already be open or obtainable via gimp_list_images, but that is a minor gap and inferable from the sibling tools.

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 image_id is not explained in the description, and schema description coverage is 0%. The phrase 'one image' weakly implies that image_id selects a single image, and the parameter name is self-explanatory, but the description adds little semantic value beyond the schema.

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

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

The description identifies the target resource (a single image) and enumerates the returned contents, which distinguishes it from siblings like gimp_list_images. It lacks an explicit verb such as 'get' or 'retrieve', but 'full structure' clearly implies inspection.

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 that this tool is for inspecting one image's full structure, which gives the agent some context for when to use it. However, it does not explicitly contrast it with alternatives such as gimp_list_images or gimp_measure, nor does it provide when-not-to-use 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?

With no annotations provided, the description carries the full burden of explaining behavior. It does disclose that the tool starts GIMP with the bridge running and describes the difference between GUI and headless execution. However, it does not mention side effects, process lifecycle, what happens if GIMP is already running, or what 'wait_seconds' controls, leaving meaningful behavioral gaps.

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 filler. The core purpose is front-loaded, and the mode-specific behavior is explained efficiently. Every sentence contributes useful information, making this an appropriately sized and well-structured description.

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 covers the main purpose and mode selection but leaves 'wait_seconds' completely unexplained. Given that there are no annotations and the schema provides no parameter descriptions, this is a significant gap. An agent cannot fully understand the launch behavior or know how to adjust the wait time appropriately. The presence of an output schema reduces the need to document return values, but the missing parameter context makes the description incomplete.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the 'mode' parameter well by defining 'gui' and 'headless'. However, 'wait_seconds' is not mentioned anywhere in the description or schema, so a key parameter remains undocumented. The tool partially compensates for the low schema coverage but not completely.

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 that this tool starts GIMP 3 with the bridge running, which is a specific verb and resource. It also explains the two modes, giving a clear sense of what the tool does. However, it does not explicitly differentiate itself from sibling tools like gimp_shutdown or gimp_status, though its role as a launcher is fairly obvious.

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 useful guidance on when to use 'gui' versus 'headless' mode, which helps the agent choose parameter values. It does not explicitly state when to use this tool relative to siblings or mention any prerequisites, exclusions, or sequencing guidance, 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?

With no annotations, the description carries the full burden. It does disclose the mutating nature of the tool through action names like delete, merge_down, and resize_to_image, which is useful. However, it does not mention side effects, required open image/layer context, reversibility, or error behavior for destructive operations.

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, front-loading the purpose with 'Layer operations' followed by a dense action list. It contains no filler. The single-line comma-separated format is efficient but slightly hard to parse due to its density.

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 19 parameters, 13 possible actions, no annotations, and 0% schema description coverage, this description is insufficient. It does not state which parameters are required for each action, whether layer_id is needed for delete/duplicate/merge_down, how image_id or layer_id are obtained, or what prerequisites must be met. The output schema covers return values but not invocation requirements.

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 description adds valuable action-to-parameter mappings, such as 'new (image_id, name, width, height, fill, x, y, position)' and 'move (dx, dy)', which is helpful given 0% schema description coverage. However, it omits some schema parameters like layer_id, merge_type, and local_origin, and does not explain value formats or meaning for fields like fill, mode, opacity, or position.

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 identifies this as a layer-operation dispatch tool and enumerates the supported sub-actions (new, set, move, reorder, duplicate, merge_down, delete, resize_to_image, scale, add_alpha, crop_to_content, info). It does not explicitly distinguish itself from sibling tools like gimp_layer_mask or gimp_layer_effects, so it is clear but not maximally differentiated.

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

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

No guidance is provided on when to use this tool versus alternatives. The action list implies core layer editing, but there are no explicit exclusions or conditions, such as when to prefer gimp_layer_mask for mask operations or gimp_layer_effects for effects.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It explicitly discloses that action='set' updates params/visible/opacity/blend_mode and 'delete' removes the effect, and notes the operation is non-destructive. This is meaningful behavioral context beyond the schema. It doesn't cover edge cases like invalid filter_id or defaults, but the core mutation behavior is transparent.

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

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

The description is a single, front-loaded sentence that captures the essential purpose and behavior. It contains no redundancy or filler, every clause adds information, and the action semantics are packed efficiently.

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 an output schema exists and the tool has 6 parameters, the description provides enough to call it correctly: it specifies the actions, the source of filter IDs, and which fields are affected by 'set'. It does omit richer parameter details (e.g., shape of params object, opacity range), but this is largely discoverable from the sibling gimp_layer_effects output, so the description is reasonably complete.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to the action parameter by defining 'set' and 'delete', and clarifies filter_id as the effect ID from gimp_layer_effects. However, it merely lists params, visible, opacity, and blend_mode by name without explaining formats, allowed values, or how params should be structured. This is partial compensation, not full.

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: 'Edit or delete a non-destructive layer effect'. It names the specific resource (non-destructive layer effect), the verbs (edit/delete), and the two action behaviors. It also distinguishes itself from sibling tools like gimp_layer_effects (which lists effects) by referencing IDs from that list, and from destructive filter tools by emphasizing non-destructive.

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 by saying IDs come from gimp_layer_effects, which tells the agent to first list effects before using this tool. It also clarifies the two actions and what they do. It lacks explicit mentions of alternatives or when not to use this tool, so it doesn't quite earn a 5, but the context is clear and there are no exclusions.

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

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

With no annotations provided, the description carries the burden of indicating safety and behavior. 'List' clearly signals a read-only operation, and 'non-destructive filters' reinforces this. However, it does not disclose what is returned or any error conditions, leaving some behavioral ambiguity.

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, well-structured sentence with no wasted words. It front-loads the action and clearly names the target resource, making it easy to scan.

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 listing tool, the description is minimally adequate, and the presence of an output schema covers return-value details. Yet it lacks any guidance on how to obtain layer_id and does not position the tool against the singular gimp_layer_effect sibling, leaving some context incomplete.

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

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

The schema has one parameter, layer_id, but 0% schema description coverage. The description does not compensate by explaining what the layer_id should reference or how to obtain it. It merely parrots the object of the operation, adding no new semantic value.

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

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

The description uses a specific verb ('List') and identifies a clear resource: the non-destructive filters attached to a layer. This makes the tool's function immediately understandable. It does not explicitly distinguish from the sibling gimp_layer_effect, so it stops short of full sibling differentiation.

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

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

There is no guidance about when to use this tool versus alternatives like gimp_layer_effect or gimp_apply_filter. It also does not mention prerequisites such as needing a valid layer_id obtained from another 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?

With no annotations, the description carries the behavioral disclosure burden, and it does well by stating outcomes: 'apply bakes the mask in', 'remove discards it', and enable/disable/show/hide are described as toggles or preview controls. It does not cover failure modes, permissions, or dependencies like whether an active selection is required for type='selection', so it is not 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?

The description is a single dense sentence with semicolon-separated clauses, each delivering a distinct operational fact without filler. It front-loads the resource name and packs the parameter behavior into a compact, scannable format.

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 small masking tool with an output schema, this description covers the operation space, the main parameter values, and key side effects. Missing explicit usage context and edge conditions, such as behavior when no selection exists, prevent 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?

Schema description coverage is 0%, but the description compensates by enumerating the valid action values and the add-type choices. layer_id is left implicit, though it is self-evident as the required target; the meaning of 'copy' and the source of 'selection' are not fully explained.

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 identifies the resource (layer masks) and enumerates all supported operations with their action values. It does not use an explicit verb like 'manage' or 'modify', but the action list makes the tool's function apparent and distinguishes it from sibling tools by domain specificity.

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

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

There is no explicit guidance on when to use this tool versus alternatives such as gimp_layer or gimp_layer_effect. The action descriptions imply usage scenarios, but the agent is not told what prerequisites exist or which situations call for this tool over nearby 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?

With no annotations, the description carries the burden of explaining behavior. It does imply a read-only listing operation and clarifies that the filter is a regex, but it does not disclose the role of the limit parameter or any edge cases like no fonts found.

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 no filler. The core action and the filtering option are front-loaded, and every word contributes useful 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 simple listing tool with an output schema and optional parameters, this is mostly adequate. However, the missing limit semantics and lack of any alternative-tool guidance leave minor but real gaps for an agent deciding how to call it correctly.

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

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

Schema description coverage is 0%, so the description should compensate for both parameters. It adds meaningful regex semantics for the filter parameter, but it never explains the limit parameter or its default behavior, leaving a real gap.

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), a specific resource (installed font names), and a modifier (optional regex filter). This clearly distinguishes it from sibling tools like gimp_list_images and gimp_pdb_search.

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

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

There is no guidance on when to use this tool versus alternatives, and no mention of whether the regex filter is sufficient or whether the limit will truncate results. The description only explains the option itself, not the decision context.

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

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

No annotations are present, so the description carries the full behavioral burden. The 'List' verb unambiguously signals a read-only query, and the sentence discloses exactly what is returned. It does not cover edge cases such as an empty image list or unsaved file paths, but those are minor for such a simple query, and an output schema exists.

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

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

A single sentence that front-loads the action and resource, then lists the returned data. There is no redundant phrasing, no repetition of schema information, and every phrase 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?

With zero parameters, an output schema, and a simple read-only listing operation, the description is fully sufficient for an agent to decide when to call it and to understand what it returns. The only minor gap is explicit sibling differentiation, but the simple scope makes that unnecessary.

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

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

The tool has zero parameters, so the parameter-semantics baseline is 4. The description correctly focuses on behavior and return contents rather than argument details, and no input guidance is needed.

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

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

The description uses a specific verb ('List'), a clear resource ('open images'), and enumerates the returned fields ('ids, dimensions, file path, and layer count'). This clearly distinguishes it from related tools like gimp_image_info, which is implied to target a single image, and from gimp_list_fonts, which targets a different 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 makes the use case self-evident: call this when you need an inventory of currently open images or need their ids for further operations. It does not state exclusions or explicitly compare to gimp_image_info, but the plural 'open images' provides clear context and there are no misleading 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?

No annotations are provided, so the description carries the behavioral disclosure burden. It discloses that entries are 'tested' and 'multi-step' and that parameter information is included, which is meaningful context. The read-only nature is strongly implied by 'List', and there are no hidden side effects described or contradicted.

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

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

One short, front-loaded sentence with no filler. Every word adds information: 'tested', 'multi-step', 'recipes', and 'parameters' all carry 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?

For a zero-parameter listing tool with an output schema available, the description is complete enough to invoke correctly. It identifies exactly what will be listed and lets the output schema handle return-value 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?

The tool takes zero input parameters, so the description has no input parameter burden. Mentioning that recipes have parameters refers to the output content, and with no input schema to document this is sufficient.

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

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

The description uses a specific verb ('List') and a specific resource ('tested multi-step recipes') plus what is returned ('their parameters'). It is immediately distinguishable from sibling tools like gimp_run_recipe or gimp_batch_recipe, which execute recipes instead of enumerating them.

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 tool's listing purpose implies it can be used to discover available recipes and their parameters before running them, but the description never explicitly states when to prefer it over gimp_run_recipe, gimp_batch_recipe, or other list tools. There is no explicit exclusion or alternative 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?

With no annotations, the description carries the behavioral disclosure burden. It does this well by defining what each kind returns, noting that color is rgba at image x,y, bbox bounds non-transparent pixels, histogram gives per-channel statistics, and dominant returns top k colors. 'Defaults to the selected layer' also reveals target context, though side-effect safety is only implied by the word 'measure'.

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 carry substantial information with no filler. The primary purpose is front-loaded, followed by a compact enumeration of modes and a useful default-target note. Every word earns its place.

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

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

The description covers the core modes and default layer behavior, and an output schema exists to describe return shapes. But given the complexity of 8 parameters, it leaves threshold undefined, does not clarify which parameters apply to which mode, and omits preconditions such as needing an open image or selected layer.

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 0%, so the description must compensate. It meaningfully explains kind values, maps x,y to color, k to dominant, and implies layer/image targeting via 'defaults to the selected layer'. However, threshold is completely unexplained, channels is only vaguely tied to 'per channel', and per-mode required parameters are not explicitly stated.

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 action, 'Measure pixels instead of guessing from a render', and then enumerates four concrete measurement modes (color, bbox, histogram, dominant) with their exact outputs. This clearly separates the tool from render-related siblings and establishes it as a pixel-level measurement 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?

'Instead of guessing from a render' explicitly tells the agent when this tool is appropriate: whenever exact pixel measurements are needed rather than visual inspection. It does not name a sibling tool explicitly or list exclusions, but the context is clear enough for an agent to choose it over render-oriented tools.

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

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

With no annotations provided, the description carries the burden of behavioral disclosure. It does disclose key behavior: the image is RGB, has exactly one layer, and accepts specific fill values. However, it does not mention side effects, color-string formats, prerequisites like a running GIMP instance, or failure 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 short sentences with the main action front-loaded and the fill options presented as a compact list. Every word adds value and there is no redundant or vague 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 tool is simple and the output schema plus parameter defaults cover some gaps, but with no annotations the description still lacks operational context such as prerequisites, color parsing, and call-time side effects. It is adequate for straightforward invocation, but not fully complete for an agent unfamiliar with the GIMP environment.

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 description adds meaningful detail for the fill parameter by enumerating valid values ('transparent', 'white', 'black', 'foreground', 'background' or any colour), which the schema leaves undocumented. It does not explain width and height units, but their roles are fairly obvious from the parameter names and default values in the schema.

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

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

The description states a specific verb and resource: 'Create an RGB image with one layer', so an agent immediately knows the tool's core function. It does not explicitly contrast with siblings like gimp_open or gimp_list_images, but the creation semantics are clear enough to avoid confusion.

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 this tool is for creating a new blank RGB image, but it provides no explicit when-to-use guidance or alternatives. It does not mention that gimp_open would be used for existing images or gimp_list_images for discovering current images.

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

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

With no annotations provided, the description carries the full disclosure burden. It reveals the main action and return value, but does not disclose that opening a file likely adds an image to the current GIMP session, requires a running GIMP instance, or may fail on unsupported/missing paths. This is a significant behavioral gap for a state-changing operation.

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

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

The description is a single, front-loaded sentence with no filler. The core action, target resource, supported formats, and return value are all conveyed efficiently.

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 covers the core purpose and notes the return structure, and an output schema exists for return details. However, it omits prerequisite launch steps, the effect on the image list, and path format expectations. For a simple one-parameter tool this is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It partially does by listing supported file types for the path, but it does not clarify whether the path should be absolute or relative, whether remote paths are allowed, or what happens with missing files. The format list adds some meaning, but leaves key path semantics unstated.

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: 'Open an image file' and 'return its structure.' It lists supported formats, which adds precision, and the action of opening a file clearly distinguishes this tool from siblings like gimp_new_image (create) and gimp_list_images (list existing).

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 about when to prefer this tool over alternatives, nor any exclusions or prerequisites. The description implies the obvious use case of loading a file, but it does not mention that GIMP may need to be launched first or that gimp_image_info should be used for already-open images.

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

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

With no annotations provided, the description carries the full disclosure burden. It does state the effect of each action: creating from strokes, converting a path to selection, drawing/filling on a layer, and deleting. But it does not mention side effects such as whether 'select' replaces an existing selection, whether stroke/fill permanently modifies pixels, whether deletion is irreversible, or whether path_id is returned after creation.

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 dense and efficient, with no filler. Each action's signature is packed into a compact clause, and the stroke structure is illustrated inline. The semicolon-heavy format is slightly less scannable than bullets, but it is appropriate for a multi-action tool with several parameter combinations.

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 has 9 parameters and 5 actions with zero schema descriptions, the description covers the core calling pattern for create, stroke, and fill well. It is incomplete for select/delete because it never explicitly says which parameter identifies the path, and 'op'/'name' remain unexplained. With an output schema present, return values need not be documented, but the missing path_id clarity means an agent may have 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?

Since schema_description_coverage is 0%, the description must supply parameter meaning, and it does for the main parameters: action, image_id, strokes with detailed bezier format, layer_id, color, and width. However, it does not explain the 'op' or 'name' parameters, and it never explicitly names path_id when describing 'select' or 'delete', which leaves important invocation details under-specified.

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 identifies the resource as 'Vector paths' and enumerates five distinct operations (create, select, stroke, fill, delete) with compact signatures. An agent can tell this is the path manipulation tool, though it lacks a single top-level verb like 'Manage' and does not explicitly differentiate from siblings such as gimp_select or gimp_pdb_call.

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

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

The action list implies when the tool is relevant: creating vector paths, converting them to selections, stroking/filling on layers, or deleting. However, there is no explicit guidance about when to prefer this tool over alternatives, and prerequisites like needing an existing image or layer are only indirectly implied through parameters such as image_id and layer_id.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains the encoding conventions (ids, strings, enums) but does not disclose potential side effects, undo behavior, or error handling. Saying it can call 'any PDB procedure' hints at broad reach, but does not explicitly warn about destructive or state-mutating calls.

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 tight sentences with no filler. The core action is front-loaded, and the second sentence delivers the most important parameter-encoding rules an agent needs before invoking.

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 covers the essential invocation contract and an output schema exists, so return values need not be explained. However, for a generic no-annotation execution tool, it omits guidance on discovering valid PDB procedure names/signatures via gimp_pdb_describe, and it leaves undo_group semantics unstated. These gaps make it minimally viable but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate. It does this well for the opaque args object by stating that arguments are keyed by name and that images/items are passed as ids, colours as strings, and enums by nick. However, the undo_group parameter is not explained, leaving a small gap.

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: 'Call any PDB procedure by name'. It also clarifies the calling convention with arguments keyed by name. This clearly distinguishes it from search/describe siblings like gimp_pdb_search and gimp_pdb_describe, which do not invoke procedures.

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

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

The phrase 'any PDB procedure' implies this is the generic raw invocation tool, but the description does not explicitly say when to prefer it over specialized siblings or when not to use it. There is no mention of alternatives or exclusions, leaving the usage context mostly implicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. 'Describe' semantically indicates a read-only introspection action and implies no execution or mutation, but the description does not explicitly state that the procedure is not invoked or how invalid names are handled. This is a partial but not complete disclosure.

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

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

The description is a single, front-loaded sentence with no filler. Every clause adds useful information about the procedure signature, and it is appropriately sized for a tool with one parameter.

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 introspection tool with one required parameter and an output schema, the description covers the essential purpose and result content. It would be more complete with an explicit example of a PDB procedure name, but the output schema likely supplies return-value structure, 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 description coverage is 0%, so the description must explain the 'name' parameter, but it never says that 'name' is the exact PDB procedure identifier or provide any format/example. The tool title and description vaguely imply that 'name' refers to the procedure, but the parameter semantics are not meaningfully clarified beyond the bare schema property.

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 ('Describe') and a specific resource ('a PDB procedure'), then spells out what the description contains: arguments with types, defaults, enum choices, and return values. This distinguishes it from siblings like gimp_pdb_call or gimp_pdb_search, which clearly execute or search procedures.

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 use when you need to inspect a procedure's signature before calling it, but it never explicitly states when to choose this over siblings such as gimp_pdb_call or gimp_pdb_search. There is no exclusionary guidance like 'use this instead of calling the procedure directly.'

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

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

With no annotations, the description must carry the burden. It does state the core search behavior: matching words in procedure names. However, it does not disclose matching semantics such as case sensitivity, multi-word combination behavior, or what happens with an empty query.

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

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

The description is a single, front-loaded sentence with no filler. The examples ('image scale', 'layer text', 'file png') make the intended usage immediately clear without adding unnecessary length.

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 covers the main action and query semantics, and an output schema exists, so return structure does not need explanation. However, it omits guidance on default behavior, especially when no query is provided, and does not explain the limit parameter, leaving minor but real 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?

The schema has 0% parameter description coverage, so the description must compensate. It adds useful semantics for 'query' with the phrase 'words in the procedure name' and examples, but it says nothing about the 'limit' parameter, leaving its meaning and effect unspecified.

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 concrete verb and resource: 'Search GIMP's Procedure Database' and narrows the scope to 'words in the procedure name' with illustrative examples. This clearly distinguishes it from siblings like gimp_pdb_describe, gimp_pdb_call, and gimp_filter_search.

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 this tool is for discovering PDB procedures by name, but it does not explicitly say when to use it versus alternatives or when not to use it. No exclusions or alternative tool names are given, leaving some routing up to the agent's 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?

With no annotations, the description carries the burden of disclosure. It does disclose the main behaviors: writing a layer mask or baking into the alpha channel, and the dependency on the segmentation extra. However, it does not mention whether the operation overwrites an existing mask/alpha channel or any caveats about the 'apply' mode being destructive.

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, front-loaded with the core purpose, and every sentence adds useful information: function, modes, prerequisite, and model options. No 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?

Given the output schema exists and the tool is relatively focused, the description covers the essential invocation context: required extra, model choices, and mode semantics. The main gap is the undocumented 'alpha_matting' parameter and lack of detail about existing mask/alpha overwrite behavior, but overall it is nearly 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 description adds meaning for 'mode' (mask vs apply) and 'model' (listing valid values and defaults), compensating for the 0% schema coverage. However, 'alpha_matting' is not explained at all, leaving a meaningful parameter undocumented.

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 ('AI subject cut-out', 'runs a segmentation model on the layer') and clearly distinguishes this from sibling tools like gimp_layer_mask or gimp_apply_filter. It also differentiates the two output modes, making the tool's 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 AI-based subject/background removal is needed, and notes the required optional segmentation extra. It does not explicitly name alternatives or exclusions, so it stops short of 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?

With no annotations, the description carries the behavioral burden. It adds useful detail like 'crops before scaling' and the current-state semantics. However, it does not explicitly state that the operation is non-destructive, what happens when no image is open, or what the output form is beyond 'a PNG you can see.'

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 compact sentence that front-loads the main purpose and then packs the two non-obvious parameters into a concise notation. No filler or redundant 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?

The core render behavior is covered well, and the optional layer/region behavior is helpful. But with no annotations, no output schema, and only partial parameter coverage, an agent may still be uncertain about image_id selection, max_size scaling semantics, and when this tool should be preferred over related siblings.

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

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

Schema description coverage is 0%, so the description must compensate. It does explain region={x,y,width,height}, layer_id isolation, and the crop-before-scale order. However, image_id and max_size are not explained, leaving important parameter meaning to inference.

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: 'Render the current state of an image as a PNG you can see.' It also clarifies the optional layer_id and region behavior. It does not explicitly distinguish this from sibling tools like gimp_export or gimp_render_compare, but the core purpose is 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 description gives no guidance on when to use gimp_render versus alternatives such as gimp_export, gimp_snapshot, or gimp_render_compare. It explains optional parameters but not the conditions under which this tool is the right choice.

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

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

With no annotations, the description carries the full behavioral burden. It explains that 'diff = pixel difference, black means identical,' which is useful, but it does not disclose the effect of drop_snapshot, whether the snapshot is deleted, the output format, or any side effects. For a tool with a boolean drop_snapshot parameter, this is a significant gap.

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

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

Two sentences with no filler. The first sentence front-loads the core purpose, and the second explains the key parameter. Every part 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 five parameters, no output schema, and no annotations, the description is not complete enough. It omits the meaning of drop_snapshot and max_size, does not describe the return value, and does not mention whether the snapshot persists after the operation. An agent would be guessing on important invocation 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 0%, so the description must compensate. It adds meaning only for panels ('comma list of before, after, diff'), leaving image_id, snapshot_id, max_size, and especially drop_snapshot without clarifying semantics. Property names alone are not enough for unambiguous invocation.

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 and resource: 'Side-by-side render of a snapshot and the current image.' This clearly distinguishes the tool from siblings like gimp_render or gimp_snapshot, and the follow-up sentence about panels adds concrete scope.

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 purpose implies when to use it: when a comparison between a snapshot and the current image is needed. However, it does not explicitly name alternatives or state when not to use it, leaving the routing decision to inference rather than direct 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?

No annotations exist, so the description carries the full burden — and it delivers: persistence across calls (the single most important behavioral trait for an interpreter tool), the exact return contract (stdout plus expression value or `result`), and undo-step wrapping via image_id. It stops short of disclosing exception/error behavior, which matters for arbitrary code execution.

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, roughly 40 words, with the core purpose front-loaded. Every sentence earns its place: namespaces, persistence, return format, and undo behavior are each covered 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 high-complexity arbitrary-code-execution tool, the description covers the critical operational facts: what's in scope, cross-call persistence, return value semantics, and transactional undo. The output schema presumably documents the return structure. The remaining gap is error handling — what an agent should expect when the Python code raises an exception — which is notable but not disqualifying given how much else is conveyed.

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 0% schema coverage, the description must compensate. It gives image_id real meaning (one-undo-step wrapping) and hints at code semantics via the expression-value return contract. However, it doesn't explain how `code` accesses the passed image or variables from prior calls, or whether stdin/multiline scripts are supported — leaving the agent to guess the execution model.

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?

"Run Python inside GIMP" is a specific verb+resource statement that immediately distinguishes this from siblings like gimp_pdb_call (single PDB procedure) and gimp_run_recipe (recipe execution). Listing the available namespaces (Gimp, Gegl, Gio, GLib, helpers) further sharpens what the tool executes.

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 persistent-namespace and undo-step notes imply a scripting use case, but the description never explicitly says when to choose this over gimp_pdb_call or gimp_run_recipe, nor does it state when not to use it. With 30+ siblings, explicit routing guidance would materially help agent selection.

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

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

No annotations are provided, so the description must fully disclose behavior, but it only mentions that recipes are Python jobs with defaults applied. It does not mention potential side effects on GIMP state, failure modes, execution time, or whether recipes can mutate images or settings. This is a significant gap for a tool that executes code.

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

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

The description is two short sentences with no filler. The primary action is front-loaded, and the clarifying context about recipes and defaults is placed right after. 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 two-parameter tool with an output schema, this is enough to invoke a known recipe: provide a name and optional params. However, it omits how to discover valid recipe names (e.g., via gimp_list_recipes) and offers no caution about running Python jobs inside GIMP, leaving an agent without key context for safe selection.

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 0%, and the description only adds 'with parameters' and 'defaults applied' beyond the parameter names. It does not explain how the free-form params object should be structured, how it maps to recipe variables, or how defaults interact with supplied 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 states a clear action ('Run a recipe') and resource ('by name'), and it clarifies that recipes are Python jobs executed inside GIMP with defaults applied. It does not explicitly contrast with siblings like gimp_run_python or gimp_batch_recipe, but the 'by name' wording hints at a defined recipe registry.

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

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

The description gives no guidance on when to choose this tool over alternatives such as gimp_run_python, gimp_batch_recipe, or gimp_list_recipes. 'Recipes are Python jobs... with defaults applied' implies a predefined, defaults-driven workflow, but this is left to inference rather than stated.

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

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

With no annotations, the description carries the behavioral burden. It explains several important behaviors: alpha selects opaque pixels, bounds 'just report', and op defines how modes combine. However, it does not disclose that the tool mutates the current selection state, explain sample_merged, or mention prerequisites like an open image.

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 extremely compact and information-dense. It front-loads the purpose and then packs mode-to-parameter mappings and operation semantics into one efficient sentence 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?

For a 13-parameter tool, the description covers the main modes, operations, parameter mappings, and return value. An output schema exists for return details, reducing the need to describe them. Missing pieces are sample_merged semantics and usage guidance versus sibling tools, but the essential calling context is well 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 description coverage is 0%, so the description must compensate, and it largely does. It maps x, y, width, height to rect/ellipse; color, threshold, layer_id to color; item_id to item; amount to grow/shrink/feather/border; and lists op values. It omits sample_merged and does not explain every parameter, but the coverage is strong.

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 identifies the tool as a unified selection operation ('Selection in one tool') and enumerates the specific modes and operations it supports. It is distinct from sibling tools because it centers on selection, though it does not explicitly compare itself to alternatives.

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

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

No guidance is given on when to prefer this tool over alternatives like gimp_layer_mask or gimp_remove_background. The description implies usage through its mode list, but there is no explicit when-to-use, exclusions, or mention of related tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly warns that unsaved work is not prompted for in the GUI, which is a critical side effect. It also reveals session-dependent default behavior. It does not mention every possible side effect, but the most important destructive behavior is disclosed.

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 one concise, front-loaded sentence. Every clause earns its place: the action, the conditional default, and the warning about unsaved work. There is no filler or redundant repetition of the tool name.

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 tool with one optional parameter and an output schema present, the description is largely complete. It covers the primary action, the parameter's default resolution, and the key risk. The only minor gap is that 'the bridge' is not explicitly defined, though the tool name and sibling context make it reasonably clear.

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 0%, so the description must compensate for the lone parameter quit_gimp. It does so by explaining the default behavior in headless versus GUI sessions and tying it to the lack of an unsaved-work prompt. This adds meaningful meaning beyond the raw boolean/null 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 starts with a specific verb and resource: 'Stop the bridge.' This clearly distinguishes the tool from siblings like gimp_launch, gimp_close_image, and gimp_export, which operate on other parts of the GIMP workflow. Even without naming a sibling explicitly, the action is 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 description gives parameter-level context by explaining how quit_gimp defaults differ between headless and GUI sessions, but it does not explicitly state when to choose this tool over alternatives or when not to use it. The usage is implied by the tool name and 'Stop the bridge,' but there are no exclusions or 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?

With no annotations, the description must carry the behavioral burden. 'Hidden snapshot' communicates that the operation does not produce visible output and is non-destructive. However, it doesn't disclose whether multiple snapshots per image are allowed, whether a previous snapshot is overwritten, or whether any internal GIMP state is changed beyond the hidden capture.

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

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

The description is a single, front-loaded sentence with no filler or redundant information. It packs the core action ('hidden snapshot'), the target ('image's current state'), and the purpose ('show before/after later') into minimal space.

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

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

For a simple one-parameter tool with an output schema, the definition provides the essential workflow context. Yet, with no annotations, it omits prerequisites such as requiring a currently open/valid image_id, and it doesn't clarify whether a snapshot must be taken before every edit or how many snapshots are retained. This leaves minor but meaningful gaps.

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 no description for image_id, and schema description coverage is 0%. The description never mentions the parameter by name or explains its format or constraints; it only says 'an image's current state,' which weakly implies an image identifier. Since the description must compensate for the missing schema descriptions, it falls short.

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 ('Take'), resource ('image's current state'), and unique scope: a 'hidden snapshot' for later comparison. It names the companion tool gimp_render_compare, which immediately differentiates it from related siblings like gimp_render or gimp_render_compare.

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

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

The phrase 'so gimp_render_compare can show before/after later' clearly establishes when to use the tool: capture state before modifications so a later comparison is possible. It doesn't explicitly state exclusions or alternative tools, but the reference to the sibling comparison tool provides strong contextual 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?

With no annotations provided, the description carries the full burden. It transparently indicates that this is a non-destructive status check ('Check whether ... reachable') and states what it returns. It does not explicitly cover error behavior or confirm no side effects beyond the verb 'Check', but the main behavioral boundary is clear.

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

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

Two short sentences with no redundancy. The primary action is front-loaded ('Check whether ... reachable') followed by the return data. 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?

This is a simple zero-parameter status tool with an output schema. The description states the purpose and the key returned information. Nothing necessary for an agent to call it confidently 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 has zero parameters, so the baseline is 4. The description not only does not need to explain parameters, it also adds meaningful context about what the tool reports, which is more than sufficient.

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

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

The description uses a specific verb ('Check') and resource ('GIMP and the agent bridge'), and lists concrete outputs (version, mode, open images). This clearly differentiates it from siblings like gimp_launch and gimp_list_images by focusing on status and reachability.

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 establishes this as a health-check tool to determine whether GIMP and the bridge are reachable, which implies use before other operations. However, it does not explicitly mention alternatives or when not to use it, such as distinguishing from gimp_list_images for only listing images.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It explains key behaviors: creation vs editing, size units, font resolution, justify values, spacing, and optional fixed box. However, it does not describe side effects, conflicts if both image_id and layer_id are supplied, or whether editing replaces or modifies existing text content.

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

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

A single dense sentence delivers create/edit modes, parameter units, font guidance, enum values, and box behavior with zero fluff. Everything included earns its place and the most important operational distinction is front-loaded.

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

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

Given 14 optional parameters, zero schema descriptions, and no annotations, the description gives a solid core but leaves gaps such as x/y positioning, layer name semantics, and behavior when parameters conflict. The presence of an output schema helps with return shape, but the description alone is not fully complete for all valid calls.

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 0%, so the description must compensate. It adds real meaning for many parameters: image_id/text create mode, layer_id edit mode, size in px, font via gimp_list_fonts, color, justify enum values, spacing, and fixed box dimensions. It still leaves x, y, and name partially unexplained, but the description is far more informative than the bare parameter names.

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: 'Create a text layer... or edit one', and clearly separates the two modes by image_id vs layer_id. This distinguishes it from generic sibling tools like gimp_layer and makes the tool's purpose immediately obvious.

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 usage context: use image_id + text to create, layer_id to edit, and points to gimp_list_fonts for font names. It does not explicitly state when not to use this tool or contrast it with alternatives like gimp_layer, which 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.