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 that it creates a copy (non-destructive to the original) and that only named layers' visibility changes, which is useful. However, it omits details about overwrite behavior, the lifetime of the scratch copy, required permissions, or any side effects, so significant behavioral information 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 sentence with no filler, front-loading the core action. Every word contributes meaning, and it is appropriately concise for a tool with such a specific function.

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

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

With 6 parameters (4 required) and zero parameter explanation, the description is far from complete for an agent to call correctly. Even though an output schema exists, the description fails to cover essential behavioral and parameter semantics, making it insufficient for reliable invocation.

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

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

Schema description coverage is 0%, and the description only hints at 'named layers' (layer_names) and 'visible.' It does not explain mxd_path, output_mxd, confirm, or overwrite, and it provides no details on how these parameters interact. This leaves the agent without essential parameter guidance for a 6-parameter tool.

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

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

The description clearly states a specific action: creating an MXD copy and altering visibility only for named layers. It distinguishes itself from sibling tools like export/convert functions and list/describe tools by its unique copy-and-visibility behavior, so an agent can identify its purpose unambiguously.

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 only usage hint is 'Requires confirm=true,' which is a prerequisite rather than guidance on when to choose this tool over alternatives. It does not mention scenarios, exclusions, or contrast with any of the many sibling tools, leaving the selection context undefined.

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 only says 'Describe' without explaining what that entails (e.g., read-only, returns metadata, or any side effects). The agent is left without information about the operation's behavior.

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

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

The description is extremely short (one sentence), which is concise, but it lacks structure and substance. While brevity is a virtue, here it sacrifices necessary detail, making it minimally acceptable at best.

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

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

Despite having an output schema, the description does not explain what 'describe' returns or how the dataset input should be provided. The tool is not contextually complete for an agent to use it correctly without additional assumptions.

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

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

Schema description coverage is 0%, and the description adds no meaning to the 'dataset' parameter beyond its name. It does not explain the expected format, path, or type of the dataset, leaving the sole parameter poorly specified.

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

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

The description clearly states the verb 'Describe' and the resource types (feature class, table, raster, workspace). This distinguishes it from sibling tools like describe_mxd, which targets map documents. 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?

The description provides no guidance on when to use this tool versus alternatives such as list_fields or describe_mxd. There is no mention of context, prerequisites, or exclusions, leaving the agent to infer usage.

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

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

With no annotations, the description carries the burden of disclosing behavior. It states that the tool returns document properties and per-data-frame coordinate system/extent, which implies a read-only inspection. It does not enumerate failure modes or file-access requirements, but for a read-oriented describe tool the disclosure is reasonably 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 entire description is a single sentence with no filler. It front-loads the main action ('Return MXD document properties') and then adds the key details about data frame coordinate systems and extents. 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 has one obvious parameter, an output schema to cover return details, and a clear read-only purpose. The description omits guidance about invalid paths or prerequisites, but for a simple describe operation it is largely complete. A slightly richer statement about file access or non-mutation would make it a 5.

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

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

Schema description coverage is 0%, so the description must compensate. It adds context that mxd_path refers to an MXD document whose properties will be read. The parameter name and title are already self-explanatory, and with only one parameter this is sufficient for correct invocation.

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

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

The description uses a specific verb ('Return') and names a precise resource: 'MXD document properties plus each data frame's coordinate system and extent.' This clearly distinguishes it from siblings like list_mxd_layers (layers only) and describe_dataset (datasets).

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 function's purpose is clear enough that an agent can infer when to use it: when MXD-level document properties, data frame coordinate systems, or extents are needed. However, it does not explicitly mention alternatives or state when not to use this tool, so it stops short of a 5.

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

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

With no annotations, the description carries the full burden. It usefully discloses that the operation works on a copy (implying non-destructive behavior) and that the output is placed in the configured scratch directory. However, it does not clarify overwrite behavior, side effects, or what happens if the output already exists.

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

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

Two short sentences, no filler. The primary purpose is front-loaded, and the confirm requirement is the second most important fact for successful invocation. Every word contributes.

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

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

