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

The annotation readOnlyHint=true already establishes that the operation has no side effects. The description adds that the generated scripts include 'error handling and data processing', but this is vague and does not explain whether the tool returns code, writes files, or executes anything. 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?

The description is one sentence with the core action and object front-loaded: 'Generate Python scripts for fetching submatrix data'. There is no filler or repetition, and the added phrase about error handling and data processing earns its place with relevant context.

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 a full parameter schema, an output schema present, and annotations covering read-only behavior, the description covers the minimum needed to invoke the tool. However, it omits context about how the generated script relates to execution versus other data tools, and it lacks sibling differentiation, leaving some ambiguity for an agent deciding between tools.

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

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

Schema description coverage is 100%, so the schema fully documents all six parameters. The description does not add meaningful detail about parameters, such as how script_type affects the output or what output_format options imply. It stays at the baseline of 3 given the complete schema coverage.

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

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

The description uses a specific verb 'Generate' with a clear resource 'Python scripts for fetching submatrix data', distinguishing it as a code-generation tool rather than a data-reading tool. It is clear about the deliverable, though it does not explicitly differentiate itself from siblings like data_read_submatrix or plot_generate_code.

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

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

The description provides no guidance on when to use this tool versus alternatives such as data_read_submatrix, which actually reads data, or plot_generate_code, which generates visualization code. There are no use conditions, exclusion criteria, or scenario hints.

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 notion of 'available quantities' but does not disclose additional behavior such as output shape, error conditions, or relationship to other data operations. No contradiction exists.

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

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

A single, front-loaded sentence that conveys the operation and target resource with no wasted words. It is appropriately concise for a simple one-parameter tool.

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

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

For a simple read-only tool with one parameter, an output schema, and a readOnlyHint annotation, the description is sufficient. It could mention when to use this tool, but the low complexity and existing structured information keep the gap minor.

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 covers the only parameter fully, including a description for submatrix_id. The tool description adds no extra parameter context, but the baseline of 3 applies when schema coverage is complete.

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

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

The description states a specific action ('Get') and resource ('available measurement quantities for a submatrix'), which distinguishes it from sibling operations like data_read_submatrix. However, it does not explicitly contrast itself with any sibling, so it is clear but not fully differentiating.

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

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

No when-to-use guidance is provided, nor are alternative tools mentioned. The description gives no indication of when to choose this over related data tools such as data_read_submatrix or data_generate_fetcher_script.

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

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

The description's 'Read' is consistent with the readOnlyHint annotation, and 'bulk data access' adds a small behavioral nuance. The description does not go beyond this to mention rate limits, pagination behavior, or any other operational traits, but the annotation already covers the safety profile.

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

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

The description is a single sentence with no filler. It front-loads the action and resource and immediately distinguishes the data access method. Every clause contributes to understanding.

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

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

Given the readOnlyHint annotation and the presence of a full output schema plus 100% parameter schema coverage, the description does not need to re-explain returns or parameters. The definition is functionally complete for a read operation, though a brief note about when 'bulk data access' applies could have added a bit more context.

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

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

Schema description coverage is 100%, so the input schema already documents all seven parameters with meaningful descriptions. The tool description adds no parameter-specific guidance beyond the general notion of reading a submatrix, so it does not exceed the schema 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 states a specific verb and resource ('Read timeseries data from a submatrix') and adds 'using bulk data access' to characterize the access mode. It is clear, but it does not explicitly distinguish this tool from siblings such as data_get_quantities or query_execute.

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 the tool should be used when reading timeseries data from a submatrix via bulk access, so the usage context is lightly implied. However, there is no explicit guidance about when to use this tool instead of sibling tools or any exclusions or prerequisites.

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

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

The annotations already declare readOnlyHint=true, so the read-only nature is covered. The description adds that the tool provides guidance on workflows and patterns, but does not go into deeper behavioral details such as response format or how topics are presented; however, the output schema and topic enum reduce the need for that.

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

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

Two concise sentences with no filler. The main purpose is front-loaded, and the second sentence adds actionable usage guidance without redundancy.

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

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

For a help/documentation tool, the description plus the rich input schema and output schema give the agent everything needed to call it correctly: required topic, available enum values, optional tool parameter, and read-only annotations. No critical context is missing.

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

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

Schema description coverage is 100%, so the topic and optional tool parameters are already well documented. The description adds general context about the 3-step workflow and patterns, which maps conceptually to some enum values, but it does not add detailed semantics beyond the schema.

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

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

