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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses that this changes UI state and must precede camera/export commands, but says nothing about failure modes, whether an already-active map errors, or what state changes persist — meaningful gaps for a state-changing tool with zero 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?

Two compact sentences with zero filler, and the effect (activate view) is front-loaded ahead of the prerequisite note. Every clause earns its place.

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

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

With one parameter, an output schema present, and the sequencing constraint stated, the definition covers what an agent needs to invoke it correctly. Only the error/edge-case behavior is absent, which is a minor gap given the output schema carries return 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?

Only one parameter and schema description coverage is 100%, so the schema already fully documents map_name as 'Map to activate.' The description adds no syntax, naming, or matching semantics beyond that, making baseline 3 appropriate.

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

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

States a specific verb and resource: 'Open/activate a map's view in the ArcGIS Pro UI'. This is clearly distinct from adjacent siblings like list_maps, get_map_view and set_map_view, though the description never explicitly contrasts itself with 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?

Gives explicit prerequisite ordering: 'Needed before camera commands and export_map_view'. That tells the agent when this call is required rather than optional. It stops short of naming exclusion cases (e.g. what happens if the map is already active), so it is clear context without full when/when-not 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 are provided, so the description carries the full burden of behavioral disclosure. It does not say what happens if the field already exists, whether a schema lock or edit session is required, whether the operation is reversible, or what the response contains — significant gaps for a mutation tool with zero 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?

A single efficient sentence with the action front-loaded and zero waste. It is well-formed, though the terseness is arguably under-specification rather than disciplined conciseness.

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 10-parameter mutation tool with no annotations, the one-sentence description is not complete: it omits prerequisites (schema locks, edit sessions), failure behavior, and any routing versus add_fields/alter_field. The presence of an output schema excuses it from explaining return values, but not from the rest.

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

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

Schema description coverage is 100% across all 10 parameters (map_name, field_type, nullable, field_domain, etc.), so the schema already explains each argument thoroughly. The description adds nothing beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (Add) and resource (field) plus its targets (a layer or table), which is clear enough for an agent to know what the tool does. However, it does nothing to distinguish itself from the sibling add_fields (plural), so an agent cannot tell which one to pick without inspecting both schemas.

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

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

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as add_fields, alter_field, or delete_field. The agent must infer the single-field scope from the tool name alone.

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 supplied, so the description carries the full burden for a schema-mutating operation. It says nothing about whether the layer must be editable, whether the addition is transactional across the batch, or what happens if one field definition is invalid – all material for a write 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 seven-word sentence with the verb and the batch benefit front-loaded and no filler. It is efficient, though its brevity reflects thin content rather than disciplined editing.

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

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

An output schema exists, so return values need not be explained, but for a write tool with zero annotations and multiple sibling field-manipulation tools, the description omits editability requirements, batch failure semantics, and any routing to add_field or alter_field.

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

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

Schema description coverage is 100%, and the schema already documents layer_name, map_name defaults, and even an example field object. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a clear verb+resource (“Add several fields”) and the mechanism (“in one call”), which implicitly distinguishes it from the sibling add_field by signalling batch behavior. It stops short of naming add_field explicitly, so an agent must infer the single-vs-batch split.

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 when-to-use guidance, no mention of prerequisites, and no reference to the obvious alternative add_field for single-field additions. A reader knows what it does but not when to prefer 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 provided, the description carries the full behavioral burden. It states that the folder is registered but does not disclose persistence, permissions, side effects on the project, idempotency, or whether the folder path must already exist.

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

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

The description is a single efficient sentence that is front-loaded with the core action. It contains no wasted text and is appropriately sized for the 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?

The tool is simple with two parameters and an output schema, so the description need not explain return values. However, for a registration/mutation tool with no annotations, it remains incomplete regarding usage context and behavioral 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 100%, and both parameters are documented in the schema as 'Folder path' and 'Display name.' The description adds no further syntax, format, or constraint details beyond what the schema already provides, so the baseline score of 3 is appropriate.

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

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

The description uses a clear verb-plus-resource phrase, 'Register a folder with the project,' and adds the practical outcome 'so its data is easy to browse.' It clearly identifies the action, but does not explicitly distinguish this tool from siblings such as list_folder or search_data.

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 a context, making folder data easy to browse, but gives no explicit when-to-use guidance, prerequisites, or alternatives. It does not tell an agent when to choose add_folder_connection over nearby data-access tools.

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

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

No annotations are provided, so the description carries the full behavioral burden and does not meet it. It does not say whether the join is virtual or materialized, whether an existing join is replaced, what happens on unmatched records (KEEP_ALL vs KEEP_COMMON is only in the schema), or what errors occur on field mismatch.

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 with zero redundancy, and the operative detail (join target, common field) comes first. It is efficient, though the extreme brevity borders on under-specification rather than true conciseness.

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

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

An output schema exists so return values need not be explained, but for a six-parameter mutation tool with no annotations the description leaves critical gaps: join semantics, replace/overwrite behavior, and permission or field-type requirements are all absent.

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

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

Schema description coverage is 100%, so every parameter including keep_all and map_name is already documented in the schema. The phrase 'on a common field' loosely gestures at layer_field/join_field but adds no syntax, format, or constraint detail beyond the schema. Baseline 3 applies.

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

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

States a specific verb (join) and both resources (table, layer) plus the keying condition (common field). It is clearly distinguishable from the closest sibling, remove_join, though it does not say which join type is produced.

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 when-to-use guidance, no prerequisites (matching field types, existing join behavior), and no reference to alternatives such as remove_join or add_layer. The agent must infer everything about 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 behavioral burden. It says data is added but does not disclose what happens on an invalid path, required permissions/licensing, how the target map is chosen (that is only in the schema), or whether an existing layer is overwritten. An output schema exists, which offsets return-value concerns, but the mutation's side effects remain undisclosed.

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: verb + destination first, then the accepted input types. No filler, though the enumerated list is long enough that the key 'add to a map' framing is slightly buried.

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

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

An output schema lets the description skip return values, and the schema documents all four parameters, so basics are covered. However, for an unannotated mutation tool it is thin on side effects, failure modes, and how it relates to add_web_layer.

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

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

Schema description coverage is 100%, so baseline is 3, and the description genuinely enriches the path parameter by enumerating the concrete dataset and service types it accepts. Still, it adds nothing to position, group_layer, or map_name beyond the schema.

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

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