For a tool with five parameters, no annotations, and no output schema, the description should explain more. It captures the core action and confirm gate but omits meaningful behaviors such as overwriting existing PDFs, how resolution is interpreted, and any expected return value or status. The agent can call it correctly only if it guesses the parameter semantics from names.

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

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

The schema provides no param descriptions, only names and defaults, so the description needs to compensate. It addresses the crucial confirm parameter ('Requires confirm=true') and the scratch-directory context, but it leaves mxd_path, output_pdf, overwrite, and resolution semantics mostly to be inferred from their names and types.

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 ('Export'), a specific resource ('an MXD copy'), and a concrete output ('a PDF in the configured scratch directory'). This clearly distinguishes it from sibling conversion tools like export_shp_to_pdf by emphasizing MXD and the scratch directory.

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 only usage-related guidance is 'Requires confirm=true', which is a precondition rather than a when-to-use instruction. It does not mention alternatives or explicitly state when this tool should be chosen over a sibling export tool.

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

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

With no annotations provided, the description must carry the full burden of behavioral disclosure. It does mention the confirm requirement and the use of a scratch directory, which is useful, but it does not disclose whether the operation is destructive to the original MXD (though it says 'copy'), what happens with the 'overwrite' parameter, or any error/return behavior. The description is minimal and leaves significant behavioral aspects unspecified.

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

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

The description is extremely concise with no filler words, which is positive, but it is under-specified to the point of being insufficient. The core action is front-loaded, but the lack of additional context makes it feel incomplete rather than efficiently concise. It earns a mid-score because it is not verbose, but it also does not fulfill the purpose of a helpful description.

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

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

Given the tool's complexity (5 parameters, no schema descriptions, no annotations) and the presence of an output schema (which we cannot see), the description is grossly incomplete. It does not explain any parameters, potential side effects, return values, or usage context. An agent would struggle to call this tool correctly without external knowledge.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameter meanings. However, the description does not mention any parameters other than confirm (and only as a requirement). It gives no insight into what mxd_path, output_png, overwrite, or resolution mean, leaving an agent to guess from names alone. This is a severe gap given the lack of schema descriptions.

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

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

The description clearly states the action ('Export'), the resource ('an MXD copy'), and the output format ('to a PNG') as well as the destination ('in the configured scratch directory'). This distinguishes it from sibling tools like export_mxd_to_pdf (different format) and export_mxd_with_overlay_png (with overlay), so an agent can easily tell it apart.

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

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

The description provides no guidance on when to choose this tool over its siblings, such as export_mxd_with_overlay_png or export_mxd_to_pdf. It mentions a prerequisite ('Requires confirm=true') but does not explain the conditions under which this tool is appropriate or alternatives to consider. An agent would need to infer usage context from the schema or sibling names.

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 disclose that the MXD is never saved, which is a key behavioral guarantee, and that confirm=true is required. However, it does not mention potential side effects (e.g., temporary files), what happens if confirm is false, or any other operational details. This is moderate disclosure but leaves gaps.

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

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

The description is a single, concise sentence that front-loads the core purpose and then adds the critical constraint about confirm=true. There is zero waste, and the key information is presented immediately.

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

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

Given the tool has 7 parameters, no annotations, no schema descriptions, and an output schema that is not detailed in the context, the description is far too minimal. It does not explain parameter usage, return value expectations, or edge cases. An agent would struggle to use this tool correctly with only the provided description and bare parameter names.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters. It only mentions 'semi-transparent overlay' and 'confirm=true' but does not describe mxd_path, overlay_dataset, output_png, resolution, transparency, or overwrite. The meaning of these parameters is entirely left to the schema names, which are insufficient for an agent to call correctly. The description fails to add any meaningful parameter semantics.

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

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

The description clearly states a specific verb-resource pair: export an MXD preview with a temporary semi-transparent overlay. It also distinguishes itself from sibling tools like export_mxd_to_png and export_mxd_to_pdf by emphasizing the overlay and the fact that the MXD is never saved. This makes the tool's purpose unambiguous.

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

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

