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

With no annotations, the description must carry the full burden. It discloses that the step is appended to the end unless after_step names an earlier step, and that the next step is rewired, which is useful behavioral context. However, it does not mention the effect on the query, whether the operation is reversible, or what dry_run does, leaving gaps in transparency.

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

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

The description is concise (two sentences) and front-loaded with the purpose. The examples are structured and aid comprehension. It avoids fluff and gets to the point efficiently, though the second sentence could be split for readability.

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 7 parameters, no output schema, and no annotations, the description is incomplete. It covers the core logic (action, params, after_step) but omits source, query, dry_run, and step_name entirely. It also does not describe the return value or any error behavior. Given the complexity, this is a significant gap in contextual completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It richly explains action and params with examples, and clarifies after_step. However, it does not explain source, query, dry_run, or step_name, which are part of the 7 parameters. While the key complex parameters are covered, the incomplete coverage of the full parameter set prevents a higher score.

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

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

The description clearly states the tool adds a standard Power Query step without hand-writing M, and gives concrete examples. It distinguishes itself from hand-writing M but does not explicitly differentiate from sibling step-modification tools like rename_step or remove_step. The purpose is specific and 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?

It references list_transforms as the source for action and params, implying the user should consult that tool first. It also explains the after_step behavior, which is a key usage nuance. However, it does not explicitly state when to use this tool versus alternatives or when not to use it, leaving some inference required.

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 for behavioral disclosure. It does add meaningful context by mentioning that dependent queries are copied along, which is a non-obvious behavior. However, it does not disclose whether existing queries are overwritten, whether dry_run is supported, whether the source is modified, or what happens on conflicts.

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

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

The description is one sentence with no filler, front-loads the action, and adds the key dependency behavior efficiently. It is appropriately concise for a top-line description, though the brevity contributes to the lack of parameter and edge-case guidance.

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 context is incomplete for a tool with 6 parameters, 3 required, no annotations, and no output schema. The description does not explain what dry_run does, what overwrite implies, how dependency traversal behaves, or what the tool returns. An agent would need additional information beyond this description to invoke it confidently in non-trivial cases.

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

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

Schema description coverage is 0%, so the description must compensate. It gives some meaning to from_source and to_source via 'between workbooks / projects / folders' and to include_dependencies via 'bringing the queries they depend on along.' But the required 'names' parameter and the important 'dry_run' and 'overwrite' parameters receive no semantic explanation.

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

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

The description names a specific verb and resource: 'Copy queries between workbooks / projects / folders,' which clearly states the core operation. It also adds a distinguishing behavior, 'bringing the queries they depend on along,' which helps differentiate it from copy-like or query-import tools. It does not explicitly name sibling alternatives, so it falls just 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?

The phrasing implies when to use the tool: when copying queries between workbooks, projects, or folders, especially when dependencies matter. However, there is no explicit guidance about when not to use it or which sibling tool to choose instead, such as export_queries or import_queries, so the agent must infer the appropriate 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?

DestructiveHint already signals mutation, and the description adds useful context about dependency refusal and force behavior. However, it does not disclose what happens when force=true (e.g., whether dependent queries are broken or cascade-deleted) or how dry_run interacts with deletion.

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 leads with the action and immediately states the key caveat. Every word adds information, and there is no padding or repetition of schema fields.

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

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

With no output schema and four parameters including a destructive force flag and dry_run option, the description is too sparse to fully prepare an agent. It omits what dry_run does, what force actually permits, and what return value or side effects to expect.

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

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

Schema description coverage is 0%, so the description must compensate for documenting parameters. It only explains force in passing, leaving source, name, and dry_run semantics entirely to the schema, which merely lists their 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 starts with 'Delete a query,' which is a specific verb and resource, clearly identifying the tool's core action. It also adds a meaningful behavioral qualifier about refusing when other queries reference it, making it distinct from sibling query-management 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?

The description gives no indication of when to choose this tool over alternatives such as set_query, rename_query, or remove_step. It mentions the refusal condition and force=true, but does not explain broader usage 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?

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds useful behavioral detail beyond that: it reports roots, leaves, orphans, and cyclic references, and supports twp output formats. This gives the agent concrete insight into what the tool computes without contradicting the annotation.

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

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

The description is two tight sentences with no filler. It front-loads the core purpose ('Query-to-query lineage') and packs the scoping rule, format options, and output highlights into minimal words. Every sentence earns its place.

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

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

For a tool with no output schema and no parameter descriptions, the description is incomplete: it never explains the required `source` parameter, the shape of the returned graph, or error/edge behavior. It mentions useful output categories but leaves essential calling details to inference.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `query` and `format`, but completely omits `source`, which is a required parameter. For a required argument, leaving its meaning undefined forces the agent to guess, which is a significant gap in a 0%-coverage schema.

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

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

The opening phrase 'Query-to-query lineage' states the exact resource and operation the tool performs. The sentence 'With query, only its upstream and downstream' clarifies the scoping behavior and distinguishes this from siblings like get_query or list_queries, which return individual or all queries rather than a dependency graph.

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

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