The description uses a specific verb ('Get help and guidance') with a clear resource ('Bulk API for loading timeseries data') and elaborates on the key workflow ('3-step workflow and common patterns'). This makes it readily distinguishable from the sibling query and data tools, which target different operations.

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 says 'Use this to understand the 3-step workflow and common patterns,' giving clear context for when the tool is appropriate. It does not name alternative tools or exclusions, but the guidance is sufficient for an agent to recognize this is the help entry point for Bulk API usage.

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

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

Annotations say readOnlyHint=false, destructiveHint=false, so the tool is already marked as non-read-only and non-destructive. The description adds that it establishes a connection, which implies a stateful side effect. It does not mention connection lifecycle, cleanup via 'ods_disconnect', or any additional behavioral consequences, but it does not contradict 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?

A single, front-loaded sentence with no filler. It states the action first and the purpose second. Every word contributes something meaningful.

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 basic connection tool, the schema and annotations cover a good deal of what is needed to invoke it. The missing pieces are guidance on when to prefer this over 'ods_connect_using_env' and the expected lifecycle after connecting. The output schema exists, so return-value documentation is not needed here.

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

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

The description contains no parameter-level information. The schema documents 3 of 4 properties (url, username, verify), with password left undescribed, so schema coverage is 75%—not high enough to fully absolve the description from adding context. The description adds nothing about how the parameters are used or what happens with the credentials.

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 ('Establish connection') with a concrete resource ('ASAM ODS server') and states the intended use ('live model inspection'). This makes the tool's basic purpose clear. However, it does not differentiate this from the sibling 'ods_connect_using_env', which seems to perform a very similar task via environment credentials.

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

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

The phrase 'for live model inspection' provides an implied use case: connect when live inspection is needed. Yet there is no explicit guidance about when to choose this tool over 'ods_connect_using_env' or how it relates to 'ods_disconnect'. The selection is left largely 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 already mark the tool as read-only (readOnlyHint: true), and the description adds useful context by specifying the returned data (server prefix and URL). It does not contradict annotations and gives enough behavioral detail for a simple list 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 compact and front-loaded with the core purpose in the first sentence. The second sentence adds valuable connection guidance without redundancy or filler.

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

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

For a zero-parameter, read-only list tool with an output schema and annotations, the description is complete. It explains what the tool returns and how to use the result, which is all an agent needs to select and 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?

This tool takes zero parameters, so there are no parameter semantics to document. The description correctly focuses on output and usage, meeting the baseline for a parameterless tool.

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

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

The description uses a specific verb ('List') and a specific resource ('ODS servers configured via environment variables'), and states the output (prefix and URL). It clearly differentiates this tool from siblings like ods_connect_using_env by framing this as the lookup step before connecting.

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 identify the right server before connecting. It explicitly directs the agent to ods_connect_using_env(env_prefix='PREFIX') afterward, which is actionable guidance that ties the tool to its intended workflow.

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 carry the read/write/destructivity profile (readOnly=false, destructive=false, openWorld=true). The description adds meaningful behavior: lists three auth modes (basic, m2m, oidc), enumerates required variables, and documents the legacy pref ix fallback. 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 long but structured with intro, a listed env-var templates, and organized auth modes. However, the sentence about 'Supports three authentication modes via {prefix }_ODE or ODSBOXX_MCP_{prefix}_ODE' appears confusingly worded; the ODSBOXX_MCP_{prefix}_ODE form is redundant or erroneous, which wastes space and could mislead an agent.

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

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

Given the tool's auth complexity, the description covers defaults, env vars, mode selection, legacy fallback, and the relationship to ods_connect. Combined with the output schema and annotations, an agent has enough to invoke it. Minor gaps such as side effects or whether the connection must later be closed are left unspecified, but the sibling ods_disconnect and openWorld hint mitigate that.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra meaning for env_prefix by explaining the default prefix (ODS box_MCP), the env var that can change it (ODS box_MCP_ENV_PREFIX), and how env_prefix interplays with the mode templates beyond the schema's bare 'override the environment variable pref ix'.

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

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

States a specific verb, resource, and mechanism: 'Establish connection to ASAMOD server using environment variables.' It also tells the reader this is the env-var alternative to ods_connect, which distinguishes it from siblings without opening the schema.

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

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

Explicitly says when to use it: 'This is an alternative to ods_connect for when you have an existing environment of ODS boxes variables.' It describes a default and fallback for auth modes, giving clear conditions for choosing 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?

