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

No annotations are provided, so the description carries the full burden. It mentions adding a bookmark but does not disclose behavioral traits such as whether duplicate names are allowed, CRS validation, or effects on existing bookmarks.

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, clear sentence that front-loads the action and key inputs with no unnecessary words.

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 no output schema and no annotations, the description is minimally adequate for a simple create operation but lacks completeness: it does not specify return values, success/failure indications, or error conditions.

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 mentions name, extent parameters (xmin, ymin, xmax, ymax), and CRS, but omits the optional 'group' parameter entirely. With 0% schema description coverage, the description fails to compensate by providing additional meaning or format guidance for the parameters.

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

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

The description uses a specific verb ('Add') and resource ('spatial bookmark'), and clearly states the tool's purpose for quick navigation. It distinguishes from siblings like 'get_bookmarks' (list) and 'remove_bookmark' (delete).

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 implicitly indicates usage for adding a bookmark but provides no explicit guidance on when to use alternatives or when not to use. However, the sibling tools have distinct operations, making the context clear.

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

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

The destructiveHint annotation already indicates a write operation; the description adds the return value and feature format. However, it does not disclose potential error conditions, whether features are appended or replaced, or editing requirements.

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 extraneous information. The first sentence states the core purpose, the second adds crucial details. Optimal length for this tool's complexity.

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

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

Covers the main purpose, feature format, and return value. Does not mention optional behavior or edge cases, but for a simple tool with few parameters this is sufficient.

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?

Despite 0% schema description coverage, the description provides an explicit example of the feature structure with attributes and geometry_wkt fields, compensating fully for the schema's lack of 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 clearly states the action ('Add features to a vector layer') and provides the return value and feature format. It does not explicitly distinguish from sibling tools like update_features, but the 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?

No guidance on when to use this tool versus alternatives (e.g., update_features, delete_features). Does not mention prerequisites like layer editability or when not to use.

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, and the description does not disclose behavioral traits such as what happens if the field already exists, if the layer is not a vector layer, or if the field type is invalid. The agent has no information about side effects or requirements.

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 short with two sentences, no fluff. The core action and important enum values are front-loaded. 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?

With 5 parameters, no output schema, and no annotations, the description is incomplete. It fails to explain return values, constraints (e.g., required formats, uniqueness), or error conditions, making it insufficient for an agent to use confidently.

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 add meaning. It only explains the field_type parameter with a list of values, but does not describe layer_id, field_name, length, or precision, leaving most parameters undefined.

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 'Add a new field to a vector layer' with a specific verb and resource, and lists the allowed field types, distinguishing it from sibling tools like delete_field and rename_field.

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

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

No guidance on when to use this tool versus alternatives (e.g., delete_field, rename_field) or what prerequisites are needed (e.g., layer must be editable, field_name must be unique).

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. It discloses that SQL layers are executed by the database and that geometry_column and primary_key may be needed for QGIS mapping. However, it does not mention side effects, permissions, or behavior if the layer already exists, 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 three sentences, front-loaded with the core purpose, and each sentence adds distinct value. No redundancy or filler.

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

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

For a tool with 8 parameters and no output schema, the description covers the primary use cases and key requirements (like geometry columns for SQL layers). It misses some parameter details but provides enough context for effective use in most scenarios.

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 table, schema, sql, geometry_column, and primary_key but leaves provider, connection, and name unexplained. This partial coverage is helpful but incomplete for an 8-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 tool's function: loading a table or SQL query from a saved connection as a project layer. The verb 'Load' and resource 'table from a saved connection' are specific, and the mention of SQL query layers distinguishes it from simple file-based layer additions.

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 the two main usage modes (pass table+schema or SQL) but does not explicitly compare with alternatives like add_vector_layer or execute_connection_sql. Usage context is implied but not contrasted, so the agent receives reasonable but not explicit 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 provided, so description carries full burden. It mentions text can contain dynamic expressions and color format, but lacks details on whether the label replaces existing ones, error handling, permissions, or units for x/y beyond '(mm)'. Significant gaps remain.

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 wasted words. Could be improved with structured bullet points for parameters, but it is concise and 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 the complexity (8 parameters, no annotations, no output schema), the description is incomplete. It fails to clarify required layout_name, optional defaults, expression syntax, or behavior when layout is missing. Many important aspects are omitted.

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 description must explain parameters. It only covers text (dynamic expressions) and color (hex format), and implicitly x/y via units. Parameters like width, height, font_size, and layout_name are unexplained. Insufficient for 8-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?

Description clearly states it adds a text label to a print layout, using a specific verb ('Add') and resource ('text label'). It distinguishes from sibling tools like add_layout_map or add_layout_legend, though it doesn't explicitly contrast 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?

No guidance on when to use this tool versus alternatives, no prerequisites (e.g., layout must exist), and no exclusion criteria. The description only states what it does without 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?

The description discloses that the legend is linked to a map item (defaulting to the first) and that position/size are in mm. However, it does not clarify error handling (e.g., missing layout), side effects, or whether the legend replaces existing ones. With no annotations, more detail would be beneficial.

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 unnecessary words. Essential information (purpose, default behavior, units) is front-loaded and clear.

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

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

Given 7 parameters, no output schema, and no annotations, the description provides a decent overview but omits details on layout_name (required), title purpose, and coordinate origin. It is adequate for basic understanding but not fully thorough.

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 description coverage, the description partially compensates by explaining map_item_id defaults and that x, y, width, height are in mm. However, title and layout_name are not elaborated, leaving ambiguity for 2 out of 7 parameters.

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

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

The description clearly states the verb 'add', the resource 'legend to a print layout', and key details like linking to a map item and dimensions in mm. It effectively distinguishes from sibling tools dealing with other layout elements.

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

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

Usage context is implied (adding a legend) but no explicit guidance on when to use this tool versus alternatives like add_layout_label or add_layout_scalebar. No exclusions or prerequisites mentioned.

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

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

The description only states the action and units. It does not disclose what happens if the layout does not exist, how coordinates are interpreted (e.g., page origin), or any error conditions. No annotations are provided to compensate.

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 that immediately conveys the core functionality. Every word is necessary and efficient.

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

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

Despite having 5 required parameters and no output schema or annotations, the description omits critical details like return value, error handling, coordinate system, and behavior when layout does not exist. It is insufficient for a user to fully understand the tool's behavior.

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 that x, y, width, and height are in millimeters, which is not in the schema. However, it does not clarify the meaning of layout_name or the coordinate system origin. With 0% schema description coverage, the description provides some but insufficient additional meaning.

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

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