The description gives no guidance on when to choose dependency_graph over related tools such as find_in_queries, diff_queries, or get_query. The conditional 'With query...' describes parameter behavior, not tool-selection criteria, so an agent gets no help deciding when this tool is the right one.

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

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

Annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds the behavioral detail that line endings are ignored, which is useful and beyond annotations. It also mentions the snapshot path requirement, but doesn't describe edge cases like mismatched types or error handling, which are less critical given the read-only guarantee.

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

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

Two sentences, no filler. The core purpose is front-loaded, examples are concise, and the snapshot note is a single clause. 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?

There is no output schema, so the agent doesn't know what the tool returns (e.g., a diff string, a boolean, or a structured report). The parameters are also underspecified, and the tool's complexity (comparing different source types) warrants more detail. An agent might call it with the wrong format and get an unexpected error or ambiguous result.

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

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

The schema has two string parameters, source_a and source_b, but no descriptions. The tool description does not clarify what these strings should represent (paths, IDs, or something else) except indirectly for snapshots ('pass its path'). Given 0% schema coverage, the description fails to compensate, leaving the agent guessing about valid input formats.

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, specific action: compare queries between two sources. It gives concrete examples of source types (workbook, exported folder, PBIP) and even notes line endings are ignored, which uniquely distinguishes this tool from any sibling. There is no other diff tool, so it's 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?

It provides explicit guidance for a special case (comparing against a snapshot by passing its path from list_snapshots) and implies general use for any two sources. While it doesn't explicitly say when not to use it, the absence of a competing diff tool makes exclusions unnecessary. It also hints at the need for valid source identifiers.

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?

Beyond the readOnlyHint annotation, the description discloses concrete behaviors: the exact return format for tables, lists, records, scalars and functions; how M errors are surfaced; that count_rows/profile scan the entire result; that ignore_privacy_levels disables the privacy firewall; and that source includes unsaved edits. This is rich, useful behavioral context.

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

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

The description is dense but organized: it opens with the core purpose and return behavior, then adds source capabilities, performance caveats, and privacy handling. Every sentence adds distinct value, and there is no filler or repetition of schema fields.

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

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

For a tool with no output schema, the description thoroughly explains what the agent can expect in return, including error behavior and function signatures. The only notable gap is the lack of explicit timeout_seconds semantics, and it could more explicitly position this tool against evaluate_query/evaluate_steps, but overall an agent has enough 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?

With 0% schema description coverage, the description carries most of the burden locked. It explains the semantics of rows, source, count_rows, profile, and ignore_privacy_levels, and even gives an expression example. It does not explain timeout_seconds or the full syntax of expression, but it compensates well for most parameters given the schema's bare names and defaults.

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: 'Run any M expression and get the result as data.' It also clarifies the breadth of accepted inputs (tables, lists, records, scalars, functions) and the output shape, which makes the tool's purpose unmistakable and distinct from sibling tools that operate on queries or steps.

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 practical guidance on when to use the tool: for ad hoc M expressions, optionally with a source to reference existing queries, and warns that count_rows and profile can be slow. It does not explicitly contrast with siblings like evaluate_query or evaluate_steps, but the 'any M expression' framing implies the general-purpose evaluation niche.

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?

Beyond the readOnlyHint annotation, it discloses that evaluation is fresh (not cached), that only part of the query may be evaluated when `step` is provided, and that output includes columns, types, and sample rows. It also hints at error-discovery behavior when evaluating step by step.

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

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

Two sentences with no filler: behavior first, then targeted use cases. Every clause adds information, and the key parameter is named inline.

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 8 parameters, no parameter descriptions in schema, and no output schema, so the description carries a heavy burden. It covers the core behavior but omits many parameters that an agent may need, especially `ignore_privacy_levels`, `profile`, and `count_rows`.

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

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

With 0% schema description coverage, the description needed to explain parameters. It clarifies `step` and implies `rows` via 'sample rows', but leaves `source`, `profile`, `count_rows`, `timeout_seconds`, and `ignore_privacy_levels` unexplained. The prose does not compensate for the schema's lack of parameter 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 identifies the action (evaluate a query), the optional limit (`up to step`), and the result (columns, types, sample rows). It does not explicitly distinguish itself from similar siblings like evaluate_steps or preview_query, but the intended behavior 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?

It gives concrete use cases: fetching real column names before apply_transform, inspecting step effects, and locating the first error by evaluating step by step. It does not state exclusions or alternative tools, but the guidance is specific enough to select this 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 readOnlyHint=true in annotations, the description goes beyond that by detailing the output behavior: it describes each step's columns, types, first rows, or the error. This adds meaningful context about what the tool returns, which is not captured in the annotation alone. No contradiction with the readOnlyHint.

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 tightly written in two sentences, with the core function and output immediately clear. The benefit statement is concise and adds value without redundancy. 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?

For a tool with 5 parameters and no output schema, the description provides a good overview of the tool's purpose and output format, but leaves key parameter details (especially ignore_privacy_levels and timeout_seconds) unaddressed. The output structure is described in general terms but not precisely enough for an agent to know exactly what to expect without further context. It's adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only mentions `rows` (as 'first `rows` rows'), clarifying its role in limiting the displayed rows. However, it says nothing about source, query, timeout_seconds, or ignore_privacy_levels, leaving those ambiguous. This partial explanation does not adequately compensate for the lack of schema descriptions.

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

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