The description gives a prerequisite ('Requires confirm=true') but does not explicitly state when to use this tool versus alternatives. It implies a use case (preview with overlay) but lacks explicit guidance such as 'use this when you need an overlay' or 'use export_mxd_to_png for plain exports.' The confirm requirement is helpful but not a full usage guideline.

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

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

With no annotations provided, the description carries the full burden. It mentions the optional where clause, which is a behavioral detail, but does not disclose other aspects such as read-only nature, performance implications, or potential errors. The simplicity of the tool makes this adequate, but it could be more explicit.

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

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

The description is a single sentence, highly concise, and front-loaded with the core action. No wasted words; every word contributes to the meaning.

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 counting tool with an output schema present, the description is fairly complete. It specifies the operation and the optional filter. The output schema likely defines the return format, so that is covered. Missing are any usage conditions or edge cases, but the tool's simplicity mitigates this.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the where_clause as an 'ArcGIS SQL where clause', adding semantic value. However, the dataset parameter is only implied by the phrase 'count features' and lacks explicit explanation of its meaning or format. Partial compensation for the missing schema descriptions.

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

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

The description clearly states the verb 'Count' and the resource 'features', making the tool's purpose unmistakable. It also distinguishes itself from siblings like query_features (which returns features) and describe_dataset (which describes structure) by focusing on the count operation.

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

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

The description gives no explicit guidance on when to use this tool versus alternatives. It does not mention conditions, prerequisites, or contrast with sibling tools like query_features or describe_dataset. The use case is implied 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 are provided, so the description carries the burden of disclosing behavior. The word 'Return' suggests a read-only capability lookup, and 'enforced safety boundaries' adds useful context about what the tool reports. However, it does not explicitly disclose authneeds, side effects, or failure behavior.

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

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

The descrition is one clear sentence with no filler. It front-loads the action ('Return') and states both key pieces of content: the tool catalog and the safety boundaries.

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

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

For a zero-parameter tool with an output schema, the description is nearly complete: it names exactly what the agent will receive. It could add a sentence about when to call it relative to sibling tools, but the low complexity and presence of an output schema make the current definition 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 has zero parameters, so the input schema imposes no burden and the description does not need to explain parameter semantics. This matches the baseline of 4 for parameterless tools.

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

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

The description uses a specific verb and resource: it returns the ArcMap 10.8 tool catalog and the enforced safety boundaries. This clearly distinguishes it from sibling tools like health_check and search_arcpy_tools by naming its unique content.

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

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

The description implies the tool should be used when an agent needs to discover available ArcMap 10.8 tools and understand safety boundaries, but it does not explicitly state when to prefer it over alternatives or when not to use it. The usage context is reasonably 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states that it returns installation and licensing details but does not mention whether it is read-only, requires specific permissions, or has any side effects. For a health check, read-only behavior is likely but not stated, leaving the agent without safety context.

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

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

The description is a single, concise sentence that immediately states the action and scope. There is no unnecessary wording or redundancy, and it front-loads the key 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?

Given the tool has no parameters and an output schema is present, the description sufficiently covers what the tool does. It might benefit from a note about typical use cases, but the simplicity of the tool makes this a minor gap. Overall, the definition is complete enough for an agent to invoke 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 has zero parameters and schema coverage is trivially 100%, so there is nothing to explain. The description does not need to elaborate on parameters. Per the rubric, the baseline for 0 parameters is 4, and no additional context is required.

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

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

The description clearly states the tool returns ArcMap Desktop/ArcPy installation and licensing details. This is a specific verb-resource pair that distinguishes it from sibling tools like get_server_capabilities or describe_mxd, which target different aspects of the system. No ambiguity.

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

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

The description offers no guidance on when to use this tool versus alternatives, nor does it mention any exclusions or prerequisites. It simply states the function. Given the unique purpose, usage might be inferred, but the description does not explicitly route the agent to this tool under specific conditions.

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

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

No annotations are provided, so the description must carry the behavioral burden. It only implies a read operation by saying 'Return', but discloses nothing about behavior for invalid or nonexistent datasets, supported dataset sources, or whether it errors or returns an empty list.

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

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