The description clearly states the tool adds a map item to a print layout, specifying position and size in millimeters. This distinguishes it from sibling tools like add_layout_label or add_layout_legend, which add different elements.

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 such as add_layout_picture or other layout item tools. There is no context about prerequisites or limitations.

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 should disclose behavioral traits. It merely states the function without mentioning side effects (e.g., overwriting existing items), error handling for invalid paths, or permission requirements. The unit mention (mm) is helpful but insufficient.

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 consists of two short, front-loaded sentences. Every word adds value: the first sentence states the core purpose with examples, the second clarifies the path and units. No fluff 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?

Given the absence of output schema and the tool's complexity (6 parameters), the description is too minimal. It omits critical context like the need for a pre-existing layout, what happens on failure, and the overall effect on the layout. The agent would need to guess or fail.

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 the 'path' parameter (image or SVG file) and notes that position/size are in millimeters, which is not in the schema. However, it does not explain the other parameters (x, y, width, height, layout_name), leaving gaps despite 0% schema coverage.

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

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

The description clearly states the action ('Add a picture or SVG') and the target resource ('to a print layout'). It also provides concrete examples (logo, north arrow) and specifies file types, making the purpose unambiguous and distinct from sibling layout tools.

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

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

No guidance is provided on when to use this tool versus alternatives like add_layout_label or add_layout_map. There is no discussion of prerequisites (e.g., layout must exist) or exclusions, leaving the agent to infer usage 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?

With no annotations, the description carries full burden. It only says 'add' (a write operation) but lacks details on side effects, required permissions, what happens if parameters are omitted or invalid, or whether the tool modifies the layout in-place or returns something.

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

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

The description is concise with two sentences. No fluff. However, it could be restructured to front-load the essential purpose and include critical parameter guidance without expanding length excessively.

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 lack of annotations, output schema, and limited description, the tool definition is incomplete. It does not cover return values, error cases, how the scale bar interacts with the map item, or any configuration beyond style examples.

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 only adds value for the 'style' parameter by listing examples. Other parameters (x, y, width, height, layout_name, map_item_id) are left unexplained in both schema and description.

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

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

The description clearly states it adds a scale bar to a print layout linked to a map item. The verb 'add' and resource 'scale bar' are specific. However, it does not differentiate from siblings like add_layout_label, but the tool name is sufficiently distinct.

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 usage guidelines are provided. It does not mention when to use this tool vs alternatives (e.g., add_layout_legend), nor does it specify prerequisites like requiring an existing layout and map item.

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 full burden. It mentions max_rows and position/size in mm, but fails to disclose whether the tool is destructive, requires existing layout, or what happens on failure. Key behavioral traits are missing.

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

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

Two concise sentences with no superfluous words. First sentence states purpose, second adds key constraints. Ideal length, though could benefit from bullet-style breakdown.

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 7 parameters, no output schema, and no annotations, the description leaves out crucial information such as the structure of the added table, error handling, and required resources. Incomplete for reliable tool invocation.

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

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

Schema description coverage is 0%, so description must compensate. It explains max_rows and implies position/size for x,y,width,height, but does not describe layout_name, layer_id, or clarify all numeric units. Partial but insufficient.

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

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

The description clearly states the verb 'Add' and the resource 'attribute table for a vector layer to a print layout'. It distinguishes from sibling tools like 'add_layout_map' or 'add_layout_label' by specifying the type of layout item.

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. There is no mention of prerequisites (e.g., existence of layout or layer) or situations where another tool would be more appropriate.

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 the create-or-update behavior, which is transparent, but omits details such as whether the theme is applied automatically or any side effects on existing themes.

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

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

The description is concise with two sentences, front-loading the key action and behavior, and contains no unnecessary words.

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?

Although the tool is simple (one parameter, no output schema), the description lacks return value information, prerequisites (e.g., open project), and context about the 'current layer visibility state'. It is adequate but not fully complete for an agent.

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 description coverage, and the description only implicitly references the 'name' parameter without adding format, constraints, or examples. It fails to compensate for the schema's lack of detail.

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 specifies the action ('Create a map theme') and the resource ('from the current layer visibility state'), and distinguishes itself from siblings by noting the update behavior when the theme exists.

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

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

The description implies usage context (after adjusting layer visibility) but does not explicitly state when to use it versus alternative tools like 'get_map_themes' or 'apply_map_theme', 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, the description carries full burden for behavioral disclosure. It only states the basic action without mentioning side effects (e.g., overwriting existing layers), error handling, or prerequisites (e.g., valid file path). This is insufficient.

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, which is concise but lacks necessary detail. It is front-loaded with key information, but brevity sacrifices completeness.

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 no output schema, no annotations, and low parameter explanation, the description is very incomplete. It does not inform the agent about return values, potential errors, or the behavior of the tool under different inputs.

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%, meaning none of the three parameters (name, path, provider) are explained in the schema. The description adds zero information about parameter semantics, leaving the agent to guess their purpose and constraints.

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 'Add a raster layer (GeoTIFF, etc.) to the project' clearly states the verb (add) and resource (raster layer), distinguishing it from siblings like add_vector_layer and add_web_layer by specifying raster. However, it does not elaborate on supported formats beyond GeoTIFF.

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 no guidance on when to use this tool versus alternatives (e.g., add_vector_layer). There are no usage exclusions or context cues to help the agent decide.

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

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

The description lacks behavioral details. It implies a mutation (adding a join) but does not explain whether it modifies the layer permanently, if it can be undone, or any side effects. With no annotations, the burden on the description is high, and it fails to provide sufficient transparency.

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 no fluff, achieving conciseness. However, it is overly sparse and under-specifies the tool's functionality, which detracts from its effectiveness.

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 5 parameters and no output schema, the description is far from complete. It does not explain the join operation, required configurations, or expected outcomes, leaving an agent with insufficient information.

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%, meaning the input schema provides no descriptions for parameters. The description does not explain any parameter meanings (e.g., prefix, target_layer_id, join_field). This is a critical gap for a tool with 5 parameters.

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

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

The description clearly states the action: add a table join to a vector layer. It uses a specific verb and mentions the resource. However, it does not differentiate from the sibling tool 'spatial_join', which serves a similar 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?

No guidance is provided on when to use this tool versus alternatives like spatial_join or add_features. There is no mention of prerequisites, limitations, or recommended contexts.

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 provided. Description does not disclose behavior such as file existence checks, duplicate handling, or error conditions. Minimal disclosure of what 'add to project' entails.

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?

Single sentence is brief but omits essential information. Not efficiently conveying necessary details; conciseness here equates to underspecification.

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?

No output schema, 3 parameters with 0% coverage. Description is far too sparse for an agent to correctly invoke the tool. Lacks parameter usage, error handling, and return value context.

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%. Description mentions formats but does not explain the three parameters (path, name, provider), their expected values, or default behavior.

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?