The description clearly states the tool evaluates every step of a query in one call, listing exactly what it describes (columns, types, first rows, or error). It also distinguishes itself from evaluate_query by highlighting that it's a single call instead of one per step, making its purpose unmistakable.

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

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

The description explicitly tells when to use this tool: to see how a query transforms data and find the first error step, framing it as faster than calling evaluate_query repeatedly. It clearly points to the alternative (evaluate_query) and the advantage, even if it doesn't list explicit conditions for when not to use it—the guidance is sufficient.

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 mention that existing .pq files are replaced, which is a destructive action, and describes the output files. However, it does not disclose any other side effects, such as whether the folder is created if missing, what happens to the manifest if it already exists, or any permission requirements.

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

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

The description is a single sentence that is efficient and front-loaded with the core action. It conveys the essential information without unnecessary verbosity, though a slightly more structured format could improve clarity.

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

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

Given the lack of annotations, no output schema, and zero schema descriptions for parameters, the description is insufficiently complete. It fails to explain the 'source' parameter, the format of the .pq files, the manifest contents, error handling, or edge cases like existing manifests or missing folders. An agent would likely struggle to call this tool correctly without additional 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?

The input schema has 0% description coverage, so the description must compensate. It explains the 'folder' parameter by referencing it in the context of writing files, but it leaves 'source' completely unexplained. It is unclear what 'source' refers to, and the description does not clarify the relationship between source and the queries being exported.

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: writing every query to a folder as .pq files plus a manifest, with the explicit purpose of being ready for git commit and PR diff. It implies a specific export format that distinguishes it from import_queries and diff_queries, though it doesn't name alternatives. It is specific about the resource (queries) and the output format.

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

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

The description gives context for when to use this tool (preparing queries for version control and PR review), but it does not explicitly state when not to use it or contrast it with sibling tools like copy_queries or import_queries. The use case is implied rather than stated as a directive.

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

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

With no annotations, the description carries the full burden. It discloses a key behavioral detail: match_prefix rewrites prefix-matched occurrences (example with C:\Data). However, it does not mention whether the operation is destructive, reversible, or how it affects multiple queries (the queries parameter). It also doesn't mention the dry_run behavior, though that is partially self-evident. The example adds value but leaves many behaviors 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?

The description is extremely concise: two sentences. The first sentence states the primary purpose immediately, and the second provides a clarifying example. Every word earns its place, with no fluff or repetition. The structure is front-loaded and efficient.

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

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

For a tool with 6 parameters, no schema descriptions, no output schema, and no annotations, the description is incomplete. It covers the core behavior and one parameter's behavior (match_prefix) but leaves source, parameter_name, queries, and dry_run entirely unexplained. An agent would need to infer or guess the semantics of these parameters, which is a significant gap for successful invocation.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It explains the concept of 'value' (hard-coded text) and gives a concrete example for 'match_prefix', but it does not clarify 'source', 'parameter_name', 'queries', or 'dry_run'. The description adds some meaning for match_prefix but leaves most parameters unexplained, which is insufficient 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 tool's function: converting a hard-coded text value into a Power Query parameter and referencing it everywhere. It specifies the resource (text values like path, server, URL) and the action (parameterize). It is distinct from sibling tools, though it doesn't explicitly name an alternative; the purpose is self-evident enough to avoid confusion.

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

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

The description implies usage: when you have hard-coded text values and want to parameterize them. It does not explicitly contrast with alternatives like replace_in_queries or apply_transform, nor does it state when not to use it. The context is implicit rather than explicit.

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

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

The readOnlyHint annotation already indicates no side effects, and the description adds useful return details (query, step, line). It does not mention behavior like case sensitivity or regex handling, but given annotation coverage, this is adequate.

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

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

The description is concise, two sentences with no filler, and front-loads the core purpose. It could include more detail but remains efficiently structured.

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

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

Without an output schema, the description should fully explain return and parameter semantics. It covers return values partially and only one of four parameters, making it incomplete for a tool with 0% schema coverage and no output schema.

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

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

With schema description coverage at 0%, the description must explain parameters, but it only clarifies 'scope' and its allowed values. It fails to define 'source', 'pattern', and 'regex', leaving the agent without enough information to construct correct inputs.

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 search operation ('Search the M of every query') and specifies the scope options, which helps distinguish it from sibling tools like replace_in_queries. However, 'M' is undefined and may confuse an agent unfamiliar with the domain, slightly detracting from clarity.

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 search use case but provides no explicit guidance on when to use this tool versus alternatives like replace_in_queries or get_query. It lists scope options but does not explain when each scope is appropriate or exclude any scenarios.

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?

Beyond the readOnlyHint annotation, the description adds a strong safety guarantee: the output is verified token-for-token against the input, so meaning can never change. It also discloses formatting details and comment preservation, giving the agent confidence about side effects and output fidelity.

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

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