A single, front-loaded sentence contains only necessary information: action, output, and target resource. No filler or redundancy exists.

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 operation is simple and the output schema covers return structure, so the description is nearly sufficient for invocation. However, missing usage guidance and behavioral context such as error handling or supported dataset types prevent it from being fully complete for an agent evaluating it in isolation.

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

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

Schema coverage is 0% and the schema only names 'dataset'. The description adds that the dataset is a feature class or table, which provides some meaning, but it does not specify accepted path formats, dataset identifiers, or workspace context, leaving part of the parameter semantics to inference.

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

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

Uses specific verb 'Return' and explicit resource 'field metadata for a feature class or table', clearly distinguishing it from sibling tools like list_mxd_layers or describe_dataset. The object type and output are both named, so an agent can identify the operation at a glance.

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

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

No guidance is given about when to choose this tool instead of alternatives such as describe_dataset or search_arcpy_tools. The description only states what it does, leaving the agent to infer intended usage without explicit context or exclusions.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It does reveal one important behavior: access is restricted to 'allowed roots'. However, it does not define those roots, explain what happens for invalid paths, or explicitly confirm whether the operation is read-only beyond the verb 'List'.

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

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

The description is a single sentence that front-loads the verb and object. There is no repetition or filler; every phrase contributes either the action, the resource, or a restricting condition.

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 simple one-parameter shape and the presence of an output schema, the description is minimally adequate: it states the operation and the key constraint. It leaves gaps around the meaning of 'allowed roots' and when to prefer sibling tools, but these are not fatal for such a small, read-oriented tool.

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

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

Schema description coverage is 0%, and the schema only labels mxd_path as a string. The description adds that the path should point to an MXD file within allowed roots, which is meaningful, but it does not specify path format, how allowed roots are determined, or expected path scope. It only partially compensates for the missing schema documentation.

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

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

The description clearly states a specific action ('List') and resource ('data frames and layers in an MXD file'), and it adds a useful scoping constraint ('within allowed roots'). It is distinct from generic purposes, though it does not explicitly contrast with the sibling describe_mxd or list_fields tools.

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

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

There is no guidance about when to use this tool versus alternatives such as describe_mxd or query_features. The description only announces the operation and provides no scenario, prerequisite, or exclusion cues to help an agent select it correctly.

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

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

With no annotations provided, the description carries the full burden. It does disclose that the operation is a read and that the result is capped at 1,000 records, but it does not mention what happens when more records match, whether pagination is supported, required permissions, or return format. These omissions leave notable behavioral ambiguity for a no-annotation 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 sentence that is front-loaded with the core action and maximum limit, followed by the optional filter and field list. Every word earns its place, with no redundancy or unnecessary detail.

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

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

For a tool with four parameters, no annotations, no output schema, and no sibling differentiation, the description is only partially complete. It covers the essential read behavior and key parameters, but it lacks information about defaults, error handling, response contents, and behavior when the 1,000-record cap is exceeded.

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

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

The schema provides only titles for parameters, so the description adds meaningful semantics: 'ArcGIS SQL filter' explains the nature of 'where_clause', 'field list' clarifies 'fields', and 'up to 1,000 records' gives practical meaning to 'limit'. The dataset parameter is implicit, but the description covers most of the semantically important details.

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 action ('Read'), a resource ('records from a dataset'), and key constraints ('up to 1,000 records', 'ArcGIS SQL filter and field list'). It is distinct from sibling names like 'export_features_to_pdf' and 'run_advanced_geoprocessing', though it does not explicitly differentiate itself from similar search/query siblings.

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

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

The description gives no guidance on when to use this tool versus alternatives like 'search_features' or 'export_features_to_pdf'. It does not state exclusions, prerequisites, or scenarios where another tool would be preferred. The intended usage is only implied by the verb 'Read'.

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 bears the full burden of behavioral disclosure. It does communicate two rules: absolute paths must be declared and outputs must be in scratch. However, it omits critical details such as potential side effects (e.g., data modification), permission requirements, confirmation/overwrite semantics (even though confirm and overwrite parameters exist), and whether the operation is read-only or destructive. For a tool that runs arbitrary GP tools, this is a significant gap.

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

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