Description clearly states 'Add a vector layer' and lists common formats (shapefile, GeoJSON, GeoPackage), distinguishing it from siblings like add_raster_layer and add_web_layer.

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

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

No guidance on when to use this tool versus alternatives (e.g., add_raster_layer, create_memory_layer). No prerequisites or exclusions mentioned.

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 fully carries the behavioral transparency burden. It discloses critical nuances: crs is only meaningful for WMS/WFS, XYZ tiles are always EPSG:3857, requesting another CRS for XYZ results in an error rather than a silent fallback, and the response reports the actual CRS. This is rich, actionable behavioral context that goes far beyond a basic summary.

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 compact paragraph of four sentences, each earning its place. It starts with the core purpose, then systematically covers service values, CRS semantics, XYZ-specific behavior, and response content. There is no redundancy or filler, making it highly efficient and well-structured.

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 tool with 4 parameters, no annotations, and no output schema, the description is remarkably complete. It covers the main purpose, service type semantics, CRS behavior, error conditions, and response content (actual CRS). It falls slightly short of full completeness by not addressing what happens on invalid service values or how the layer name is used, but these are minor 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?

Since the input schema has no property descriptions (0% coverage), the description must compensate. It explains the service values ('xyz', 'wms', 'wfs') and the nuanced behavior of crs for WMS/WFS vs XYZ. However, it does not explicitly explain the 'url' and 'name' parameters, though their semantics are reasonably inferable. Overall, it adds significant meaning beyond the raw 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 opens with a specific verb and resource: 'Add a web layer (XYZ, WMS, WFS) to the project.' This clearly states what the tool does and explicitly lists the supported service types, distinguishing it from sibling tools like add_vector_layer or add_raster_layer. The scope is well-defined and immediately comprehensible.

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

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

The description clearly implies when to use this tool (for web layers of types XYZ, WMS, WFS) and provides guidance on how to set the service parameter. It does not explicitly name alternative tools or state when not to use it, but the context is strong enough for an agent to infer appropriate usage. The CRS notes also give practical usage direction for different service types.

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

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

The annotation idempotentHint is present, indicating repeated applications have no additional effect. The description adds context by revealing that the tool modifies layer visibility to match the saved theme state, which is important because it changes the project's visual state. However, it doesn't mention error handling or prerequisites like the theme existing.

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 which fully states the purpose and effect in under 15 words. No wasted 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 tool is simple with one parameter and no output schema, so complete guidance should clarify that 'name' refers to an existing theme. The description doesn't mention that the theme must have been created earlier or what happens if it doesn't exist. Given the simplicity, the description is close but lacks these important contextual 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 schema has one required parameter 'name' with no description (0% coverage). The description mentions 'the theme' but doesn't explicitly state that the 'name' parameter is the map theme's name, nor does it clarify format or requirement that the theme must already exist. This leaves ambiguity despite the apparent simplicity.

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 map theme' and explains the effect: 'restores the layer visibility state saved in the theme.' This distinguishes it from sibling tools like add_map_theme and remove_map_theme, which manage themes.

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

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

The description implies the use case—restoring a saved layer visibility state—but doesn't explicitly state when to prefer this over direct layer visibility tools like set_layer_visibility. It offers no exclusions or alternative tool references, so guidance is minimal.

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 provided. The description does not disclose behavioral traits such as whether it overwrites existing style, if it requires the layer to be loaded, error handling, or side effects.

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 short sentence, which is concise and front-loaded with the verb. However, it is under-specified and could include additional context without becoming verbose.

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 tool with no output schema and two undocumented parameters, the description is incomplete. It lacks information on return values, prerequisites, and potential side effects.

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 adds no meaning to the parameters 'path' or 'layer_id'. It does not explain what format path should be (e.g., full path, URL) or how to obtain layer_id.

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

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

The description clearly states the action: 'Apply a QGIS QML style file to a layer.' It specifies the verb (apply), resource (QGIS QML style file to a layer), and distinguishes from siblings like 'set_layer_style' and 'save_style_qml'.

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

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

No guidance on when to use this tool versus alternatives (e.g., set_layer_style). No mention of prerequisites, when not to use, or typical 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?

With no annotations, the description must carry the behavioral burden. It discloses the restrictive behavior (disallowed destructive commands) and format, but does not mention execution order, failure handling, partial success, or response details. This is useful but incomplete for a batch execution tool.

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

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

The description is compact: two sentences covering purpose, format, and restrictions. Every sentence earns its place with no filler, and key information is front-loaded.

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

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

The tool is a batch wrapper and the description provides purpose, format, and key restriction. An output schema exists, so return values are covered elsewhere. Missing details like ordering or failure atomicity, but overall it's sufficient for selection and basic invocation.

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

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

Schema description coverage is 0%, but the description compensates by explaining the structure of the 'commands' parameter: each command is {"type": "<command_name>", "params": {...}}. It also lists disallowed command types, adding semantic meaning beyond the schema's bare array of objects.

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?

Description clearly states 'Execute multiple commands in a single round-trip', specifying the verb (execute), resource (multiple commands), and the value proposition (single round-trip). It differentiates from individual command tools by batching, and even gives the command format.

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

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

Provides explicit guidance on when not to use the tool: 'Destructive commands ... are not allowed in batch - use them individually.' This gives a clear exclusion and alternative. It implies usage for non-destructive multi-command scenarios, but doesn't elaborate on further use cases.

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

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

The description adds no behavioral context beyond the idempotentHint annotation. It implies a state change (clearing selection) but does not disclose side effects, events triggered, or confirmation requirements. The annotation already covers idempotence, but the description fails to add value.

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 short sentence, which is efficient and front-loaded. However, it earns its place by conveying the core action without extra words.

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 parameter and no output schema, the description adequately states the action. However, it could be more complete by clarifying that it clears the current feature selection on the specified layer, especially given the context of sibling selection 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?

With 0% schema description coverage, the description must explain the parameter but only mentions 'on a layer' without linking to layer_id or specifying its format (e.g., name, ID). No meaning is added beyond the schema structure.

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

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

The description clearly states the verb 'clear' and the resource 'selection on a layer', distinguishing it from sibling tools like select_features (which selects) and get_selection (which retrieves). 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?

No usage guidelines are provided. The description does not indicate when to use this tool, prerequisites (e.g., layer must have a selection), or when not to use it. No mention of alternatives like select_features or get_selection for 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. It discloses two key behaviors: committing the edit buffer and closing the edit session. However, it does not mention irreversibility, active-session requirements, or error handling, which are important for a mutation tool.

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

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