Two sentences communicate purpose, scope, formatting behavior, and a correctness guarantee with no filler. The key capability is front-loaded and every clause adds 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 low complexity, single parameter, and read-only annotation, the description fully covers what the tool does, what input it expects, and what the output guarantees. No critical information needed for correct invocation appears to be 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?

With 0% schema description coverage, the description compensates by indicating that the single 'formula' parameter accepts either an M expression or a section document. It does not specify parameter syntax or error cases, but for a single simple string parameter this is sufficient semantic guidance.

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, 'Pretty-print M', and precisely defines the input scope as 'an expression or a section document'. It also details observable formatting behaviors (one step per line, long calls broken at arguments, comments kept), which clearly distinguishes this tool from the query-level format_queries sibling.

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

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

The description makes the use case clear: call this tool when you need to pretty-print an M expression or section document. It does not explicitly name alternatives or exclusion criteria, but the scope is specific enough that an agent can infer when it applies without ambiguity.

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 behavioral burden. It does disclose that the operation happens 'in place' (modifying the original) and references format_m's guarantees, but those guarantees are not enumerated. It also omits the dry_run parameter's behavior (whether it prevents changes). This is a moderate disclosure, but the lack of specifics 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 sentence, which is concise and front-loaded with the primary action. However, it is so terse that it omits essential details about parameters and behavioral nuances. While brevity is a virtue, the under-specification makes it less effective than a slightly longer, more informative description would be.

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 three parameters, no output schema, and no annotations, the description is notably incomplete. It does not describe the effect of formatting (e.g., whitespace changes), the role of source, the purpose of dry_run, or any error conditions. The vague reference to 'same guarantees as format_m' assumes prior knowledge and does not stand alone. An agent cannot fully understand how to invoke this tool correctly from the description alone.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It only hints at the query parameter via 'one query, or every query,' implying that query can be null to target all, but it does not explain the source parameter (required) or the dry_run flag (default false). The meaning of these parameters is left entirely to the schema, which itself has no descriptions. This is a significant shortfall.

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 verb-resource pair: 'Format one query, or every query, in place.' It specifies the operation (format), the target (queries), and the scope (one or all). The reference to format_m also distinguishes it from the sibling tool for M expressions, so an agent can tell them apart without opening the schema.

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

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

The description implies when to use this tool: when you need to format queries. The phrase 'same guarantees as format_m' hints that format_m is for M code, but it does not explicitly state 'use format_m for M expressions.' However, given the sibling list includes format_m and no other formatting tool for queries, the intended use is reasonably clear, though it lacks explicit exclusions or alternative 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?

The readOnlyHint annotation already covers the safety profile, so the description adds value by detailing what is returned: full M code, parsed steps, data sources, dependencies, and dependents. It does not describe error behavior or how missing/ambiguous queries are handled, but for a simple read-only getter this is an acceptable 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 a single efficient sentence that front-loads the most important fact, 'Full M code of one query', before listing additional returned content. There is no filler or redundancy.

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

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

With no output schema and no parameter documentation, the description leaves important invocation details to inference. It tells the caller what is returned but not how source and name are used, what constraints apply, or what the output structure looks like beyond a short list of content types.

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

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

Schema description coverage is 0%, so the description must explain the two required parameters, source and name. It does not explicitly do so; 'one query' implies that name identifies a query and source scopes it, but the description never clarifies what a 'source' is or how it relates to the returned data sources.

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 resource ('one query') and a specific deliverable ('Full M code plus its parsed steps, data sources, dependencies and dependents'). It implicitly distinguishes itself from list-oriented siblings like list_queries and dependency_graph, 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?

There is no guidance on when to use this tool versus alternatives such as list_queries, dependency_graph, or extract_parameter. The description implies a per-query retrieval use case, but it does not state when a caller should prefer this sibling or which excluded scenarios apply.

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

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

No annotations are present, so the description carries full responsibility for behavioral disclosure. It does reveal a potentially destructive side effect: mode='sync' deletes queries not in the folder, which is valuable. However, it does not mention the `dry_run` parameter, whether changes are reversible, or how overwrites of existing queries are handled, leaving important behavioral gaps for a mutation/import operation.

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

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

The description is two focused sentences with no fluff or repetition. The primary behavior is front-loaded, and the mode semantics are stated compactly in the second sentence. Every word contributes to understanding 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?

Given four parameters, no annotations, no output schema, and a destructive mode, the description is too sparse to be fully safe and self-sufficient. It omits the role of `dry_run`, any prerequisites or source requirements, and what happens after execution. An agent could invoke it correctly for the basic update case but would lack guidance for safe or non-destructive usage.

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

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

The input schema provides no property descriptions, so the description must compensate. It adds meaning for `folder` and `source` by tying them to the .pq loading flowaa, and it explains the `mode` values (update vs sync). However, `dry_run` is completely unexplained, and there is no detail on parameter formats or constraints beyond the schema 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 uses a specific verb ('Load') and identifies the resource and direction: .pq files from `folder` into `source`. It also distinguishes itself from siblings like export_queries and copy_queries by making the import direction and file format explicit. This is an unambiguous statement of what the tool does.

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

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

The description provides clear operational context: load .pq files back into a source, with mode='update' for changes/adds and mode='sync' for deletion of stale queries. It does not explicitly name alternatives or state when not to use this tool, but the mode guidance is practical and sufficient for an agent to choose the intended behavior.

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

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