The description is concise: two short sentences with no redundancy. It front-loads the core purpose and then adds the key constraint. While it is sparse, it is efficiently structured and avoids filler.

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

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

Given the complexity of the tool – 7 parameters, nested objects, an output schema, and a sibling 'run_geoprocessing' – the description is notably incomplete. It does not explain how to use the 'tool' parameter, how to construct args/kwargs, what 'confirm' and 'overwrite' control, or how the output schema relates to the returned result. The presence of an output schema reduces the need to explain return values, but the description still fails to cover essential invocation details.

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

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

Schema coverage is 0% – no parameter descriptions are provided in the schema. The description partially addresses input_paths and output_paths by stating that paths must be declared and outputs must be in scratch, but it does not explain the tool, args, kwargs, confirm, or overwrite parameters. This is insufficient compensation for the lack of schema documentation.

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

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

The description states a clear purpose: 'Run an opt-in ArcPy GP tool.' It identifies the resource (ArcPy geoprocessing tool) and the action (run). However, it does not explicitly distinguish from the sibling 'run_geoprocessing', relying on the 'advanced' naming to imply difference. The constraint 'Every absolute path must be declared; outputs must be in scratch' adds specificity about scope but does not define what makes it advanced.

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 offers no guidance on when to use this tool versus the simpler sibling 'run_geoprocessing'. It mentions 'opt-in' but does not clarify what that entails or when it is appropriate. No alternative tools are named, and no conditions are given to help an agent decide between the two geoprocessing tools.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions two constraints (confirm and scratch) but does not describe the tool's side effects, what happens if confirm is false, or any potential impact on data. The mutation nature is implied but not elaborated.

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

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

The description is a single concise sentence that states the purpose and key constraints. However, it could be better structured by front-loading the purpose and separating prerequisites more clearly, but overall it is efficient.

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

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

The tool runs arbitrary geoprocessing, which is complex, yet the description provides no information on how to select a valid tool, how to structure the parameters object, or what the output schema returns. With no annotations and no parameter explanation, it is incomplete for an agent to call correctly.

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

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

Schema description coverage is 0%, so the description must compensate by explaining parameters, but it does not. It does not clarify what 'tool', 'input_features', 'output_feature_class', 'parameters', 'overwrite', or 'confirm' mean beyond their schema names. The agent is left to guess the semantics.

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

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

The description clearly states the verb 'run' and the resource 'whitelisted geoprocessing tool,' which gives a specific purpose. However, it does not differentiate from the sibling 'run_advanced_geoprocessing' – the term 'whitelisted' is ambiguous and does not explain 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?

The description provides two prerequisites (confirm=true and output under scratch) but gives no guidance on when to choose this tool over its sibling 'run_advanced_geoprocessing' or other alternatives. It fails to state the intended use case or exclusion criteria.

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

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

With no annotations, the description carries full behavioral burden. It adds useful details: tools are 'callable', limited to this ArcMap 10.8 runtime, and result count is capped at 500. It does not disclose query matching behavior or potential return/error behavior, though the output schema partly covers return structure.

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 filler. Every phrase adds signal: search, callable tools, runtime scope, and result cap.

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

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

This is a simple discovery tool and the output schema likely covers return values, but with no annotations and minimal parameter guidance, the definition leaves important usage semantics unstated. It is adequate but not complete for an agent deciding how to query and use results.

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?

Input schema has 0% description coverage and the description does not explain the 'query' parameter at all; 'limit' is only indirectly addressed by 'up to 500'. The agent cannot tell whether query matches tool names, aliases, metadata, or supports wildcards.

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

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

The description names a specific action ('Search'), a precise resource ('callable ArcPy GP tools installed with this ArcMap 10.8 runtime'), and a bound ('up to 500'). This makes it clear the tool is for discovery rather than execution, distinguishing it from siblings like run_geoprocessing.

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 intended context is implied: use it to find ArcPy GP tools available in this runtime. However, it never explicitly says when to choose this over run_geoprocessing or run_advanced_geoprocessing, nor gives any when-not-to-use guidance.

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