A single, front-loaded sentence that communicates the action and consequence without waste. Perfectly concise for a simple tool.

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 no output schema, the description covers the core behavior and side effect (close edit session). It implicitly assumes an active edit session, which is reasonable given the sibling tools. Minor lack of error-case details is acceptable for this simplicity.

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 only layer_id (string) with 0% coverage from the description. The description references 'the layer's' which implies layer_id identifies the target layer, but it doesn't explicitly map the parameter or explain format/requirements. It adds some semantic value but could be clearer.

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?

Description uses the specific verb 'commit' and identifies the resource ('layer's edit buffer') along with a side effect ('close the edit session'). This clearly distinguishes it from sibling tools like rollback_edits or start_editing.

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

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

The description implies usage as the final step in an editing workflow, but it does not explicitly state when to use this tool versus alternatives like rollback_edits or undo_edits. No exclusions or prerequisites are mentioned.

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

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

Annotations are absent, so description carries full burden. It explains core behavior (coverage_layer drives pages, optional expressions) but lacks details on side effects, prerequisites (layout must exist), or error conditions. Adequate but minimal.

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?

Single sentence of 25 words, front-loads purpose. No filler, 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?

No output schema, no return info. Lacks prerequisites (layout must exist) and error handling. Adequate for a straightforward configuration tool but could include more context given 6 parameters.

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 description must compensate. It explains coverage_layer and names three optional expressions but omits required layout_name and enabled. Adds meaning beyond schema for covered params but incomplete.

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

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

The description clearly states the verb 'configure' and the resource 'print layout's atlas'. It distinguishes from sibling tools like export_atlas by specifying that it configures the atlas, not exports it.

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

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

The description implies usage for setting up an atlas in a print layout. It doesn't explicitly state when not to use or mention alternatives, but the context is clear given the sibling tool set.

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, and the description does not disclose behavioral traits such as whether parent group must exist, effects on existing layers, or permission requirements. The description is too brief to convey behavioral context.

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

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

The description is a single short sentence, which is concise but sacrifices important details. It is front-loaded with the core action but lacks structure or elaboration, earning a moderate score.

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

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

Given the tool's simplicity (2 params, no output schema, no annotations), the description is incomplete. It does not clarify how layer groups behave in the tree, implications of missing parent, or any related constraints, leaving gaps for an AI agent.

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 minimal meaning for the 'parent' parameter (optional). The required 'name' parameter is not explained, and no constraints like uniqueness or naming rules are provided.

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 creates a new layer group in the layer tree with an optional parent, using a specific verb and resource. It distinguishes from siblings like 'move_layer_to_group' or 'add_vector_layer' by focusing on group creation.

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

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

No guidance is provided on when to use this tool versus alternatives, nor does it mention prerequisites or scenarios where the tool should not be used. The description only states what the tool does.

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 disclose behavioral traits but only states it creates a layout. It fails to mention side effects, such as whether the layout is added to the project, if it requires an open canvas, or what the return value is.

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

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

The description is too short to be useful; it is under-specified rather than concise. Every sentence should earn its place, but this single sentence provides no value beyond the title.

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

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

Given the tool's simplicity (one required parameter, no output schema, no annotations), the description is severely inadequate. It does not explain how to use the created layout with other tools or what happens after creation.

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 adds no extra meaning for the 'name' parameter. It does not clarify constraints, format, or purpose beyond the 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 'Create a new print layout.' merely restates the tool name and title, providing no additional information about what a print layout is or how it differs from sibling tools like add_layout_map or list_layouts.

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

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

No guidance is given on when to use this tool, what prerequisites are needed, or how it compares to alternatives such as adding map components or exporting layouts.

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 provided, so description carries full burden. It states 'create' indicating a write operation, but fails to disclose permissions, side effects (e.g., memory usage), or whether the layer persists beyond the session. This is insufficient for a mutation tool.

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

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

Two concise sentences pack essential information about the tool's purpose and parameter constraints without unnecessary words. No 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?

With no output schema and no annotations, the description should clarify return value or behavior after creation. It does not mention whether the layer becomes active, how to reference it, or error conditions. The tool is simple but still lacks completeness for a confident 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?

Description adds meaning beyond the schema by enumerating valid geometry types and specifying the fields format. However, it omits description for 'crs' and 'name' parameters. Schema description coverage is 0%, so description partially compensates but is incomplete.

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?

Description clearly states 'Create a new in-memory vector layer' with specific verb 'Create' and resource 'in-memory vector layer'. This distinguishes it from siblings like 'add_vector_layer' which adds file-based layers.

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?

Description implies in-memory usage but does not explicitly state when to use this tool over alternatives like 'add_vector_layer' or when not to use it. No guidance on context or prerequisites.

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

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

No annotations are provided, so the description carries full burden. It does not disclose whether an existing project at the path is overwritten, or any side effects, permissions, or initialization details.

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, concise sentence that communicates the essential action without any redundant or extraneous 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 tool with one parameter and no output schema, the description is minimally adequate but lacks details on default settings or behavior for existing paths.

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 description coverage, the description should explain the 'path' parameter beyond its type, but it merely says 'given path' without details on format, extension, or constraints.

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

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

The description clearly states the verb 'Create', the resource 'new empty QGIS project', and the action 'save it to the given path', distinguishing it from siblings like save_project and load_project.

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

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

The description implies usage for creating new projects but provides no explicit guidance on when to use this tool over siblings, nor does it mention prerequisites or when not to use it.

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

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

With no annotations, the description carries the full behavioral burden and does so: passwords are never accepted, credentials originate from QGIS Auth Manager or pg_service.conf, unused parameters are rejected, and it fails when the name exists or the database is unreachable. The port note (never assumes 5432) and ssl_mode default are additional non-obvious behaviors.

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?

Purpose and the password/credential rule are front-loaded, then the mode-specific parameter rules follow in a predictable order. It is dense with per-mode detail but each sentence carries required information; a bulleted mode breakdown would read more cleanly than the semicolon-heavy 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?

For a complex three-mode tool with 8 parameters, zero schema annotations, and no schema descriptions, the definition covers mode selection, credential sourcing, parameter exclusivity, failure conditions, and ssl behavior. Return shape is handled by the output schema, so nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 0%, so the description must supply all parameter meaning, and it does: host/port/database/auth_config_id for endpoint mode, service plus optional database override for service modes, the three connection_mode enum values, and ssl_mode's full value set with its default. Only 'name' is left implicit (as a unique identifier, clarified by the duplicate-name failure).

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

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

States a specific verb ('Validate and save') and resource ('a new PostgreSQL Browser-panel connection'), and the QGIS-panel framing distinguishes it from siblings such as add_layer_from_connection or import_layer_to_connection. An agent knows exactly what the tool produces without opening the schema.

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

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

Gives strong when-to-use conditions: it enumerates the three connection_mode branches, states which parameters each requires, and instructs the agent to ask the user which mode applies when intent is unclear. It does not name sibling tools (e.g., list_connections) as alternatives, so it falls just 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?

No annotations are provided, so the description fully bears the transparency burden. It discloses name collision behavior, ambiguity handling, error reporting, and response structure, exceeding typical annotation coverage.

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 front-loaded with the core purpose and critical usage notes, followed by a well-organized spec. Every sentence adds value, and the structure aids quick comprehension despite the complexity.

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

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

Given the tool's complexity, the description covers inputs, steps, outputs, error handling, and response format. It is self-contained and provides everything needed for correct invocation without relying on additional documentation.

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 explains all parameters in detail via the structured spec, including types, defaults, and usage patterns (e.g., @input_name, $step_id.OUTPUT). It fully compensates for the lack of schema descriptions.

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 builds a QGIS processing model from a spec and saves/registers it. It uses a specific verb and resource, and distinguishes from siblings like run_model or list_processing_algorithms.

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

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

Explicitly warns not to call list_processing_algorithms or get_algorithm_help first, and explains how to handle ambiguous hints and bad parameters. Provides clear when-to-use and 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?

The description adds value beyond the destructiveHint annotation by explaining the two targeting methods and the mutual exclusivity constraint. It does not contradict the annotation and provides useful behavioral context.

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

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

The description is extremely concise (two sentences) and front-loaded with the core action. Every word adds value, and there is no redundancy.

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

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

Given the tool's simplicity and the presence of destructiveHint annotation, the description is sufficiently complete. It covers the deletion methods and constraint, though it could mention the response or safety confirmations.

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 compensates by explaining the relationship between fids and expression (mutually exclusive) and their types. It does not mention the required layer_id parameter, but the core semantic gap is addressed.

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 action (delete features) and the two methods to specify which features (by IDs or expression). It distinguishes itself from sibling tools like remove_layer and remove_bookmark by specifying 'features' as the target.

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 explicit guidance on when to use this tool (to delete features) and the rule to provide either fids or expression, not both. However, it does not mention when not to use it or suggest alternative tools for non-destructive operations.

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

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

Annotations include destructiveHint: true, but the description adds no extra behavioral details beyond that. It does not mention whether the operation is permanent, what happens to related data (e.g., if the field has constraints), or any confirmation steps.

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 of 6 words, which is overly terse. While concise, it sacrifices critical information. The key details (parameters, effects) are missing, making it insufficient for reliable tool selection.

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 lack of parameter descriptions, output schema, and behavioral context, the description is severely incomplete. The agent cannot understand how to use the tool correctly without guessing parameter meanings or side effects.

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 explain the parameters. It does not mention 'layer_id' or 'field_name' at all, leaving the agent to guess their meanings. No formats, constraints, or examples are provided.

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 (delete) and the resource (field from a vector layer), making it immediately understandable. It also distinguishes itself from sibling tools like add_field and rename_field by specifying 'delete'.

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, prerequisites, or when not to use it. The description lacks context about required permissions or potential downstream effects such as data loss.

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

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

Annotations indicate readOnlyHint=true, and the description aligns by stating it runs checks and reports info without side effects. It adds value by describing the specific diagnostic categories, going beyond the annotation.

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 delivering essential information with no wasted words. The structure front-loads the action and lists outputs 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 zero parameters and the presence of an output schema, the description fully covers the tool's purpose and output scope. No gaps remain for an agent to interpret 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?

With zero parameters and 100% schema coverage, the description need not add param info. It still adds meaning by detailing what the output includes, which aids understanding.

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 runs diagnostic checks on the QGIS MCP stack and enumerates what it reports (version, match, providers, clients, project status). It distinguishes itself from sibling tools that focus on specific actions.

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

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

The description implies the tool is for overall stack health checks, but does not explicitly state when to use it versus alternatives like ping, get_qgis_info, or get_project_info. No exclusions or when-not-to-use guidance is provided.

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 provided, so description must carry full behavioral disclosure. It mentions copying style and new name but omits details like what happens if new_name already exists, error conditions, or side effects. Lacks sufficient transparency.

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?

Single sentence, 8 words—very concise. However, it omits important information like parameter definitions and usage context. Conciseness is good but at the expense of completeness.

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 two parameters, no output schema, and no annotations, the description is incomplete. It does not explain what layer_id is, return behavior, or constraints. User/agent would need additional context to use 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 description must compensate. It only hints at new_name's purpose ('under a new name') but does not explain layer_id or provide any format/validation details. Minimal added meaning.

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

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

The description clearly specifies the action (duplicate), the resource (layer), and includes the scope (including style, under new name). It distinguishes from sibling tools like add_vector_layer or remove_layer.

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

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

No guidance on when to use this tool versus alternatives, no prerequisites mentioned (e.g., layer must exist), and no conditions for when not to use.

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

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

Annotations indicate readOnlyHint=true. Description adds behavioral details: evaluates to scalar value, standalone, with optional layer scope. No contradictions. Lacks error handling details but sufficient.

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, well-structured, no redundant information. Front-loaded with core purpose and examples.

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 no output schema, the description sufficiently explains tool behavior and usage. It covers purpose, parameters, and distinguishes from siblings. Minor gap: no mention of return value format, but implied as scalar.

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 has no property descriptions (0% coverage). Description adds meaning: layer_id adds layer scope. Expression is required and standalone. Provides value beyond 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?

Description clearly states the tool evaluates a standalone QGIS expression to a scalar value, with specific examples. It distinguishes itself from sibling tools validate_expression and field_calculator.

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

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

Explicitly mentions optional layer_id for layer scope and contrasts with alternatives for validation and per-feature calculation, guiding when to use.

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?

Only destructiveHint=true is annotated, so the description carries the behavioral load and does so richly: elapsed seconds and stdout/stderr returned, timed_out=True with partial output on timeout, side effects persisting, QGIS blocking during execution, and the limitation that a single blocking call (time.sleep, GDAL) cannot be interrupted. This is exactly the operational detail an agent needs before running arbitrary 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?

Front-loads purpose in the first sentence, then stacks the return values, timeout behavior, and blocking caveat in dense, non-redundant sentences. No filler or restatement of the title.

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 no output schema and no annotation detail, the description steps in to describe return values (stdout/stderr, elapsed seconds, timed_out), side-effect persistence, and the runtime environment (QgsProject, iface, core QGIS classes). Nothing an agent needs to invoke this correctly is missing.

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

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

Schema coverage is 0% and there are no param descriptions, so the description must compensate. It fully specifies the timeout parameter (default 55, cancel semantics, timed_out flag, partial output, side effects standing) and the code parameter is self-evident from the 'arbitrary PyQGIS code' framing, though it never explicitly names the code field.

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

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

States a specific verb (Execute) and resource (arbitrary PyQGIS code) and immediately distinguishes itself from siblings with 'Use for operations not covered by other tools.' An agent can tell this apart from the many narrow, single-purpose sibling tools without opening any schema.

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

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

Provides an explicit routing rule ('operations not covered by other tools') and adds practical guidance on scoping work ('raise timeout or split bulk work into several calls'). It does not enumerate when-not-to-use beyond the fallback framing, so it falls short of a full 5.

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

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

Annotations already provide destructiveHint=true, and the description reinforces this by stating 'Can modify the database: DDL/DML run as issued.' It adds useful behavioral context beyond the annotation: server-side execution, distinction from virtual layers, and the limit parameter capping returned rows (-1 for all). It does not contradict the destructive hint.

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

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

The description is three concise sentences that front-load the primary purpose and immediately differentiate from a sibling tool. Every clause carries important information: server-side execution, virtual layer exclusion, mutability, and limit behavior. There is no redundancy or filler.

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

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

Given that the tool has an output schema and a destructive annotation, the description covers the key operational concerns: what it runs, where it runs, the mutability risk, and row limit control. It could be more complete by explaining provider and transaction semantics, but the existing information is sufficient for effective tool selection and basic 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 input schema has 0% description coverage, so the description must compensate. It meaningfully explains sql (SQL executed directly), connection (a saved connection), and limit (caps returned rows, -1 for all). However, the provider parameter is left unexplained, which is a notable gap since it is required.

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 specific function: 'Run SQL directly on the database behind a saved connection'. It also distinguishes itself from the sibling tool execute_sql by explicitly noting 'not a virtual layer - use execute_sql for that', which resolves potential ambiguity.

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

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

The description gives explicit usage guidance by naming the alternative tool for virtual layers ('use execute_sql for that'). It also warns that the tool can modify the database with DDL/DML, which helps agents decide whether to use this tool based on whether data mutation is intended or acceptable.

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 and does well: it discloses the default timeout (55s), that long jobs monopolize the QGIS session, that without load_results TEMPORARY_OUTPUT/memory results are discarded, and that only vector/raster destinations get loaded. It omits error/failure behavior and permission requirements, which keeps it short of a 5.

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

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

Front-loaded with the core action, then layered detail in descending priority. Every sentence carries concrete information, though the paragraph is dense and slightly overlong with stacked clauses on load_results.

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 free-form nested 'parameters' object with no output schema, the description supplies the missing context an agent needs, including the 'loaded_layers' return key and destination-type limits. Error handling and the algorithm-string format are the remaining 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?

Schema description coverage is 0%, so the description must compensate, and it does for three of four params: layer params accept layer IDs or file paths, OUTPUT can be 'memory:', timeout semantics, and load_results semantics. The 'algorithm' param's expected identifier format (e.g. provider:name) is left implicit, so not a full 5.

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

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

States a specific verb and resource ('Execute a QGIS Processing algorithm'), which cleanly separates it from run_model, execute_processing_batch, list_processing_algorithms, and get_algorithm_help in the sibling list. An agent can identify the tool's role without opening the schema.

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

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

Explicitly routes the agent to get_algorithm_help for parameter discovery and explains the load_results trade-off (only path to keep TEMPORARY_OUTPUT/'memory:' results). It gives clear context for when to set timeout higher, but never explicitly contrasts with execute_processing_batch or run_model for multi-algorithm/model workflows.

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 at all, the description carries the full burden and does disclose a genuinely non-obvious trait: the timeout is for the whole batch, defaults to 55s, and late runs return 'skipped' while completed runs are preserved. What it omits is side-effect disclosure — running arbitrary algorithms can create or overwrite data, and nothing warns about that or about permissions.

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

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

Three sentences, front-loaded with the core behavior, then batching rationale, then the timeout caveat. No filler and every clause carries operational information.

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

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

There is no output schema, and the description does describe the return shape ('per-run result with index and success/error status') plus partial-failure behavior under timeout. The remaining hole is how a caller discovers valid algorithm IDs and parameter keys, which the description leaves entirely to inference.

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 explains 'timeout' thoroughly (units, default of 55, effects on runs) and clarifies that 'parameters_list' is one dict per algorithm run, but it adds nothing about what an 'algorithm' string must contain (e.g., provider:algorithm id) or how dict keys must match that algorithm's parameters — a real gap for a 0%-coverage schema.

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

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

States a specific verb and resource ('Run one algorithm once per parameter dict in parameters_list') with the batch scope made explicit, which clearly separates it from the single-run siblings like execute_processing and run_model. An agent can tell what the tool does and how it differs from a one-shot execution without opening the schema.

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

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

Gives a clear usage condition: 'Use for applying the same operation over many inputs in a single round-trip,' plus a scaling instruction ('raise it or split the list for big batches'). It never names the single-run alternative or states when *not* to batch, 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?

The description discloses that results are limited to max 1000 rows inline and as_layer registers a new layer with optional geometry_field. However, it does not clarify if the tool is read-only, what happens on errors, or permissions needed. Since no annotations exist, the description carries full burden but leaves 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 concise with two sentences, front-loading the core purpose. It could be better structured with bullet points for parameters, but the density is acceptable given the tool's complexity.

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

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

With 6 parameters, no schema descriptions, and no output schema, the description is insufficient. It does not explain return format for inline results, default values, or the effect of uid_field. The tool is complex and needs more detail to be fully usable.

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 explain parameters. It covers as_layer, geometry_field, and layers, but omits query, uid_field, and layer_name. The query parameter is implied but not defined. This forces the agent to infer syntax and meaning.

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

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

The description clearly states the tool executes SQL across loaded layers via a virtual layer, specifying the key capability. It distinguishes itself from sibling tools as the only SQL execution tool.

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

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

The description implies usage through mention of referencing layers by name and as_layer behavior, but lacks explicit guidance on when to use inline vs as_layer, or constraints on SQL statements. No alternatives are discussed, though it is unique among siblings.

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

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

Annotations provide idempotentHint true. Description adds output behavior: pdf single file, images one file per feature, output_path directory for images. This adds value beyond annotations.

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

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

Two sentences, front-loaded with action, no waste. Every sentence adds value.

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

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

No output schema, so return value unknown. Parameters partly explained. Adequate for a 4-param tool but missing dpi 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 coverage 0% requires parameter explanation. Description only implicitly mentions format and output_path, but dpi and layout_name are unexplained. Format options explained adequately.

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 'Export a configured atlas' with specific verbs and resource. It distinguishes from siblings like export_layout by focusing on atlas export and format behaviors.

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

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

Explicit prerequisite 'Call configure_atlas first' and format-specific guidance (pdf vs image formats). No explicit when-not to use, but context is clear.

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

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

Annotations already mark idempotentHint=true. The description adds key behavioral details: output format derived from extension, reprojection via target_crs, and vector-only filter expression. Missing overwrite behavior, but overall informative.

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

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

Two sentences, no wasted words, front-loaded with main action. Efficient and easily parsed.

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: export layer to file. Description covers format, reprojection, and filtering. No mention of return value or error handling, but for this complexity level it's largely complete. Could note filter is vector-only, which it does.

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 has 0% description coverage, so description carries full burden. It explains target_crs and filter_expression with examples, and clarifies output_path extension influences format. layer_id is left implicit but is standard. Good compensation for schema 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 clearly states the tool exports vector/raster layers to disk, with format determined by file extension. This distinguishes it from siblings like export_layout or render_map that handle different output types.

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 does not explicitly compare to alternatives but implies usage for file export. The context of siblings makes it clear this is the appropriate tool for exporting layers to disk, though no 'when not to use' guidance is provided.

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

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

Annotations provide idempotentHint=true, indicating safe re-execution. The description adds format and dpi constraints but omits behavioral details like file overwrite behavior or error conditions. No contradiction with annotations.

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

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

The description is very concise with two short sentences, front-loading the core action. However, it could be slightly clearer by separating format and dpi into a list or structured 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?

Given 4 parameters, no output schema, and only idempotentHint annotation, the description lacks essential context: prerequisites (layout must exist), path constraints, and what happens on success/failure. Sibling tools like create_layout hint at dependencies not addressed here.

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 partially compensates by explaining format values and dpi default. However, layout_name and path are not described beyond the schema, leaving their roles implicit.

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

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

The description clearly states the verb 'export' and the resource 'print layout', and the allowed formats are listed. This distinguishes it from sibling layout tools like create_layout or add_layout_map, which do not export.

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 explicit guidance on when to use this tool vs alternatives like export_atlas or export_layer. The description assumes the agent knows to use this for single layout export, but lacks context on prerequisites (e.g., layout must exist) or limitations.

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 discloses that the operation is in-place, adds the field only if missing, processes per feature, and returns the updated count. However, it omits details about access rights, whether existing fields are overwritten (only 'if missing' is mentioned), and potential side effects (e.g., irreversible modification).

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

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

The description is concise: two sentences and an example. The main action is in the first sentence, front-loading the purpose. Every part is useful, though the example could be integrated more naturally. No unnecessary words.

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 tool with 6 parameters, no output schema, and no annotations, the description covers the core functionality (adding and populating a field) but leaves gaps: parameters 'length' and 'precision' are undocumented, and the return value 'updated feature count' lacks type/format. Sibling tools are numerous, but the description doesn't explicitly differentiate from close ones like 'add_field' or 'evaluate_expression'.

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 'field_type' by listing allowed values (string, int, double, etc.) and default (double). It uses an example to clarify 'expression' and 'field_name'. However, 'length' and 'precision' (integer with default 0) are not explained at all, and schema coverage is 0%, so the description only partially compensates.

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 adds a field if missing and populates it using a QGIS expression per feature in-place. It lists valid field types and provides a concrete example, making the purpose unambiguous. It distinguishes from siblings like 'add_field' (which only adds) and 'evaluate_expression' (which only evaluates).

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

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

The description gives an example but offers no explicit guidance on when to use this tool versus alternatives like 'add_field', 'update_features', or 'evaluate_expression'. It does not state prerequisites, contraindications, or post-conditions.

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

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

Annotations already indicate readOnlyHint=true. The description adds behavioral details about fnmatch wildcard and substring matching support, which is valuable context beyond what annotations provide.

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

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

Two concise sentences with no wasted words. Front-loaded with the core action and immediately followed by key matching details.

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

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

With an existing output schema, the description does not need to explain return values. It covers matching semantics well, but could mention that it returns layer objects for completeness.

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 name_pattern parameter by specifying wildcard and substring matching, though a more explicit format example would be even better.

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 finds layers by name pattern, specifying support for fnmatch wildcards and substring matching. This distinguishes it from sibling tools like get_layers or get_active_layer.

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 does not explicitly guide when to use this tool versus alternatives like get_layers. It implies usage for pattern-based search but lacks explicit when-to-use or 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?

Annotations declare readOnlyHint=true, which is consistent. The description adds behavioral details: it reuses the open view's scene and camera, renders via a print-layout 3D map item, and clarifies that camera overrides apply only to the capture without affecting the live view. This provides useful context beyond annotations.

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

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

The description is well-structured, front-loading the main action and providing details in a logical order. It is relatively concise given the parameter count, but slightly verbose with parentheses; however, every sentence adds valuable 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 tool with 5 optional parameters and no output schema, the description covers prerequisites, parameter semantics, and non-destructive behavior. It lacks explicit return format (e.g., image type or size), but the title and 'inline image' imply the result. Overall, it is sufficiently 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?

With 0% schema description coverage, the description fully explains each parameter. It defines dpi, view_index, and camera overrides (pitch, heading, distance) with concrete examples (e.g., '0 = straight down/top-down, 90 = horizontal/edge-on') and notes that overrides are applied only to the capture. This compensates entirely for the schema 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 clearly states the tool captures an open 3D map view as an inline image. It differentiates from get_canvas_screenshot by noting the 2D tool cannot capture OpenGL 3D views, making the purpose specific and distinct.

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

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

Explicitly states when to use this tool (when a 3D map view is open) and when not (clarifies get_canvas_screenshot for 2D). Also provides prerequisites (requires 3D map view open in QGIS) and alternative tools, guiding correct 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?

The description correctly indicates a read operation, consistent with the 'readOnlyHint' annotation. However, it adds little beyond that; the annotation already signals no side effects. The description does not elaborate on return format or other behavioral traits.

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 concise single sentence that immediately conveys the tool's purpose. No extraneous 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 parameterless tool with a clear read-only annotation and an output schema, the description provides sufficient context. The existence of the output schema compensates for any missing details about return values.

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 parameters, so the description does not need to explain parameter semantics. The baseline for zero parameters is 4, which is appropriate.

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

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

The description clearly states the tool retrieves the currently active layer from the QGIS layer panel. It uses a specific verb-resource combination and is easily distinguished from the sibling tool 'set_active_layer'.

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

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

The description implies the tool should be used to query the active layer, but it does not explicitly state when not to use it or mention alternatives. Given the sibling 'set_active_layer', the context is clear enough for an agent.

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

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

The description indicates a read-only retrieval operation ('get'), which is consistent with the readOnlyHint annotation. It adds that it returns parameter details, outputs, and description, but does not provide additional behavioral context such as error conditions or permissions beyond what annotations already convey.

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

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

The description is a single sentence that is concise and front-loaded with the core purpose. Every word adds value; no unnecessary information is present.

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

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

Given the tool's simplicity (one parameter, read-only, with output schema), the description adequately covers the return structure (parameters, outputs, description). It does not discuss possible errors or format details, but the presence of an output schema reduces the need for additional return value explanation.

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 algorithm_id is not described in the description; the description only lists the kinds of information returned (parameters, outputs, etc.) but does not clarify what algorithm_id represents or how to obtain it. With 0% schema description coverage, the description fails to compensate and adds no meaning beyond the raw 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 clearly states the verb 'Get' and the resource 'detailed help for a processing algorithm', specifying exactly what is returned (parameters, outputs, description). This distinguishes it from sibling tools like execute_processing (which runs algorithms) and list_processing_algorithms (which lists algorithms).

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 detailed information about a specific algorithm is needed, but it does not explicitly state when to use this tool versus alternatives, nor does it provide any exclusion criteria. Guidance is limited to the implicit purpose.

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

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

Annotations provide readOnlyHint=true. The description adds the structure of returned bookmarks (name, group, extent, CRS). No contradictions.

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?

Single sentence, front-loaded with verb and resource, no wasted words. Perfectly concise.

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 no parameters and an existing output schema, the description adequately explains what the tool returns. Could mention that an empty list is returned if no bookmarks exist, but not critical.

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

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

With zero parameters, schema coverage is 100%. Description adds meaning about the return structure, which is helpful beyond the empty 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 clearly states the tool retrieves spatial bookmarks from the project and enumerates the fields (name, group, extent, CRS), distinguishing it from siblings like add_bookmark and remove_bookmark.

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?

Context is clear: use to get existing bookmarks. Sibling tools add_bookmark and remove_bookmark handle other operations. No explicit exclusions needed given the simplicity.

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

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

Annotations already declare readOnlyHint=true. Description adds that it returns extent and CRS but no additional behavioral traits beyond what annotations provide.

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

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

One concise sentence with no wasted words. Front-loaded with key action and output.

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?

Low complexity tool with no parameters and an output schema. Description fully adequate for an agent to understand purpose and return value.

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?

No parameters exist, so schema coverage is 100%. Baseline for 0 parameters is 4. Description does not add parameter info, but none 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?

Clearly states it gets the current map canvas extent and CRS. Distinguishes from siblings like set_canvas_extent (write) and get_canvas_screenshot (different output).

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 explicit guidance on when to use vs alternatives. However, as a simple getter, usage is implied. No exclusions or alternative suggestions provided.

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

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

Annotations already declare readOnlyHint=true, so safety is clear. The description adds specific details about what is retrieved (scale, rotation, magnification), providing value beyond annotations by specifying the exact properties.

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 efficiently and clearly conveys the tool's purpose without any unnecessary words.

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 no parameters and an output schema exists, the description adequately informs the agent about the tool's functionality and what to expect.

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?

No parameters exist, and schema coverage is 100%. Per guidelines, baseline is 4. Description does not need to add parameter information.

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 (Get) and the resource (current map canvas scale, rotation, and magnification factor). It distinguishes from sibling set_canvas_scale by focusing on reading rather than writing.

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 explicit usage guidance is provided. However, the context implies it is the read counterpart to set_canvas_scale and should be used when retrieving current canvas properties. Lacks explicit when-not-to-use or 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?

Annotations already indicate readOnlyHint true, so safety is covered. The description adds behavioral details: no re-render, fast, returns inline image, which is consistent with annotations. It does not disclose potential limitations such as format or resolution, but given the low risk, it's adequate.

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

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

Two concise sentences with no unnecessary words. The key points (fast, no re-render, inline return, faster than render_map) are front-loaded and immediately actionable.

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 no parameters and clear annotations, the description covers essential context. It mentions the return type and performance benefit. Could specify image format, but not critical for 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?

With zero parameters and 100% schema description coverage, the baseline is 4. The description adds no parameter specifics because none exist, but this is appropriate.

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

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

The description clearly states it grabs a fast screenshot of the current map canvas widget without re-render, and distinguishes itself from render_map by noting it is much faster. This effectively differentiates it from siblings like get_3d_screenshot and render_map.

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

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

The description implies usage when a fast screenshot without re-render is needed, and contrasts with render_map by highlighting speed. However, it does not explicitly exclude scenarios where a full render is required, but the context is clear enough.

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

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

The annotation readOnlyHint=true already signals a safe read operation. The description adds context by specifying exactly which attributes are returned (editable, modified, undo/redo availability, counts), giving the agent a clearer behavioral picture beyond the annotation. No contradictions.

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

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

The description is a single sentence that is front-loaded with the resource ('Edit state of a layer') and immediately lists the key output categories. There is no redundant information or filler.

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

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

The tool is simple (one parameter, read-only) and an output schema exists, so the description need not explain return values in detail. The description captures the core functionality well. Missing edge cases like layer-not-found or not-editable behavior are minor and acceptable for a status query.

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's single parameter layer_id has no description, so the description must compensate. The phrase 'of a layer' clarifies that the tool operates on a specific layer, but it does not explicitly define the parameter or provide additional format/semantics. With 0% schema coverage, the description partially compensates but could be more explicit.

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 returning the edit state of a layer, enumerating specific data points (editable, modified, undo/redo availability, counts of pending changes). This is a specific verb+resource+scope, and it distinguishes the tool from editing mutators like start_editing or commit_edits.

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

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

The description implies usage when a user needs to inspect the current edit status of a layer, but it does not explicitly state when to use this tool versus alternatives, nor does it provide exclusions or context about editing workflows. Given the many edit-related sibling tools, explicit alternatives would be helpful.

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

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

Annotations provide readOnlyHint=true, and the description adds behavioral detail: handling of non-numeric fields. This goes beyond the annotation. However, it doesn't mention edge cases like missing values or performance constraints.

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 succinct sentences, front-loaded with the main purpose. No redundant or unnecessary words.

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 presence of an output schema (not shown here), the description doesn't need to detail return values. It covers both numeric and non-numeric cases. Minor gap: no mention of parameter constraints (e.g., field must exist, layer must be loaded).

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 should compensate for missing parameter descriptions. It does not explicitly define layer_id or field_name; only implicitly through context. For 0% coverage, this is insufficient to guide parameter selection.

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 it computes aggregate statistics (count, sum, mean, min, max, stdev) for a numeric field. It also specifies behavior for non-numeric fields (count and distinct values). This distinguishes it from sibling tools like get_unique_values or field_calculator.

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 (when you need aggregate stats for a field), but does not explicitly provide guidance on when not to use it or compare to alternatives. Sibling tools like field_calculator or zonal_statistics could be misused if the agent doesn't know the distinction.

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