The readOnlyHint annotation already establishes that this is a safe read operation. The description adds meaningful behavioral context by listing the lint categories and stating that each finding carries a concrete suggestion. No contradiction with annotations.

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

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

The description is compact and front-loaded with the main action, followed by a concise list of audited concerns. Every sentence carries useful information, and the severity values are included efficiently.

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

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

For a read-only tool with three parameters and no output schema, the description omits essential context: what 'source' means, how 'query' interacts with it, and what the overall report shape looks like beyond 'each finding carries a suggestion.' An agent could guess, but not confidently.

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

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

Schema description coverage is 0%, so the description must compensate. It only documents min_severity choices (info | warning | error). The required 'source' parameter and optional 'query' parameter are not explained, leaving critical semantics unclear.

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 ('Audit') and resource ('queries'), and enumerates the exact kinds of issues it checks for, such as folding breakers, dead steps, and orphans. This makes the tool's purpose clear and reasonably distinct from siblings like validate_m or format_m.

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 instead of related tools such as validate_m, diff_queries, or dependency_graph. It does not mention exclusions, prerequisites, or alternative 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?

The readOnlyHint annotation already covers safety, and the description adds the output content (source inventory with hard-coded/parameterised status). However, it does not clarify behavior around the required 'source' parameter or output format, leaving some ambiguity.

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

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

The description is a single sentence, concise and front-loaded with the core purpose. It could be slightly improved by adding a parameter hint, but it is efficiently written without 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 tool with one required parameter and no output schema, the description fails to define the parameter or any usage context. An agent cannot confidently call this tool without additional inference, making it incomplete.

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

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

Schema description coverage is 0%, and the description does not explain what 'source' refers to (e.g., a query identifier or a data source name). The parameter remains completely undefined, forcing the agent to guess.

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 ('inventory') and resource ('external sources each query reads'), and adds a distinguishing attribute ('whether it is hard-coded or parameterised'). This clearly separates it from siblings like list_sources or list_queries, which would not include per-query dependency details.

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 such as list_sources or list_queries. It only states what it does, without any context for selection 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?

Annotations already provide readOnlyHint=true, and the description is consistent with read-only behavior. The description adds some context by revealing the output includes dependency/usage relationships, but it doesn't disclose potential size, pagination, or performance characteristics of listing every query.

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

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

The description is a single compact sentence that front-loads the main outcome and lists the key included attributes without extraneous wording. It could be more structured, but there is no 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?

The description states what is returned but completely omits the meaning of the required 'source' parameter and provides no usage context. Without understanding what source should be, an agent cannot reliably invoke the 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?

The schema has one required parameter, 'source', with 0% description coverage)Skip. The tool description does not mention or explain 'source' at all, leaving the agent without any basis for what value to provide.

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

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

The description clearly specifies the resource (queries) and the details included: kind, step count, load destination, and dependencies/usage. It distinguishes this as an aggregate listing tool, especially against siblings like get_query, though it doesn't explicitly state the verb 'list'.

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

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

No guidance is given on when to choose this tool over get_query, dependency_graph, or list_data_sources. The word 'Every' implies a broad listing use case, but there are no explicit context signals, exclusions, or alternatives.

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

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

The readOnlyHint annotation already signals a safe read operation. The description adds useful context by explaining snapshots are taken automatically before writes and are returned newest first, but it does not describe return shape, pagination, or any other behavioral details beyond the annotation.

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

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

One short sentence front-loads the key fact that snapshots are automatic pre-write captures and ends with ordering. It is concise and efficient, though the implicit 'list' action could be more explicit.

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 read-only tool with one required parameter, the core concept and ordering are present. However, the lack of any return-format detail and minimal explanation of the source parameter leaves some gaps an agent must infer.

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

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

With 0% schema description coverage, the description must compensate, but it only says 'this source' without defining what a source is, what value is acceptable, or how to specify it. This adds minimal meaning beyond the required string property.

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

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

The description conveys that this tool returns snapshots associated with a sourceanding the 'this source' context, and the 'newest first' ordering strongly implies a list operation. It is reasonably distinguishable from restore_snapshot and other siblings, though it lacks an explicit verb such as 'lists'.

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 use this tool versus alternatives like restore_snapshot. The description implies snapshots exist for review, but it does not state when listing is appropriate, what prerequisites exist, or which sibling tools to prefer in other scenarios.

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

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

The annotation readOnlyHint=true already signals that this is a safe read operation. The description adds context about what is listed and that both workbooks and models are usable as `source`, but it does not disclose the output shape or possible empty results. This is acceptable but not particularly rich.

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

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

A single sentence that front-loads the action and resource, then adds a clarifying explanation of scope. There is no filler, repetition, or unnecessary structure.

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

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

For a zero-parameter, read-only listing tool, this description is largely sufficient: it states what is listed and notes the explanatory component. A minor gap is the lack of any detail about the return format, but no output schema exists and the tool's behavior is simple enough that this is not critical.

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

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