States a specific verb (Add) plus resource (data to a map) and enumerates accepted inputs (feature class, shapefile, raster, table, .lyrx, web service). It is clear and concrete, but does not differentiate itself from the sibling add_web_layer, which it overlaps with by mentioning service URLs.

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

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

The description gives no when-to-use guidance, no prerequisites, and never mentions alternatives such as add_web_layer or create_map. The agent must infer from the sibling list when this tool is the right choice.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it says nothing about side effects on the layout, whether the change is persisted only via save_project, permission needs, or defaults applied when optional params are omitted. 'Add' implies mutation but no mutation semantics are disclosed.

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

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

A single, well-formed sentence with no filler, front-loading the action and target. It is appropriately sized, though it is arguably under-specified rather than merely 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?

An output schema exists, so return values need not be explained, and the schema fully documents parameters. However, for a 10-parameter mutation tool with no annotations, the description omits prerequisite and persistence context that an agent would want before calling it.

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

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

Schema description coverage is 100%, and each of the 10 parameters is documented in the schema (x/y in page units, layers to include, style_item, etc.). The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb (add) and resource (legend) and scopes it to a layout's map frame, which distinguishes it from sibling add_layout_* tools like add_layout_text or add_layout_scale_bar. It does not explicitly name those siblings, but the resource 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 versus other layout-element tools, and no prerequisites stated (e.g., the layout and named map frame must already exist). The agent must infer everything about 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 behavioral disclosure burden. It implies a mutation and a dependency on a layout's map frame, but does not mention persistence, required permissions, effect on existing layout elements, or error conditions when the layout or map frame is 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?

The description is a single front-loaded sentence with no redundant or filler text. Every word contributes to identifying the action and the target element.

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 schema is fully described and an output schema exists, so return-value explanation is unnecessary. However, for a mutation tool with no annotations, the description lacks usage context and behavioral detail that would make it complete beyond the minimum viable level.

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

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

Schema description coverage is 100%, so the schema already documents each parameter's meaning and units. The description adds no parameter-level detail beyond what is structured, and the baseline of 3 is appropriate.

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

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

The description gives a specific verb and resource: 'Add a north arrow' tied to a layout's map frame. This clearly identifies the tool versus siblings that add legends, scale bars, or pictures. It stops short of explicitly naming alternatives or routing conditions, so sibling differentiation is implicit rather than explicit.

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

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

The description states what the tool does but gives no guidance on when to use it, when not to use it, or which sibling tools to prefer. An agent must infer usage from the resource name alone.

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 behavioral burden, and it discloses almost nothing: no mention of whether the change persists to disk, whether an existing layout is required, what happens on an invalid picture_path, or whether duplicate names are allowed. 'Place' implies a mutation but adds no operational detail.

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 short sentence with zero filler, front-loaded on the action. It is efficient, though the terseness leaves little room for structural cues about required inputs.

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

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

An output schema exists and parameter coverage is complete, so return values and argument formats are covered elsewhere. What remains missing for a layout-mutating tool with no annotations is prerequisite/state context (does the layout need to exist, are edits saved), leaving the definition merely adequate.

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

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

Schema description coverage is 100% and all seven parameters (x, y, name, width, height, layout_name, picture_path) are documented in the schema itself. The description adds no positional, unit, or format semantics beyond what is already structured, so the baseline 3 applies.

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

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

States a clear verb+resource ('Place an image... on a layout') and names a concrete example (logo), which makes the intent unambiguous. It doesn't explicitly contrast itself with siblings like add_layout_text or add_layout_legend, but the 'picture' resource is distinct enough to infer the boundary.

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 when-to-use guidance, no prerequisites, and no alternatives offered. It doesn't say whether the layout must exist/be active first, or whether create_layout must precede 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?

No annotations are provided, so the description carries full behavioral burden. It hints that the scale bar is tied to a map frame but omits whether this mutates the layout, what happens if the map frame is missing, whether changes are persisted, or any permission/rate considerations.

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, efficient sentence that front-loads the action and resource. No wasted words, though it is minimal to the point of possibly under-specifying.

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 annotations and a mutation tool that adds an element to a layout, the description should explain side effects, required layout state, or return behavior. It does none of this. The presence of an output schema reduces the need to describe return values, but behavioral aspects remain unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents all eight parameters. The description adds the key semantic that the scale bar is 'tied to' the layout's map frame, clarifying the relationship between layout_name and map_frame_name beyond what the schema's individual descriptions state. Baseline is 3 when schema coverage is high; the relational hint warrants a 4.

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: adding a scale bar that is tied to a layout's map frame. It is distinguishable from siblings like add_layout_legend and add_layout_north_arrow by resource, though it doesn't explicitly name 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 exclusions. The description is purely a statement of function.

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

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

No annotations are provided, so the description must carry the full behavioral burden. It only says it adds a text element; it does not disclose whether the layout must exist, if it requires an active project, whether the operation is reversible, or what happens on success/failure. Significant gaps 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?

The description is a single efficient sentence with no wasted words. It is front-loaded with the action and resource. Could be slightly shorter, but it is appropriately sized.

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 10 parameters, no annotations, and an output schema, the description is minimally adequate. It omits behavioral context like prerequisites and side effects, but the output schema may cover return values. For a mutation tool with no annotations, more context would be beneficial.

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

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

Schema description coverage is 100%, so all 10 parameters are already well-documented in the schema. The description adds no parameter details beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description clearly states a specific verb ('Add') and resource ('text element such as a title or credits') to a layout, distinguishing it from siblings like add_layout_legend or add_layout_picture. It doesn't explicitly name alternatives, 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?

Usage is implied by the verb and the required parameters (layout_name, text), but there is no explicit guidance on when to use this tool versus other layout element tools. 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?

No annotations are supplied, so the description carries the full behavioral burden, and it discloses little beyond the act of creation. It does not state that this mutates the layout, whether the change is persisted, what happens if layout_name or map_name is invalid, or that an existing element name may collide. The existence of an output schema covers return values, but the mutation semantics remain opaque.

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 front-loaded sentence with no filler. It is efficient, though its brevity comes at the cost of the guidance dimensions rather than being a model of tight-but-complete writing.

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?