Annotations already declare idempotentHint=true and destructiveHint=false, covering repeated-call and non-destructive behavior. The description adds only the target ('ODS server') and does not disclose extra behavioral nuances such as whether an active connection is required or how pending queries are affected, but for a zero-parameter disconnect this is acceptable.

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 five words in one clear sentence with no filler. It places the action and object up front and earns its place entirely.

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, annotation-covered lifecycle tool with an output schema, the description is essentially complete. The sibling list already provides the connection context, though the description could explicitly mention that this is the cleanup counterpart to ods_connect.

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

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

The input schema has no parameters and schema description coverage is 100%, so there is nothing for the description to add. The baseline for zero-parameter tools applies.

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

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

The description states the exact action ('Close') and resource ('connection to ODS server'), making the tool's function immediately unambiguous. It is also clearly distinguished from siblings like ods_connect, ods_connect_using_env, and ods_get_connection_info.

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

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

No explicit when-to-use guidance or alternatives are mentioned, but as a connection-lifecycle tool it is clearly meant to pair with the connect tools. The description leaves the intended timing ('after connection work is done') to inference rather than stating it.

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

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

The description is consistent with the readOnlyHint annotation and adds the 'current connection' framing, which implies it reports state rather than modifying it. However, it does not disclose any additional behavioral traits such as behavior when no connection exists or whether the result reflects locally cached vs. live connection data. The annotation already covers the core safety profile, so this is adequate but not 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?

The description is a single, front-loaded sentence with no filler or repetition. For a zero-parameter getter tool, this is appropriately concise and structurally 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?

Given the tool has no parameters, has a readOnlyHint annotation, and has an output schema, the description covers the essential purpose without needing to explain return values. It is complete enough for an agent to select and invoke the tool correctly, though a small note about requiring an active ODS connection could add 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?

The tool has zero parameters, so there is no parameter semantics burden for the description to carry. The schema is already fully complete and the description does not need to explain any 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 uses a specific verb ('Get') and resource ('current ODS connection information'), making it clear this is a read-only informational tool. It is distinguishable from siblings like ods_connect and ods_disconnect because it retrieves state rather than changing it, though it does not explicitly name those alternatives.

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

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

No guidance is given about when to call this tool instead of ods_connect_env_list or ods_connect. The intended use is only implied by the phrase 'current ODS connection information'; there are no explicit conditions, prerequisites, 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?

The description discloses an important behavioral detail: the generated notebook reads the password from ODS_PASSWORD at runtime, avoiding embedded credentials. This goes beyond the annotations and adds useful security-relevant context. No contradiction with readOnlyHint=false or destructiveHint=false.

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

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

The description is three short sentences with no redundant content. The main purpose is front-loaded, and the connection and credential-handling details each earn their place.

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

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

The description covers the key prerequisite connection requirement and the security-relevant caching behavior. Combined with the rich input schema, enum options, and output schema, an agent has enough context to invoke the tool, though explicit sibling differentiation is left unstated.

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

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

Schema description coverage is 100%, so the input schema already documents all parameters including examples for measurement_query_conditions. The description does not add additional parameter-level meaning, making the baseline 3 appropriate.

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

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

The description clearly states the verb-action 'Generate a Jupyter notebook' and the resource purpose 'comparing measurements'. It differentiates itself from the sibling plot_generate_code by specifying the notebook format rather than generic code generation.

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 mentions a prerequisite (active ODS connection via ods_connect or ods_connect_using_env) but gives no guidance on when to choose this tool over alternatives such as plot_generate_code. There are no exclusions or explicit 'when to use' instructions.

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 annotations already establish readOnlyHint=true, and the description aligns by saying it generates code rather than mutating data. It adds useful context that the output is Python plotting code, but it does not describe the output format, whether the code is standalone, or any limitations beyond what the annotations and output schema already imply.

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

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

The description is a single, front-loaded sentence with no filler, repetition, or redundant content. It communicates the action, resource, and purpose efficiently, which is ideal for an agent scanning tool descriptions.

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 low complexity: all three required parameters are fully described in the schema and an output schema is present, so the description does not need to restate parameters or return values. The remaining gap is the lack of explicit differentiation from plot_comparison_notebook, which prevents a perfect score.

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

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