The tool has zero parameters and the schema has 100% coverage for an empty property set, so the description carries no parameter burden. The description still adds useful context by clarifying what the listed resources are usable as (`source`), justifying a score above the 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 names a specific action and resource: it lists open Excel workbooks and Power BI Desktop models, and explains other source forms. It is clear and specific, though it does not explicitly distinguish itself from the sibling list_data_sources, so it falls just 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?

The intended use case is implied: call this when you need to enumerate available sources and understand source form options. However, it gives no explicit when-not-to-use guidance or alternatives, especially given the similarly named sibling list_data_sources.

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

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

Annotations already declare readOnlyHint=true, so the safety profile is covered. The description adds that the tool provides a catalog with params, which is useful context, but it does not describe return format, ordering, or any other behavioral details. This is acceptable for a read-only list tool given the annotation.

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

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

The description is a single, focused sentence that front-loads the core purpose and then provides clarifying examples. Every element earns its place, and there is no redundant or filler content.

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

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

Given the tool's simplicity—no parameters, no output schema, and a clear read-only role—the description is nearly complete. It names the associated sibling apply_transform and gives concrete examples of what the catalog contains. A brief mention of how the returned catalog might be used would make it fully complete, but it is not essential.

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 100% schema coverage, so there is no parameter documentation burden on the description. The mention of 'their params' refers to the transforms' parameters, not the tool's own arguments, which is fine. Baseline 4 applies because no parameters need semantic clarification.

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

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

The description clearly identifies this tool as a catalog of guided actions for apply_transform, naming example transforms like unpivot, pivot, and group_by. This distinguishes it from apply_transform itself, which presumably performs the transform. A slightly stronger verb like 'lists' would make it explicit, but the intent 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 implies the tool is used when you need to discover available transforms and their parameters for apply_transform. However, it does not explicitly state when to use it versus alternatives or mention any exclusions. The usage context is inferable from the sibling relationship but not directly 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?

The annotation readOnlyHint=true already declares this as a read-only operation, so the description need not repeat that. It adds behavioral context by explaining what results to expect: signatures and descriptions for exact names, member lists for namespaces, and search results for keywords. It does not discuss pagination or the limit parameter's effect, but these are minor given the read-only nature.

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 purpose and includes concrete examples. Every clause adds value, and it avoids redundancy. It is concise yet comprehensive for the tool's complexity.

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

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

Given the tool's complexity (850+ members, multiple lookup modes) and the absence of an output schema, the description covers all necessary usage aspects: how to query by exact name, namespace, or keywords. It even includes examples. The only omission is the limit parameter's behavior, but that is a minor detail that can be inferred from its default. Overall, it is complete for an agent to call the tool correctly.

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

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

Schema description coverage is 0%, so the description must explain the parameters. It thoroughly explains the primary parameter name_or_search with examples of exact name, namespace, and search words. However, it does not explicitly describe the limit parameter, which controls result count, leaving its meaning to inference. The main parameter is well-covered, but the secondary one is not.

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: look up the M standard library. It specifies three distinct query modes (exact name, namespace, search words) with concrete examples. This distinguishes it from all sibling tools, none of which perform library lookup.

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

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

It explicitly tells when to use the tool: 'Use it instead of guessing signatures.' It also describes the three usage patterns (exact name, namespace, or search words), giving an agent clear guidance on how to phrase the input. No alternative tool is mentioned, but since it is the only library lookup tool, this is sufficient.

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

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

Annotations already declare readOnlyHint=true, which covers the safety profile. The description adds the constraint 'open Excel workbook only,' which is a useful behavioral note. However, it doesn't disclose what happens when the workbook is not open or other edge cases, so it adds limited value beyond the annotations.

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

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

The description is two sentences long, directly stating the core function and a usage tip. It is front-loaded with the primary purpose and contains no filler or redundant information, making it highly concise and well-structured.

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

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

Given that there are 3 parameters with zero schema descriptions and no output schema, the description is insufficient. It does not explain parameter semantics, the meaning of 'rows,' or the return format beyond 'column names and first rows.' While it notes the workbook constraint, it lacks critical details needed for an agent to call the tool correctly without additional context.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters (source, name, rows). It doesn't clarify what 'source' and 'name' refer to, nor does it mention the 'rows' parameter with its default of 20. The description fails to compensate for the lack of schema documentation, leaving the agent to infer parameter meanings.

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 column names and first rows of a query, and specifies the context of an open Excel workbook. It also mentions a concrete use case ('before apply_transform'), which helps identify the tool's purpose. However, it does not explicitly distinguish it from sibling tools beyond that use case.

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 clear usage direction: 'Use it to get real column names before apply_transform.' This provides a specific scenario for when to invoke the tool, though it doesn't mention when not to use it or compare it to alternatives.

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

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

With no annotations, the description must carry the behavioral burden. It usefully discloses that the tool blocks until refresh completes and returns the mashup engine's error text on failure. It does not, however, mention side effects, permissions, success return shape, or broader implications of refreshing, so the disclosure is partial rather than 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 that conveys the operation, scope, blocking behavior, and failure output without filler. Every phrase earns its place.

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

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