A fully documented schema and an output schema mean parameters and returns are covered, so the description need not restate them. However, for a mutating layout-construction tool with zero annotations, the absence of any prerequisite or side-effect statement leaves a real gap that the structured fields cannot fill.

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

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

Schema description coverage is 100%, so all seven parameters are already documented in the schema. The description only gestures at 'a page position', which corresponds to x/y, adding nothing about units, defaults, sizing, or the map_name fallback that the schema does not already say. Baseline 3 is appropriate.

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

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

Specific verb (add) plus resource (map frame) plus target container (a layout) and rough placement (a page position). An agent knows exactly what the tool does, but there is no differentiation from the many layout-element siblings such as add_layout_text, add_layout_legend, or add_layout_scale_bar.

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

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

The description gives no when-to-use guidance, no prerequisites (e.g. that the named layout must already exist), and no routing against sibling layout tools. The only hint is the parenthetical notion of placement.

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 behavioral burden. It implies a mutation ('Add') but does not disclose permission requirements, side effects on the active map, authentication needs for the service URL, or what happens if the URL is unreachable.

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 with a compact parenthetical list of supported service types. It is appropriately sized for a straightforward add operation and contains no filler.

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

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

With an output schema present and full schema description coverage, the return and parameter details are covered elsewhere. However, with no annotations, the description should clarify where the layer is added (active map vs. named map) and any side effects, which it leaves to the schema.

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

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

Schema description coverage is 100%, and the schema already documents 'url' as 'Service URL' and 'map_name' as the target map. The description reinforces that a web service URL is expected and lists service types, but adds no syntax, format, or constraint details beyond the schema.

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

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

The description gives a specific verb and resource — 'Add a web service layer' — and enumerates the supported service types (Feature/Map/Image service, WMS, WMTS, vector tile). It implicitly distinguishes from the sibling add_layer by scoping to web services, but it does not name or contrast any sibling explicitly.

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

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

The description states what the tool does but gives no guidance on when to use it versus alternatives such as add_layer or get_capabilities. There is no mention of prerequisites, when-not conditions, or how to choose between adding a local layer and a web layer.

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 behavioral burden. It states the mutation types but omits permissions, reversibility, conflict behavior for new_name, or whether field_length is limited to text fields beyond a schema note.

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 with no wasted words. It is concise and easy to scan, though its extreme brevity leaves some important context unstated.

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 an output schema and full parameter descriptions, this is a mutation tool with no annotations and no usage or safety guidance. The description does not say when to use it, what it requires, or what side effects it has, so it is not complete enough for 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?

Schema description coverage is 100%, and the description adds no parameter semantics beyond what the schema already documents. Baseline 3 applies because the schema does the heavy lifting for all six 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?

States a specific verb ('Rename') and resource ('field'), plus alias/length alteration variants. It is clearly distinct from add_field/delete_field siblings, but does not explicitly name alternatives or scope conditions.

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 when-to-use guidance, prerequisites, or comparison to siblings such as add_field, delete_field, or calculate_field. The description only says what the tool can do, leaving the agent to infer 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 provided, the description carries the full behavioral burden. It does not disclose what happens if the bookmark is missing, whether the bookmark is saved to a specific map, or whether the view change is persisted — all relevant for a tool that mutates map view state.

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 with no wasted words. It is appropriately sized for a simple two-parameter tool, though it is arguably sparse.

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

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

An output schema exists, so return values need not be explained, and both parameters are fully described in the schema. The description is adequate for this low-complexity tool, with only error behavior left unstated.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema, establishing a baseline of 3. The description adds no extra semantics such as how bookmark names are resolved or what happens when map_name is omitted.

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

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

The description states a specific verb ('Zoom') and resource ('the map view'), clearly identifying the operation. It distinguishes itself from bookmark siblings like list_bookmarks and create_bookmark by implication, though it never explicitly names 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?

There is no guidance on when to use this tool versus alternatives such as zoom_to_layer, zoom_to_selection, or set_map_view. The agent must infer that the bookmark must already exist and that this only changes the view extent.

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 but discloses almost nothing beyond the copy action. It does not say whether existing symbology is overwritten, what permissions are needed, or how the update_symbology option affects behavior.

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

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

A single sentence with zero waste, front-loading the verb and resource immediately. Every word earns its place.

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

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

The tool is a moderate-complexity mutation on layer symbology with no annotations. The output schema covers return values, and the input schema is fully documented, but the description omits behavioral context such as overwrite semantics or required map state.

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

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

Schema description coverage is 100%, so the schema already explains all four parameters. The description adds no extra parameter meaning beyond restating that symbology_source can be a .lyrx file or another layer. Baseline 3 applies.

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

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

The description states a specific verb ('Copy symbology') and resource, and names the possible sources (.lyrx file or another layer). It is clear but does not explicitly differentiate from siblings like get_layer_symbology or set_layer_renderer.

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 when-to-use, when-not-to-use, prerequisites, or alternative tools are mentioned. The agent gets only the action itself, not the context for selecting this tool over related symbology tools.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses almost nothing. It doesn't state that this mutates layer data (a write operation likely requiring save_edits), which fields/rows are affected, permission needs, or reversibility. The expression example is illustrative but not behavioral.

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 efficient sentence with an inline example that is front-loaded and wastes no words. It avoids padding but is arguably thin rather than over-long.

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

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

An output schema exists, so return values needn't be explained, but with zero annotations on a data-mutating tool the description should disclose the write/save semantics and side effects it omits. For a 6-parameter geoprocessing-style tool, this leaves meaningful gaps.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters (map_name, code_block, expression, field_name, layer_name, expression_type). The description only adds expression syntax via the example, so baseline 3 applies.

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

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

States a specific verb (Calculate) and resource (field values) with concrete scope ('across a layer') and a sample expression, so the agent understands it computes values into fields. It does not, however, distinguish itself from siblings like add_field, alter_field, or update_features.

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 when-to-use or when-not-to-use guidance is given, and no alternatives are named. The agent must infer the context from the tool name alone.

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 behavioral burden. It mentions the optional checkout but does not disclose that checkout consumes/holds a licence (a stateful mutation), whether it is reversible or auto-returned, or any permission requirements. The one hint it gives is already present in the schema's checkout parameter description.

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 with no filler, front-loading the primary action and appending the optional variant. 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?