Schema description coverage is 100%, so all three parameters are already documented with types and descriptions in the input schema. The description adds only the high-level 'measurement comparison' framing and no additional detail about how the parameters relate to one another, so the baseline score of 3 is appropriate.

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

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

The description clearly identifies the action ('Generate') and the resource ('Python plotting code') and adds the purpose 'for measurement comparison.' It does not explicitly name sibling tools, but the focus on Python plotting code distinguishes it from notebook-oriented or data-fetching siblings such as plot_comparison_notebook and data_generate_fetcher_script.

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

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

The phrase 'for measurement comparison' implies when the tool is appropriate, but there is no explicit guidance about when to use it versus plot_comparison_notebook or other plotting/code-generation siblings, and no exclusions are stated. This is adequate but leaves the choice 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?

The annotations declare readOnlyHint=true, and the description is consistent with that, indicating a non-mutating operation. It adds the behavioral idea that the tool produces a description rather than executing the query, but it does not disclose output format or whether a connection is required. The output schema likely covers return details, so this is adequate but not 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?

The description is a single short sentence with no filler or redundancy. It is front-loaded and easy to parse. It earns its place, though it is slightly underspecified.

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

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

For a one-parameter, read-only tool with an output schema, the core purpose is conveyed. However, the description lacks any mention of when to prefer this tool over related query tools or what kind of description the agent should expect. It is minimally complete but leaves selection and expectation-setting 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 100%: the query parameter has a type, description, and an example. The tool description itself adds no additional parameter-level meaning, so the baseline of 3 applies.

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

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

The description uses a clear verb+resource pair: 'Describe what a Jaquel query does.' It is unambiguous about the tool's action, and the resource (Jaquel query) matches the input schema. It does not explicitly contrast with sibling tools like query_validate or query_get_pattern, so it stops 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?

There is no guidance on when to use this tool versus alternatives such as query_validate, query_get_pattern, or query_execute. The description merely states what the tool does, leaving the agent to infer selection criteria from the name and siblings.

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

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

The readOnlyHint annotation already conveys the safety profile, and the description is consistent with it, so there is no contradiction. The word 'directly' suggests immediate execution without validation or transformation, and the requirement of a connected ODS server is hinted, but the description does not disclose failure modes, validation behavior, or context-size safeguards beyond what the schema explains.

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

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

The description is a single, front-loaded sentence with no filler or redundant wording. Every word contributes to identifying the operation, making it highly concise while remaining more informative than a tautology.

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 input schema is unusually rich, the read-only annotation is present, and an output schema exists, so the description does not need to explain return values or parameter details. The main gap is the lack of routing guidance relative to query_validate and other siblings, but for an execution tool with this much structured context, the definition is close to complete.

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

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

Schema description coverage is 100%, and the schema already provides detailed semantics: a full Jaquel query example, defaults for max_rows, the adaptive max_cells formula, and format/token guidance for result_format. The description itself adds no parameter-level meaning, so the baseline score of 3 applies.

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

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

The description states a specific action ('Execute'), a specific resource ('a Jaquel query'), and a target ('connected ODS server'), which makes the tool's core purpose clear. It does not explicitly contrast it with sibling tools like query_validate, query_describe, or data_read_submatrix, but the verb 'execute' plus 'directly' gives the agent a reasonable basis for differentiation.

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

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

There is no guidance on when to use this tool versus query_validate, query_generate_skeleton, query_describe, or data_read_submatrix. It does not mention whether the query should be validated first, whether an active ODS connection is required beyond the phrase 'connected', or when an alternative would be preferable.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds that the tool generates a skeleton rather than executing a query, but it does not explain what the skeleton contains or how it should be used afterward.

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

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

The description is a single sentence with no filler, the verb is front-loaded, and every word contributes to identifying 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 two-parameter tool with an output schema and read-only annotations, the basic invocation is reasonably covered. However, in a family of many query_* siblings, the lack of any positioning information leaves uncertainty about preconditions and relationship to other tools.

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

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

Schema description coverage is 100%, and both parameters already have meaningful descriptions and examples. The description only adds the generic phrase 'specific entity and operation', which does not meaningfully extend the parameter information already available.

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 the specific verb 'Generate', the object 'query skeleton', and the scope 'specific entity and operation'. This is clear and distinguishes it from execution or validation tools, though it does not explicitly name sibling tools for contrast.

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

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