For a simple two-parameter tool, the description covers the main prerequisite (open workbook), the operation (refresh one query), and one outcome (error text on failure). It leaves the success return value unspecified and does not clarify what 'source' refers to, so it is adequate but not fully complete for an agent with no additional schema context.

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

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

Schema description coverage is 0%, and the description does not explain what 'source' and 'name' mean explicitly. The phrase 'one query in an open Excel workbook' weakly implies that source identifies the workbook and name identifies the query, but the agent is left to infer the parameter mapping. The description does not compensate for the missing schema-level parameter docs.

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

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

The description names a specific verb and resource: 'Refresh one query in an open Excel workbook.' It also adds distinguishing behavior by stating it waits for completion and returns error text on failure, which separates it cleanly from siblings like list_queries, evaluate_query, or set_query. There is no ambiguity about the core 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?

Usage context is implied by 'one query in an open Excel workbook,' so an agent can infer this is for refreshing an existing query rather than listing or editing queries. However, there is no explicit guidance about when to choose this tool over related alternatives like evaluate_query or set_query, and no exclusionary conditions 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?

There are no annotations, so the description carries the behavioral burden. It does disclose the destructive nature ('Delete') and a key side effect ('rewire the steps that used it'), which is useful. But it does not mention whether the change is reversible, whether it affects other query definitions, or what happens when rewiring is impossible.

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

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

The description is a single, front-loaded sentence that immediately states the action and the critical rewiring side effect. Every part of the sentence adds value and there is no filler.

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

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

For a mutation tool with no annotations, no output schema, and zero parameter documentation, this description is too sparse. An agent does not learn what 'source' and 'query' mean, whether dry_run suppresses the actual delete, or what the tool returns.

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

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

Schema description coverage is 0%, so the description must compensate for the four parameters. It adds some semantic context by referring to relationships between steps, but it does not clarify the roles of 'source', 'query', or 'dry_run' beyond what the bare parameter names suggest.

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 ('Delete') and resource ('a step'), and immediately explains the distinct side effect: rewiring dependent steps to the step they read from. This clearly separates it from sibling tools like rename_step and delete_query.

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

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

The description implies when to use the tool: when a step should be removed and its dependents rewired. However, it does not explicitly state when not to use it or compare it to alternatives such as rename_step or delete_query, leaving the usage context 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?

Annotations are absent, so the description carries the full burden. It discloses the key behavioral trait: the rename is token-aware, leaving strings, comments, and same-named columns untouched, which prevents unintended modifications. This is valuable beyond the schema. It does not mention side effects like irreversibility or permission requirements, but the core mutation behavior is well explained.

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

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

The description is a single sentence that is dense with information: it states the action, the scope of rewriting, and the safety constraints. It is front-loaded with the core action and immediately clarifies the behavioral nuance. 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?