An output schema exists, so return values need not be explained, and the schema documents both parameters. What is missing is the behavioral context a licence tool needs: whether checkout has persistent state consequences. Adequate but with a clear gap.

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

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

Schema description coverage is 100%, with both parameters documented and the extension parameter listing example values. The description adds no semantics beyond what the schema already states, so the baseline of 3 applies.

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

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

States a specific verb (check) plus resource (ArcGIS extension licence) and notes the optional checkout variant. No sibling tool in the list deals with licence state, so sibling differentiation is not needed, but the sentence is terse enough that the exact distinction between 'check' and 'check out' is left to the parameter name.

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

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

There is no statement of when to use this tool versus alternatives, nor any prerequisite (e.g. that a licence server must be reachable, or that checkout is needed before extension-dependent geoprocessing). Usage is only loosely implied by the verb.

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 the scope of the operation (a single layer vs. every layer) but does not state whether clearing all layers is the default, that other layers are unaffected by a single-layer clear, or the reversibility/permission profile of the mutation.

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 with zero filler, and the layer-vs-all-layers distinction is front-loaded so the agent immediately grasps the two operating modes.

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 only two optional, fully documented parameters and an output schema covering return values, the description is nearly sufficient for correct invocation. It could explicitly note that all layers is the default and that the operation is state-only, but the core requirement is met.

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

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

Schema description coverage is 100%, so both map_name and layer_name (with their 'defaults to active map' / 'default all layers' semantics) are already documented in the schema. The description's phrase 'one layer, or on every layer' adds a light restatement but no new syntax or format detail, so baseline 3 applies.

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

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

The description gives a specific verb ('clear') and resource ('selection') plus the scope (one layer or every layer in the map). This is clear and allows an agent to infer it is the inverse of set_selection, but it does not name that sibling explicitly to harden the distinction.

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

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

Usage is only implied – one reads that you call this when you want to deselect. There is no explicit when-to-use, when-not-to-use, or reference to set_selection/zoom_to_selection as the alternative. Adequate but leaves routing to inference.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: no read-only/safety profile, no statement that counting avoids materializing geometries, no note on cost for large layers. The existence of an output schema covers return shape, but the description adds no behavioral context beyond the title.

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 with no waste, and the optional-filter qualifier is placed correctly after the core action. It is efficient, though its brevity is partly under-specification rather than pure conciseness.

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

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

For a simple one-required-parameter count tool with a full output schema and complete parameter documentation, the description is minimally sufficient. It nonetheless omits any guidance on how this differs from other feature-reading siblings, which is the main gap given the crowded tool family.

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

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

Schema description coverage is 100% – layer_name, map_name, and where are all documented in the schema, including the map_name default and the SQL nature of the where clause. The description merely echoes the where parameter, adding no syntax or format detail, so the baseline 3 applies.

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

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

States a specific verb and resource ("Count features") with the optional filtering scope, so the operation is unambiguous. It does not differentiate itself from siblings like get_features or summarize_features, which also operate on layer features, but the name plus description make the core action clear.

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

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

The phrase "optionally matching a where clause" hints at filtering but gives no when-to-use guidance, no prerequisites, and no routing against get_features, get_field_statistics, or summarize_features. An agent must infer that this is the lightweight counting alternative to pulling full feature records.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the core action but does not mention side effects, persistence, overwrite behavior for duplicate names, required preconditions (e.g., an open map/project), or permissions, leaving significant gaps 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?

The description is a single front-loaded sentence with no wasted words. It efficiently conveys the core action and scope, making it easy for an agent to parse quickly.

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

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

Given the tool's simplicity, full schema coverage, and the presence of an output schema, the description need not explain return values and the parameters are well documented. However, it lacks usage guidance relative to siblings and any behavioral caveats, leaving notable gaps for an agent deciding when to call it.

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

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

Schema description coverage is 100%, so the schema already documents all four parameters (name, extent, map_name, description) with meaningful descriptions. The description adds only a slight conceptual mapping ('current view' vs 'given extent'), but no syntax or format details beyond the schema. Baseline 3 is appropriate.

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

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

The description states a specific verb ('Save') and resource ('bookmark'), along with the scope ('current view, or a given extent') and that it creates a 'named' bookmark. This clearly separates it from siblings like list_bookmarks, apply_bookmark, and delete_bookmark, though it does not explicitly name those alternatives.

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

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

Usage is implied: this is the tool for creating a bookmark. However, the description offers no explicit when-to-use guidance or mention of alternatives such as apply_bookmark for applying an existing bookmark. The agent can infer the context but receives no routing help.

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 does disclose a genuinely non-obvious default: that the feature class lands in the project's default geodatabase and is added to the map, which is not derivable from the schema (out_path defaults to null). However, it says nothing about failure modes, name collisions, permission/project prerequisites, or whether the project must be saved.

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 with zero waste, front-loaded with the action and followed by the two most decision-relevant defaults. Nothing extraneous.

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

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

An output schema exists, so return values need not be explained, and the schema fully documents the 10 parameters. What remains missing for a mutation tool with no annotations is usage routing against siblings and any note on error/prerequisite 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?

Schema description coverage is 100%, so the schema already documents all 10 parameters (epsg, fields, template, geometry_type, etc.). The description adds only the meaning of the default output location, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource ('Create an empty feature class') and adds two meaningful scope details: the default output geodatabase and that the result is added to the map. It is clear enough to distinguish from create_table/create_file_geodatabase, but it never names a sibling or contrast case explicitly.

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

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