No guidance is provided about when to use this tool versus closely related siblings such as query_get_pattern, query_describe, query_validate, or query_execute. An agent is left to infer the tool's role from its name and the word 'skeleton'.

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 no additional behavioral context such as return type details, error behavior, or authentication requirements, but it also does not contradict 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 a single, front-loaded sentence with no filler. Every word contributes to explaining what the tool does, which is ideal for a simple one-parameter documentation tool.

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

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

For a single-parameter, read-only tool with an output schema, the description is fully sufficient. It tells the agent what the tool returns, and the input is fully defined 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?

Schema description coverage is 100%, and the schema already documents the 'operator' parameter with examples. The description adds no new parameter semantics, but none are needed given the schema's completeness.

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

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

The description states a specific action ('Get documentation and examples') and a specific resource ('Jaquel operator'), so an agent knows exactly what the tool provides. The resource term also distinguishes it from siblings like query_get_pattern and query_describe.

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

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

The description implies this tool is for retrieving Jaquel operator documentation, but it does not explicitly state when to prefer it over sibling tools or mention any exclusions. Usage context is inferable 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?

Annotations already declare readOnlyHint=true, so the description is not required to restate safety behavior. It does add that the tool provides a template for a common pattern, but it does not disclose additional behavioral traits such as what the template contains, whether unknown pattern names fail, or how the template is returned. 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?

A single sentence states the tool's purpose with no filler. It is front-loaded and appropriately sized for a one-parameter, low-complexity 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?

With a single required parameter, a complete enum in the schema, an output schema, and read-only annotations, the description is largely sufficient. The main gap is the lack of usage guidance relative to sibling tools, but that is already penalized under usage_guidelines.

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

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

Schema description coverage is 100%: the single pattern parameter lists all accepted values in its description. The tool description adds little beyond the schema, so the baseline of 3 applies.

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

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

The description states a clear verb and resource: getting a template for a Jaquel query pattern. It is distinct enough from siblings like query_list_patterns (which lists patterns) and query_generate_skeleton (which may generate code), though it doesn't explicitly draw those contrasts.

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 related tools such as query_validate, query_get_operator_docs, or query_generate_skeleton. The intended use is only implied by the name and the pattern parameter, not explicitly 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?

Annotations already mark this as read-only, and the description adds little behavioral context beyond enumerating available items. There is no mention of output granularity, ordering, or whether the list is static, though the output schema likely covers the return shape.

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 conveys the entire operation with no filler or redundancy. It is appropriately minimal for a parameterless listing tool.

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

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

For a zero-parameter, read-only listing tool with an output schema, this description is sufficient: an agent knows exactly what operation is offered and that it is safe to call. No missing information would prevent correct selection or invocation.

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

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

The input schema has zero parameters and 100% schema coverage, so there is nothing for the description to explain. The baseline of 4 for parameterless tools applies; the description correctly focuses on the operation rather than parameter details.

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

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

The description uses a specific verb ('List') and a precise resource ('all available Jaquel query patterns and templates'), making the operation unmistakable. It naturally distinguishes this list-all tool from the sibling query_get_pattern, which retrieves a single pattern.

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

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

The phrase 'List all available' implies the tool should be used when an agent needs to enumerate the full set of patterns/templates, but the description never explicitly states when to use it versus query_get_pattern or query_get_operator_docs. No alternative tools or exclusions are named, so guidance is only implied.

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

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

Annotations declare readOnlyHint=true, so no safety contradiction exists. The description adds that validation covers syntax errors and best practices, giving useful behavioral scope beyond the annotations. It does not detail the exact validation rules, but the output schema can cover the return shape.

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

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

A single front-loaded sentence with no filler. Every word contributes meaning, and the core action is stated immediately.

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

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

For a one-parameter, read-only validator with an output schema, the description is nearly sufficient. It could explicitly clarify that validation does not execute the query or contrast itself with query_execute, but the schema and annotations cover the remaining essential context.

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

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

Schema description coverage is 100%, and the single 'query' parameter is thoroughly documented with a concrete Jaquel query example. The tool description adds no parameter-level meaning, so the baseline score of 3 applies.

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

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

States a specific verb ('Validate'), a specific resource ('Jaquel query structure'), and the exact concerns checked ('syntax errors and best practices'). This clearly distinguishes it from sibling tools like query_execute, query_describe, and query_generate_skeleton.

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 to check a query before executing it, but it never explicitly says when to use it vs. alternatives or names query_execute as the complementary follow-up. The usage context is inferable but not 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?