The tool is moderately complex due to its global rewrite behavior and token-awareness. The description covers the key behavioral aspects, but it omits details about the 'dry_run' parameter and potential side effects (e.g., what happens if the old name doesn't exist). However, given that the output schema is absent and the parameter semantics are mostly inferable, the description is reasonably complete for an agent to invoke it correctly, though the 'dry_run' behavior is a notable 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?

The schema has 0% coverage, so the description must compensate. The description does not explicitly explain the parameters 'source', 'old_name', 'new_name', or 'dry_run'. However, the tool name and description imply that 'old_name' and 'new_name' are the target and replacement names, and 'source' likely specifies the context. The 'dry_run' parameter's purpose (preview changes without applying) is not mentioned, which is a gap given the schema lacks any 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 'Rename' and the resource 'query', and importantly specifies the scope: it rewrites every reference in all other queries. It also distinguishes what it does not touch (strings, comments, same-named columns), which helps set expectations. This is highly specific and differentiates from siblings like 'rename_step' or 'replace_in_queries'.

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

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

The description implies usage for renaming a query and updating references globally, but it does not explicitly state when to use this tool versus alternatives like 'replace_in_queries' or 'rename_step'. The token-aware behavior is mentioned but no explicit 'when not to use' is given. However, the context suggests it is for query renaming, which is reasonably clear.

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

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

No annotations exist, so the description carries full disclosure burden. It reveals that references are updated, but omits side effects (e.g., irreversibility, error handling for missing old_name, or whether dry_run is supported). The dry_run parameter is not mentioned.

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 efficiently conveys the core action and scope.

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 mutation tool with 5 parameters and no annotations, the description is insufficient. It lacks parameter meanings, return behavior, error handling, and any details about how references are updated. An agent cannot reliably 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?

Schema description coverage is 0%, and the description adds no parameter explanations. While 'old_name' and 'new_name' are self-evident, 'source' and 'query' are ambiguous, and 'dry_run' is entirely undocumented.

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

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

The description states a specific verb ('rename') and resource ('a step inside a query') with a clear scope ('every reference to it'). This distinguishes it from sibling tools like rename_query (renames whole query) and remove_step (deletes a step).

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

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

The description implies usage for renaming steps but offers no explicit guidance on when to use this tool versus alternatives. No exclusions, conditions, or references to sibling tools are provided.

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

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

With no annotations, the description carries the full burden for behavioral disclosure. It does explain scope semantics ('inside text literals' vs 'outside strings and comments'), but it does not mention that this mutates query definitions, whether changes are reversible, how dry_run behaves, or what output the caller should expect. The word 'replace' implies mutation, but the destructive nature and safety affordances are left 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?

The description is short, front-loaded with the core behavior, and every sentence earns its place. The example and the scope breakdown are compact and immediately useful, with no filler or repetition of schema data.

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

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

For a tool with 8 parameters, no output schema, and no annotations, this description is not complete enough. It explains the main purpose and scope options but leaves required parameters, regex behavior, dry-run behavior, and return values undefined, making it difficult for an agent to invoke the tool 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%, so the description must compensate. It explains only the 'scope' parameter in detail; the other seven parameters—especially required ones like 'source', 'find', and 'replace'—are not described. Parameter names like 'dry_run' and 'ignore_case' are partially self-explanatory, but that does not make up for the lack of formal guidance on 8 parameters.

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

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

The description states a specific operation ('Find and replace') on a specific resource ('queries'), and clarifies the scope ('all or the listed queries in one go') with a concrete example. This clearly distinguishes it from single-query tools like set_query and from find_in_queries.

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 clear use case ('repoint a server or folder') and explicitly says it operates across all or selected queries at once. It does not name exclusions or alternatives, but the context is strong enough for an agent to infer when bulk replacement is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It discloses destructive behavior: 'queries created since are deleted' and explains the 'latest' default behavior. This is meaningful behavioral context beyond the schema. It could add more about reversibility or side effects, but the core destructive nature is disclosed.

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

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

The description is compact and front-loaded with the main action. The parenthetical about `queries` and the 'latest' note are useful and placed efficiently. It earns its place without excessive 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?

The tool has 4 parameters, no output schema, and no annotations. The description covers the core behavior and two parameters, but leaves `source` and `dry_run` unexplained. For a destructive operation, the missing `dry_run` semantics and the required `source` parameter are notable gaps.

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

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

Schema description coverage is 0%, so the description must compensate. It explains `queries` (partial restore) and `snapshot_id` ('latest' undoes the most recent write), but does not explain `source` or `dry_run`. The description adds value for two of four parameters, but leaves the required `source` and the safety-relevant `dry_run` undocumented.

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

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

The description clearly states the action ('Roll back to a snapshot') and the resource (snapshot/query set), and distinguishes the partial vs full restore behavior. It doesn't explicitly name sibling tools like list_snapshots or copy_queries, but the verb 'restore' plus the rollback semantics make the purpose 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 description explains when to use the tool: to roll back to a snapshot, with a conditional for partial restore via `queries` vs full restore. It doesn't explicitly state when not to use it or name alternatives, but the context is clear enough for an agent to select it over list_snapshots or copy_queries.

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

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

With no annotations, the description carries the full burden, and it does well by revealing validation behavior ('Rejects unbalanced brackets/strings before writing') and conditional creation via create_if_missing. It could go further by mentioning dry_run behavior or the result of a successful write, but the core mutation and validation traits are clear.

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

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

Two sentences with no filler. The core behavior is front-loaded, the create_if_missing behavior is included, and the sibling routing is appended without wasting 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?

The description captures the essential behavior, validation, and tool-selection context. However, with no output schema and several under-documented parameters, an agent may still be unsure about what values source/name/dry_run expect and what the call returns.

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

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

Schema description coverage is 0%, so the description must compensate, but it only clarifies formula and create_if_missing. The roles of source, name, description, and dry_run are not explained, especially source/name, which are ambiguous in this domain.

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: 'Replace a query's M', and explicitly mentions the create_if_missing option. It also differentiates against siblings by saying apply_transform is preferred for standard actions and rename_query/rename_step for renames.

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

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

It gives explicit routing guidance: 'For standard actions prefer apply_transform; for renames prefer rename_query / rename_step.' This tells an agent when not to choose this tool and which sibling to use instead.

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

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

Annotations only provide readOnlyHint:true. The description adds useful behavioral detail: it reports line/column syntax errors, plain-English causes, did-you-mean suggestions for unknown steps/queries/functions, and argument-count checks. No contradiction with annotations 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 sentences with no filler. The first sentence front-loads the purpose and key behaviors; the second sentence covers the valid invocation patterns. Every clause adds information useful for invoking the tool correctly.

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

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

The description names the error classes and parameter modes, which is strong, but it does not state what happens on success or what a successful validation returns, and there is no output schema. It also leaves implicit whether at least one of formula/source is required, despite all parameters being optional in 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?

With 0% schema description coverage, the description carries the parameter burden. It explains formula as an expression or whole section document, source as providing known query names, and query as optional alongside source. The 'query' parameter remains thinner than the others, but the main parameters are meaningfully defined.

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 verb and resource: 'Check M before using it' and enumerates specific checks (syntax errors with line/column, unknown identifiers with did-you-mean, wrong argument counts). It is clearly distinct from evaluate_m, format_m, and m_function_help in behavior, though it never names a 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 gives concrete usage context: validate before using M, pass formula with optional source, or validate existing source with optional query. It does not explicitly say when not to use this tool or name alternatives, but the two invocation modes are clearly described.

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