There is no when-to-use or when-not-to-use guidance. With siblings like create_table, create_file_geodatabase, and add_layer in the same namespace, the agent gets no help choosing among them. Only default behavior ('by default in the project's default geodatabase') is stated, which is not usage routing.

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

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

No annotations are provided, so the description carries the full burden of disclosure. It does not say what permissions or workspace state are required, what happens if the geodatabase already exists, or how it relates to the project home default that the schema mentions. For a mutating creation tool this is a notable gap.

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

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

It is a single well-formed sentence with no wasted words, but it is also nearly a restatement of the tool name, so brevity here reflects under-specification rather than disciplined editing.

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

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

An output schema exists so return values need not be described, and the parameters are fully covered by the schema. However, with no annotations and no usage guidance, the definition is only minimally viable for a creation tool.

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

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

Schema description coverage is 100%, so both 'name' (with .gdb suffix behavior) and 'folder' (default project home) are already fully documented. The description adds nothing beyond the schema, so the baseline of 3 applies.

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

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

The description states a specific verb (Create) and resource (file geodatabase), which is enough to distinguish it from siblings like create_feature_class or create_table that operate on different dataset types. It is clear but adds no scoping detail beyond the name-and-resource pairing.

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

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

There is no guidance on when to use this tool versus alternatives such as create_feature_class or add_folder_connection, and no prerequisites (e.g., workspace/folder must exist) are mentioned. The agent must infer usage entirely from the tool name.

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

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

With no annotations, the description carries the full behavioral burden. It usefully discloses the key side effect that existing layers can optionally be moved into the new group, but it does not cover permission requirements, ordering effects, failure behavior for invalid layer names, or what happens to pre-existing group structures. Some valuable context, but far from complete.

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

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

The description is a single front-loaded sentence with no wasted words. It leads with the primary action and appends the optional behavior efficiently. Well-sized for a simple creation 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?

The tool is relatively simple, the input schema fully documents all three parameters, and an output schema exists, so the description need not explain return values. It covers the core action and optional move behavior adequately, though it omits some usage and edge-case context. Overall complete enough for correct invocation.

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

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

Schema description coverage is 100%, so the schema already documents name, map_name, and layer_names in full. The description only echoes the layer_names concept by mentioning 'moving existing layers into it,' adding no syntax, format, or default details beyond the schema. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

The description gives a specific verb and resource: 'Create a group layer.' The added phrase 'optionally moving existing layers into it' clarifies the tool's scope, but it does not explicitly differentiate itself from siblings such as add_layer or move_layer. Clear purpose, but no named sibling differentiation.

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

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

There is no explicit guidance on when to use this tool versus alternatives like add_layer or move_layer, nor any prerequisites or exclusions. The optional layer_names behavior implies you can combine group creation with moving layers, but this is not framed as usage guidance. This is essentially implied-only 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 behavioral burden. It only mentions the default map frame, which is already captured by the schema defaults, and omits whether this is a persistent creation, requires an open project, or affects the active map.

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 front-loaded with the verb and resource, with zero waste. It is appropriately sized for a tool whose parameters are fully described elsewhere.

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

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

An output schema exists and the input schema fully documents parameters, reducing the description's burden. However, with no annotations, the description should provide more behavioral context (e.g., prerequisites, side effects) for a creation tool; the one-sentence description leaves that gap.

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

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

Schema coverage is 100%, so all 8 parameters are documented in the schema. The description adds no parameter-specific meaning beyond the default map frame behavior already encoded in the schema defaults, making the baseline 3 appropriate.

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

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

States a specific verb 'Create' and resource 'layout page', and notes the default map frame. It does not explicitly distinguish itself from sibling layout tools like add_map_frame or create_map, but the resource type is clear.

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 when-to-use, prerequisites, or alternatives are mentioned. Sibling tools such as list_layouts or preview_layout exist but are not referenced, leaving the agent to infer 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 states the tool creates a map, but says nothing about permissions, whether the new map becomes the active map, whether the change persists only after save_project, or any error conditions. For a mutation tool with zero annotation coverage, this is a substantial gap.

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

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

A single wasted-free sentence with the key action front-loaded. It is arguably too terse for a mutation tool, but there is no padding or redundancy.

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

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

An output schema exists so return values need not be explained, but the absence of annotations and any behavioral/prerequisite context leaves a mutation tool under-specified for an agent deciding whether and how to call it.

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

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

Schema description coverage is 100%, so epsg, basemap, name, and map_type are already documented in the schema with examples. The description only echoes map/scene, which corresponds to map_type, adding little beyond the schema. Baseline 3 applies.

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

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

"Create a new map or scene in the project" gives a specific verb (create) and resource (map/scene), and the mention of both map and scene maps to the map_type parameter. It is clearly distinguishable from siblings like list_maps or remove_map, though it does not explicitly name 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 versus alternatives, nor any prerequisites (e.g. project open, whether the map becomes active, whether it must be created before add_layer). The agent must infer usage entirely.

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 behavioral burden. It says the table is empty and standalone but does not disclose side effects such as writing to a workspace, requiring an out_path or active geodatabase, or adding the result to the map by default.

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

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

The description is a single front-loaded sentence with no filler. It immediately states the core action and result.

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

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

An output schema exists and parameter descriptions are complete, so the description does not need to explain return values or parameter syntax. However, for a creation tool with no annotations, it still omits important usage and side-effect context, leaving it minimally adequate.

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

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

Schema description coverage is 100%, so the schema already documents all six parameters well. The description adds no parameter meaning beyond what is already in the schema, which matches the baseline of 3 for high-coverage schemas.

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

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

The description states a specific verb and resource ('Create an empty standalone table'). The word 'standalone' distinguishes this from the sibling create_feature_class, which creates a spatial feature class rather than a non-spatial table.

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

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

The description gives no when-to-use guidance, prerequisites, or alternatives. It does not mention create_feature_class, add_field, or any condition under which another tool would be preferable.

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 behavioral burden. It only restates that a deletion occurs; it does not disclose whether the deletion is permanent, what permissions are needed, what happens if the bookmark does not exist, or how the active map default behaves.

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

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

The description is a single front-loaded sentence with no filler. It efficiently communicates the core action without wasting tokens.

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 deletion tool with a rich input schema and an output schema, the description is minimally adequate. However, the absence of annotations means it should do more to cover destructive behavior and usage 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 100%, so both parameters are already documented in the input schema. The description adds only 'from a map' and no additional syntax, default behavior, or edge-case meaning beyond what the schema already provides.

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

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

The description states a specific verb ('Delete'), resource ('bookmark'), and scope ('from a map'). It distinguishes the tool from siblings such as list_bookmarks, create_bookmark, and apply_bookmark without requiring schema inspection.

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

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

There is no guidance about when to use this tool versus alternatives, nor any prerequisites, exclusions, or warnings about deletion. The agent must infer usage solely from the tool name.

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

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

No annotations are provided, so the description carries the behavioral burden. It adds one crucial behavioral fact — 'This cannot be undone' — which signals destructiveness and irreversibility. However, it omits permission requirements, whether it requires the dataset to be unopened, and what happens to related resources.

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

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

Two short sentences, front-loaded with the action and immediately followed by the critical irreversibility warning. Zero waste.

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

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

For a single-parameter destructive tool with an output schema present (return values need not be explained), the essential information — action, scope, and irreversibility — is covered. Missing only permissions/prerequisite details, which is a minor gap.

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

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

Single parameter with 100% schema description coverage ('Dataset path.'). The description doesn't add path format details beyond the schema, so it neither helps nor hurts. Baseline 3 applies when schema coverage is high.

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 ('Delete a dataset') and clarifies scope ('from disk or a geodatabase'), distinguishing it from sibling delete_features (feature deletion) and delete_layout. Clear but doesn't explicitly name those siblings.

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

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

No guidance on when to use this tool versus alternatives like delete_features or truncate_table, nor prerequisites (e.g., schema locks, required connections). The irreversibility warning is a caution, not usage 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 are provided, so the description carries the full burden for a destructive tool, yet it only says 'Delete rows'. It omits that the operation is irreversible, that deletions stay pending unless save_edits is set, and that allow_delete_all gates a full-table wipe. The schema hints at these behaviors, but the description itself adds nothing.

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 short sentence with the action front-loaded and no filler. It is efficient, though arguably under-specified rather than maximally economical for a six-parameter destructive 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?

An output schema exists so return values need no explanation, but for a destructive, six-parameter mutation with zero annotations the description leaves critical gaps: irreversibility, the confirmation gate, and the pending-vs-committed edit distinction. An agent could plausibly call it without realizing edits are not persisted by default.

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

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

Schema description coverage is 100%, so the schema already documents where, map_name, layer_name, save_edits, allow_delete_all and use_edit_session. The description only echoes the where clause and adds no syntax, format, or interaction detail beyond the schema, which is the expected baseline.

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

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

The description gives a specific verb and resource ('Delete rows') plus a scope qualifier ('matching a where clause'). It is clearly distinct from dataset-level siblings like delete_dataset or truncate_table, though it never names an alternative to make that contrast explicit.

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

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

There is no when-to-use guidance at all: nothing about when to prefer this over truncate_table or delete_dataset, no mention of the edit-session workflow, and no hint that a follow-up save_edits may be required. The agent must infer the entire workflow from sibling names and schema defaults.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does not say whether the deletion is permanent/irreversible, whether it requires save_edits or an active edit session, whether it works on shapefile/table data sources, or what happens to dependent data — significant gaps for a destructive 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 short sentence, front-loaded with the verb and resource, with no filler. It is arguably under-specified rather than padded, so it earns credit for efficiency but not a perfect 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?

For a destructive mutation tool with no annotations, the description omits edit-session requirements, irreversibility, and permission context. The output schema and parameter descriptions partially compensate on return values and arguments, but the behavioral gaps remain material.

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

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

Schema description coverage is 100%, so each parameter is documented in the schema, giving a baseline of 3. The description's 'one or more fields' hints that field_name and field_names are alternative ways to specify targets, but it never clarifies that they are mutually exclusive or whether both can be passed.

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

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

The description states a specific verb (Delete) and resource (fields) with scope (one or more), so the basic operation is unambiguous. However, it does not distinguish this from siblings like alter_field or delete_dataset, nor clarify the relationship to add_field/delete_features.

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

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

There is no when-to-use guidance, no note about required edit sessions or save_edits, and no mention of alternatives such as alter_field or delete_dataset. The agent must infer applicability entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses almost nothing: it does not say whether deletion is permanent, whether layout elements are affected, or whether the layout must be closed/saved first. For a destructive tool this is a substantial gap.

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

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

A single sentence with zero filler, and the action is front-loaded. It is efficient, though brevity here shades into under-specification rather than tightness.

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

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

The tool is simple (one required param, output schema present so return values need no explanation), which lowers the bar. Still, as an unannotated destructive operation it should at minimum warn that the deletion is permanent - that omission keeps it from being fully complete.

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

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

Schema description coverage is 100% and the single layout_name parameter is documented in the schema as 'Layout to delete,' so the description adds no parameter meaning beyond the structured data. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description states a specific verb (Delete) and resource (a layout from the project), so the agent knows exactly what the tool does. However, it offers no differentiation from close siblings such as delete_layout_element or remove_map, leaving the agent to infer the boundary.

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

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

There is no guidance on when to use this tool instead of delete_layout_element, nor any warning about prerequisites, confirmation, or irreversibility. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It does not state whether the deletion is permanent, whether it requires the layout to be open, or what the output schema returns. This is a significant gap 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 short sentence with zero waste. It is front-loaded and efficient, though perhaps overly terse for a mutation 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?

The tool has no annotations, an output schema, and complete parameter documentation, but the description fails to describe side effects, reversibility, or error conditions. Given it is a destructive operation, more context is needed.

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

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

Schema description coverage is 100%, so the two parameters are already documented in the schema. The description adds no syntax, format, or constraint details beyond what the schema provides, making the baseline 3 appropriate.

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

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

States a specific verb (Remove) and resource (element from a layout). It does not distinguish itself from siblings like set_layout_element or delete_layout, but the resource 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 such as set_layout_element or delete_layout, nor prerequisites or side effects. Usage must be inferred entirely from the name.

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

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

No annotations are provided, so the description carries the full burden. It discloses the implicit non-mutating, non-map-changing behavior ('without adding it to a map') and enumerates the returned metadata fields. It doesn't state whether it works on local vs remote datasets or error behavior, but it adds meaningful behavioral context beyond a bare 'describe'.

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 front-loaded sentence; the resource, the operation, and the output fields are packed efficiently with no wasted 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?

Output schema exists, so return values need not be explained, and the description still names the key fields. For a simple one-parameter read tool this is essentially complete; it could note scope limitations (local vs remote) but nothing essential is missing.

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

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

Schema coverage is 100% and only one parameter exists, so schema does the heavy lifting (baseline 3 for high coverage). However the description adds value by framing 'path' as 'any dataset by path', signaling the parameter accepts arbitrary dataset paths, slightly above baseline. No param = 4 floor context; with 1 param this is a fair 4.

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

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

Specific verb (describe) + resource (dataset) + the exact information returned (type, geometry, CRS, extent, fields, row count). The 'without adding it to a map' clause sharply distinguishes it from add_layer and get_layer_info in the sibling set.

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?

Clear context: it describes a dataset by path. The 'without adding it to a map' scoping implies this is the right tool when you don't want to load a layer, which differentiates from get_layer_info/add_layer. No explicit when-not or named alternative, so not a 5.

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

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

With no annotations, the description carries the behavioral burden and does so reasonably: 'Get' and 'before running it' signal a read-only, non-executing metadata lookup. It does not explicitly state that no side effects occur or describe auth requirements, but for this tool type the read-only implication is strong and accurate.

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

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

It is a single front-loaded sentence with no wasted words. Every element—verb, returned metadata categories, and timing relative to execution—earns its place.

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

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

Given a single parameter, full schema coverage, and an existing output schema, the description is complete enough for correct selection and invocation. It states what metadata is returned and when to call it; no further detail is needed for this low-complexity tool.

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

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

Schema coverage is 100% and the single parameter tool_name already includes an example format, so the schema does the necessary work. The description adds no further parameter semantics beyond what the schema provides, making the baseline 3 appropriate.

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

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

The description states a specific verb ('Get') and resource ('a tool's parameters, data types, defaults and usage text'), making the purpose immediately clear. The phrase 'before running it' distinguishes this metadata-retrieval tool from execution siblings such as run_geoprocessing_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 explicitly says to use it 'before running it,' which gives a clear usage context relative to execution tools. It does not name an alternative tool or give a when-not condition, but the timing guidance is sufficient for this simple describe operation.

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 what is inspected, but never states that it is a read-only, non-destructive operation or whether it reports errors versus returning status values. Adequate but incomplete for a diagnostic tool with zero 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?

Two tight sentences: the scope is listed first, then the usage trigger. Every clause earns its place with no filler.

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

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

An output schema exists, so return-value detail is not the description's job, and with zero parameters and a 100%-covered schema there is nothing further an agent needs to invoke it correctly. The description supplies the scope and trigger, which is the right amount.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to clarify beyond the empty schema, which is already fully covered.

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 ('self-check') and resource ('connection') and enumerates exactly what is inspected (version, licence, project, active map, map view, write access). This differentiates it from sibling diagnostics like ping and get_arcgis_info, though it does not name those siblings explicitly.

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

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

Gives a clear trigger condition ('Run this first when something does not work'), which is actionable troubleshooting guidance. It falls short of 5 because it does not name alternative diagnostic tools (ping, get_capabilities, get_arcgis_info) or state when this is unnecessary.

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 entire behavioral burden. 'Throw away' does signal data loss, but it omits that the operation is irreversible, whether an edit session must be active, and whether confirmation/permissions are required for a destructive action.

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 four-word sentence that is front-loaded and free of padding. It is arguably too terse for a destructive operation, but there is no wasted wording.

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

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

An output schema exists so return values need not be explained, but for a destructive, annotation-free tool the description leaves key behavior (irreversibility, edit-session prerequisite, alternative save_edits) unstated.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the schema is fully covered by definition.

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 verb-plus-resource phrasing ('Throw away pending edits') clearly states the operation and is easy to distinguish from the sibling save_edits. It doesn't explicitly name the sibling or the state it operates on, 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?

There is no guidance on when to use this versus save_edits, nor any prerequisite such as needing an active edit session or an open workspace. The agent must infer usage entirely from the name.

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

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

No annotations are provided, so the description carries the full disclosure burden. It implies mutation (a copy is added to the map) but does not say whether the new layer lands in the table of contents, whether the original is untouched, what the copy is named if new_name is omitted, or whether the operation is reversible - all material for a write tool with zero 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?

A single sentence with no padding, and the purpose ('copy a layer within the map') is front-loaded ahead of the rationale. Nothing to trim.

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

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

An output schema exists, so return values need no explanation, and the schema fully documents the three parameters. The remaining gap is behavioural detail about the resulting duplicate (position in the TOC, default name), which for a simple duplication tool is a minor omission.

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

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

Schema description coverage is 100%, so map_name, new_name, and layer_name are already documented in the schema, including the default-to-active-map behaviour. The description adds no parameter-level meaning beyond that, so the baseline 3 applies.

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

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

The description gives a specific verb and resource ('Copy a layer') plus scope ('within the map'), so an agent immediately knows this duplicates a layer rather than editing it. It does not contrast itself with siblings that also change how a layer is drawn, notably apply_symbology_from_layer or set_layer_renderer, which is the main ambiguity a caller faces.

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 clause 'so it can be symbolised differently' implies the intended use case - you want two visual representations of the same data - but never states when to prefer duplication over apply_symbology_from_layer or set_layer_renderer, and gives no prerequisites or exclusions. Usage is inferable but not spelled out.

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 the description must carry full behavioral load and does: it discloses that the ArcGISProject('CURRENT') binding is pre-initialized, that variables persist between calls (a significant stateful behavior), and that print() output is captured and final expressions returned. These are non-obvious execution semantics critical to correct invocation.

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

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

Three tightly packed sentences: first the what/where, then the execution semantics, then the routing rule. Zero waste, front-loaded purpose.

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 annotations, an output schema, and a straightforward 2-param schema, the description covers purpose, environment, statefulness, output handling, and usage guidance. Nothing an agent needs to call it correctly is missing.

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

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

Schema description coverage is 100% (both 'code' and 'reset_namespace' are documented in the schema), so the schema already carries parameter meaning. The description adds only context about the execution environment rather than parameter-level guidance. Baseline 3 is appropriate.

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

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

States a specific action (run Python) on a specific resource/context (inside ArcGIS Pro) with an environment detail (arcpy pre-imported). Clearly distinguishes itself from the many dedicated sibling tools by framing itself as the general-purpose escape hatch.

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: 'whenever no dedicated tool covers the task.' This is a textbook routing rule for a fallback tool within a large sibling set of CRUD 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?

With no annotations, the description carries the full behavioral burden. It does disclose a genuinely important trait — the output is shaped by the layer's live selection and definition query — but omits other critical behaviors: whether an existing dataset at out_path is overwritten, what happens to the selection/definition-query interaction with the `where` parameter, and what permissions are needed.

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 sentence, front-loaded with the action and resource, with the behavioral caveat set off by em-dashes so it does not dilute the main clause. No filler.

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

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

An output schema exists, so return values need no explanation, and the description covers the key filtering behavior. Still, for a write-to-disk tool with no annotations it should say whether out_path is overwritten, what dataset types are acceptable, and whether add_to_map applies only when a map context exists.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds real meaning by clarifying that there is already an implicit where (the layer's definition query) that the schema's 'Extra where clause' parameter supplements, and that selection state is an implicit filter not represented by any parameter.

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 ('Export') and resource ('a layer') plus the destination ('to a new dataset'), which is enough to distinguish it from export_map_view, export_layout, and export_map_series in the sibling list. It does not explicitly name any sibling, so it falls short of a 5.

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

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

Usage is implied rather than stated: mentioning that the export honours the current selection and definition query signals this is the tool to use when you want a filtered/selected subset exported. However, there is no explicit when-to-use, when-not-to-use, or named alternative (e.g., get_features or run_geoprocessing_tool for plain copies).

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 it does disclose two real behaviors: format is driven by the output extension and PNG/JPEG are returned inline. It omits whether an existing file at output_path is overwritten, permission requirements, and whether the file is written to a local or server path — significant gaps for a file-writing 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 short sentences, front-loaded with the action and the supported formats, with no filler. Every clause carries information the agent can act on.

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 2-required-param export tool with no output schema and no annotations, the description covers formats and the inline-image return but leaves out the side-effect profile (overwrite behavior, where the file lands). It is adequate to call, but not complete for a mutating file-export tool.

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

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

Schema description coverage is 100%, so dpi, layout_name, output_path, and return_image are already documented, and the baseline is 3. The description adds only the extension-determines-format and inline-image details, which restate what output_path and return_image already say.

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

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

The description gives a clear verb (export) and resource (layout) plus the enumerated output formats, so the agent knows exactly what the tool produces. It does not, however, distinguish itself from siblings like export_map_view or export_map_series, which also write rendered output to disk.

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 note that PNG/JPEG come back inline so the result can be checked implies a reason to pick those formats, which is a mild usage hint. There is no explicit when-to-use guidance relative to export_map_view or export_map_series, and no prerequisites are stated.

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

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

No annotations are provided, so the description carries the full burden, and it does disclose the resulting artifact (a multi-page PDF written to output_path). However, it says nothing about overwrite behavior for an existing file, required permissions/ArcGIS Pro session state, or failure modes when a layout lacks a map series.

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

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

A single sentence that front-loads the action and the artifact with zero filler. Nothing could be trimmed without losing information.

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

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

An output schema exists, so return values need not be explained, and all four parameters are covered by the schema. The only real gap is the absence of any prerequisite or overwrite context, which is minor for a straightforward export tool.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds no syntax or format detail beyond that, so the baseline of 3 applies.

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

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

States a specific verb (Export) and resource (a layout's map series / map book) plus the output artifact (multi-page PDF). It is distinguishable from siblings like export_layout or preview_layout by name, though it never explicitly contrasts with 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 when-to-use guidance, no prerequisites (e.g., that the layout must have a map series enabled), and no routing away from export_layout for single-page exports. The agent is left to infer the choice from the tool name alone.

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 usefully discloses the environmental precondition (the map tab must be open) and the return format (an inline image), which goes beyond the schema. It does not state error behavior when the tab is closed, whether a file is written when output_path is supplied, or any side effects/reversibility, so the behavioral picture is partial.

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

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

Two short sentences, zero filler, and the core action is front-loaded before the prerequisite. Every clause earns its place by adding either purpose or a constraint.

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 7-parameter tool with 100% schema coverage, no annotations, and no output schema, the description covers the essentials: what it renders, what it returns, and the environment requirement. It stops short of describing failure modes or how file output interacts with return_image, which would be the remaining gap.

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

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

Schema description coverage is 100%, so dpi, width, height, map_name, output_path, return_image, and zoom_to_layer are already documented in the schema. The description adds no syntax, format, or interaction detail (e.g., how zoom_to_layer interacts with width/height) beyond that, so the baseline of 3 applies.

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

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

States a precise verb+resource: 'Render the map view to PNG and return the image,' which is unambiguous about the output artifact. It also frames intent ('the way to visually check a map'), implicitly separating it from coordinate-returning siblings like get_map_view. However, it never names a sibling explicitly, so an agent must infer the boundary from intent alone.

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

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

Provides clear context for use ('the way to visually check a map') plus a hard prerequisite ('Requires the map's tab to be open in ArcGIS Pro'). There is no explicit when-not guidance or named alternative such as export_layout or export_map_series, so routing among export siblings is left to inference.

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

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

No annotations are provided, so the description carries the full burden, but for a zero-parameter read of local application metadata the risk surface is small. It does disclose the categories of data returned (version, licence, extensions, project path), which implicitly signals a non-mutating information fetch, but it never explicitly states that it is read-only or side-effect free.

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 compact sentence that front-loads the most salient fact (ArcGIS Pro version). It is efficient with no filler, though the terseness comes at the cost of the verb and any usage framing.

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

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

With zero parameters and an output schema present, the description does not need to enumerate return fields or formats. It states the scope of what is inspected (Pro installation plus current project path), which is sufficient for an agent to call it correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a parameterless tool is 4. No parameter-level details are missing or needed.

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

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

The description names the specific resources returned (version, licence level, extensions, project path), which is more than a tautology. However, it is a noun phrase with no verb and it does not distinguish this tool from nearby siblings such as get_project_info, get_capabilities, get_environment, or diagnose, all of which plausibly overlap with 'current environment info'. An agent must guess which of these to call.

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

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

There is no statement of when to use this tool, no exclusions, and no named alternative. Given that get_project_info and get_capabilities appear in the same sibling list, the absence of routing guidance is a real gap rather than a trivial omission.

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. 'List' implies a non-mutating scan and the phrase 'across all maps' usefully discloses that the search is global, but it says nothing about cost, whether sources are checked on disk versus network, or how results are ordered.

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 with the scope ('across all maps') and the filter ('whose data source is missing') stated immediately. No filler.

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

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

An output schema exists, so return values need not be described. For a zero-parameter read tool this covers what an agent needs, though a pointer to repair_layer_source as the natural follow-up would make it fully self-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?

The tool takes zero parameters, so there is no parameter semantics to explain; the baseline of 4 applies. Nothing in the description misrepresents the (empty) argument set.

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 ('List') and resource ('layers') with a precise filter: 'whose data source is missing', scoped 'across all maps'. This clearly separates it from the sibling get_layers, which lists all layers without a health filter.

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