Annotations already declare readOnlyHint=true, so the read-only safety profile is provided. The description aligns with this annotation but adds no additional behavioral context (e.g., whether 'exists' means closed-world, error behavior, or usage limits). With annotations covering the main safety profile, a 3 is appropriate.

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

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

The description is a single sentence with no wasted words, front-loading the core action. It is appropriately sized for a simple tool.

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

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

The tool is simple, both parameters are fully documented, an output schema exists, and annotations cover the read-only nature. The description lacks usage guidelines but is otherwise sufficient for an agent to invoke the tool correctly. Minor gap in not stating when to use it.

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

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

The input schema documents both parameters with 100% coverage and includes concrete examples. The description adds no extra parameter semantics beyond what the schema already provides, so the baseline of 3 applies.

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

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

The description states a specific action ('check if a field exists') and a clear resource ('entity schema'), making the tool's purpose unambiguous. No sibling tools are listed, so differentiation is not required. A small deduction for not specifying what the check returns, though the output schema presumably covers that.

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

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

No guidance is provided on when to use this tool versus alternatives, nor any exclusions or prerequisites. The description only states what the tool does, not when it should be selected, leaving the agent to infer appropriateness from the name alone.

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

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

Annotations already declare readOnlyHint=true, so the safe read-only behavior is covered. The description adds the ODS model source context but does not disclose additional behavioral details such as error conditions or whether a connection must already exist. 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 a single front-loaded sentence with no wasted words. It immediately communicates the action and resource without unnecessary background.

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

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

With one required parameter fully documented in the schema, a read-only annotation, and an output schema present, the description is sufficient for an agent to invoke the tool correctly. No critical information is missing.

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

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

The input schema provides 100% coverage for entity_name, including an explicit example, so the schema carries the parameter documentation burden. The description adds no extra meaning about the parameter beyond what the schema already provides.

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

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

The description states a specific action ('Get available fields') and a clear resource ('an entity from ODS model'). It is plainly distinct from siblings like schema_list_entities and schema_field_exists by focusing on retrieving all fields for one entity.

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

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

No guidance is provided on when to use this tool versus alternatives such as schema_field_exists or schema_list_entities. The intended usage must be inferred entirely from the tool name and description.

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

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

Annotations already indicate readOnlyHint=true and openWorldHint=false, so the safety profile is covered. The description adds the source context 'ODS server ModelCache' and the 'existing entities' scope, but does not disclose details such as ordering, whether entity metadata is included, or whether a connection is required first.

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

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

The entire description is one concise sentence that front-loads the action and resource. There is no wasted wording or repetition of structured 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 zero-parameter tool with an output schema available, the description is suitably complete. It names the resource, states the operation, and gives the source location. No additional explanation of return values is needed because the output schema covers that.

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

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

The input schema has zero parameters and schema description coverage is 100%, so there are no parameter semantics to document. The description still reinforces that no inputs are needed and that it simply returns the existing entity list.

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 ('Return a list'), the resource ('existing entities'), and the source ('ODS server ModelCache'). This distinguishes it from sibling tools like schema_get_entity, which targets a single entity, and query_* tools, which handle 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 provides no explicit guidance on when to use this tool versus alternatives such as schema_get_entity or schema_field_exists. The context 'existing entities' implies a listing use case, but there is no direct statement of applicability, exclusions, or prerequisite connection steps.

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, and the description does not contradict that. It adds useful traversal semantics (AoTest -> AoMeasurement via 'children'), but it does not disclose additional behavior such as recursion depth, ordering, empty-result behavior, or whether intermediate nodes are included.

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 conveys the operation without filler. Every word contributes to identifying the resource, endpoints, and relation.

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

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

Given zero parameters, an output schema, and a read-only annotation, the description is nearly complete for invocation. It fully specifies the traversal path, though it could strengthen completeness by adding when to use it relative to sibling schema tools.

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

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

The tool has zero parameters, so parameter semantics are not applicable and the baseline of 4 applies. The description has no parameter information to add because none exist.

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

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

The description states a specific verb ('Get') and resource ('hierarchical entity chain'), and identifies exact start and end entities ('AoTest' to 'AoMeasurement') plus the relation ('children'). This clearly differentiates it from more generic sibling tools like schema_get_entity and schema_list_entities.

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 use case is implied: call this when you need the AoTest-to-AoMeasurement hierarchy via the children relation. However, it does not explicitly state when to prefer this over alternatives, nor does it mention any exclusions or when-not-to-use conditions.

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