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

With no annotations, the description carries the behavioral burden itself. It explicitly discloses that the operation is read-only and that results are capped, which addresses the two main risks of executing a query: side effects and unbounded output. It leaves details like default cap behavior unspecified, but the key safety traits are present.

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, wasted words, or repetition of the tool name. The primary action is front-loaded, and the qualifiers 'read-only' and 'capped' are attached compactly.

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

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

There is no output schema and no annotations, so the description should explain both behavior and return expectations. It covers safety and capping but omits usage context, parameter details, and what the query response looks like. An agent would be uncertain about edge cases such as exceeding the cap or omitting `maxCells`.

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% description coverage, so the description must compensate. It partially does: 'MDX query' semantically anchors the required `mdx` parameter, and 'capped' hints at the purpose of the optional `maxCells` parameter. However, it does not explain the expected format, defaults, or how the cap behaves, leaving significant inference to the agent.

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 ('Run') with a clear resource ('an MDX query'), and adds two scope-defining traits: read-only and capped. This clearly distinguishes it from the sibling list/get tools, which are about retrieving administrative or metadata objects rather than executing ad-hoc 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 no guidance on when to use this tool versus alternatives such as tm1_get_cube_grid, or when it would be inappropriate. The read-only and capped hints imply a safe execution context, but no explicit condition, exclusion, or named alternative is provided.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that the result is ordered dimensions, which is minimal. It does not describe the return format, whether it returns dimension names or objects, error behavior for invalid cube names, or any side effects.

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

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

The description is a single short phrase with no filler, and the key concept is front-loaded. It is concise to the point of under-specification, but it does not waste words or repeat the tool name. The brevity is appropriate for a simple one-parameter read operation, though it could be a full sentence.

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, but with no annotations, no output schema, and 0% parameter coverage the description should still clarify what the returned ordered dimensions look like. It does not mention whether this returns names only, includes hierarchy info, or how errors are handled. The description is too thin for an agent to confidently predict the tool's behavior.

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

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

Schema description coverage is 0%, so the description must compensate for documenting cubeName. The phrase 'of a cube' implies cubeName identifies the cube whose dimensions are returned, which is useful but minimal. It does not clarify whether the name must be exact, case-sensitive, or a full path.

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 identifies the resource as the dimensions of a cube and notes they are ordered, which conveys the return content. It is brief and lacks an explicit verb like 'retrieves' or 'returns,' but the tool name makes the action clear. The phrase distinguishes this from sibling tools like tm1_list_dimensions by scoping to a specific cube.

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 tm1_list_dimensions or tm1_get_cube_rules. It does not mention prerequisites, typical scenarios, or exclusions. Any usage context must be inferred entirely from the tool name and parameter.

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

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

With no annotations, the description carries the behavioral disclosure burden. It clearly states the return shape (rows, columns, values, updateable) and the write-tuple mapping, which tells an agent that this is a read-oriented grid builder for writeback workflows. It does not cover permissions, errors, or size limits, but those are secondary for a get-style tool.

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

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

The description is a single front-loaded sentence with no filler. It states the action, purpose, and return contract efficiently, making every word earn 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 8 parameters, 5 required, no output schema, and no annotations, this description is too thin. It gives a strong high-level purpose but leaves parameter semantics, valid combinations, and required context behavior unexplained, so an agent would still need to infer how to construct a correct call.

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 compensate by explaining the parameters. While names like cubeName, rowDimension, and colElements are somewhat self-explanatory, the important 'context' parameter and hierarchy-related fields remain semantically opaque.

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

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

The description uses a specific verb and resource: 'Build a rows × columns value grid' for an editable data-entry table. It also distinguishes itself from sibling read/list tools by emphasizing the 'updateable' flag and mapping cells back to a write tuple.

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 an editable data-entry table' gives a clear intended use context, signaling this is the right tool when a writeback grid is needed. It does not explicitly name alternatives or state when-not-to-use conditions, so it falls just short of full routing guidance.

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

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

No annotations are provided, so the description carries the full burden for behavioral disclosure. However, 'Rules text of a cube' is only a noun phrase and does not state that this is a read-only retrieval, what it returns, or any failure or edge-case behavior. It does not contradict annotations, but it discloses no behavioral traits.

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

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

The description is extremely short, which is concise, but it is under-specified rather than efficiently structured. It lacks a complete sentence that states the action and connects the parameter to the operation, so the brevity does not earn its place.

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

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

The tool is simple, with one parameter and no output schema, so the missing context is not catastrophic. However, with no annotations, no usage guidance, and no explicit behavioral or return-value description, the agent is left to infer the operation and outcome. This is below the minimum needed for confident independent 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 one required parameter, cubeName, with 0% schema description coverage. The description's 'of a cube' hints that cubeName identifies the cube whose rules are retrieved, but it does not explain the parameter's role or any restrictions beyond the name itself. This is minimal compensation for the missing schema descriptions.

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

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

The description identifies the resource precisely as 'Rules text of a cube', and the tool name supplies the 'get' action. This distinguishes it from siblings like tm1_get_cube_dimensions and tm1_get_process_code, but the description itself lacks an explicit verb, so it does not fully state the action on its own.

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, no mention of prerequisites, and no indication of situations where another sibling like tm1_execute_mdx or tm1_get_cube_grid would be more appropriate. The agent must infer usage purely from the name and resource phrase.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the return value ('Full source') but does not disclose the output format, potential errors, read-only nature, or any other behavioral traits. The tool name implies retrieval, but the description adds little beyond 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?

The description is a single concise phrase with no wasted words. It is immediately understandable and front-loaded. It could be slightly more informative, but it earns a high score for efficiency.

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

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

This is a simple one-parameter tool with no output schema and no annotations, yet the description is too sparse. It does not specify what 'full source' includes, what the return type is, or any usage context. An agent can infer the basic call but lacks important operational details.

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

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

Schema description coverage is 0% and the description does not explain the processName parameter. It only identifies the resource as 'a TI process', which adds minimal meaning beyond the parameter name. The description fails to compensate for the schema's lack of parameter documentation.

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

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

The description clearly states the tool returns the full source code of a TI process, which is a specific resource and output. It lacks an explicit verb, but the intent is unambiguous. It doesn't explicitly contrast with siblings like tm1_list_processes, but 'source' is distinct enough to differentiate.

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. The description does not mention that this is for retrieving process code as opposed to listing process metadata, nor does it provide any context for when an agent should select it.

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

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

With no annotations provided, the description carries the behavioral transparency burden. 'Static' hints that the data is non-changing and likely read-only, but the description does not disclose output format, error behavior, permissions, or whether any special context is needed. The hint is useful but minimal.

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

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

The description is extremely concise—three words, no filler, and the key qualifier 'static' is front-loaded. For a zero-parameter, single-purpose server information tool, this level of conciseness is appropriate.

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 and parameterless, so the description is adequate for invoking it correctly. However, with no output schema and no annotations, the description is thin on what the returned configuration actually contains, which leaves an agent without enough context to interpret results 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?

The tool has zero parameters, so there is no parameter semantics to document. The baseline for zero-parameter tools is 4, and the description does not need to compensate for undocumented 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 names the resource ('server configuration') and qualifies it as 'static', which, combined with the tool name, makes the operation reasonably clear. It is distinguishable from sibling tools that target cubes, dimensions, processes, views, and other model objects, though it is expressed as a noun phrase rather than an explicit action statement.

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

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

The description implies the tool is for retrieving static server configuration information, which gives some usage context. However, it does not explicitly state when to use it over sibling list/get tools, nor does it mention any exclusions or fallback 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure, but it discloses nothing beyond 'List cubes.' It does not state whether control cubes are included by default, what the output looks like, whether pagination exists, or any side effects/safety characteristics.

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

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

The description is extremely short, but this is under-specification rather than effective conciseness. It contains no information beyond what the tool name already conveys and therefore does not earn its place in the definition.

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 optional parameter, no output schema, and no annotations, the description should at least clarify what the returned cube list contains and how includeControl affects it. 'List cubes' leaves too many basic call-time questions unanswered.

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 only parameter, includeControl, has no description in the schema and schema coverage is 0%, so the description needed to explain it; it does not. The parameter name is mildly self-explanatory and optional, which keeps this above the lowest score, but the agent receives no real 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 states the action and resource ('List cubes'), so a caller can tell it is a listing operation for cubes. However, it essentially restates the tool name and provides no scope, return-format, or filtering details, so it does not reach the level of a well-specified purpose.

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

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

There is no guidance about when to use this tool versus siblings like tm1_list_dimensions or tm1_list_views beyond the object type in the name. No mention of the optional includeControl parameter or any exclusions, so an agent cannot decide confidently between alternatives from the description alone.

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

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

With no annotations, the description must carry the behavioral transparency burden. 'List' signals a read-only retrieval operation, and 'capped' discloses a limiting behavior, which adds useful context. It does not explain the default cap, whether the limit parameter is required, or what the returned element data looks like.

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

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

The description is a single front-loaded sentence with no redundant schema text or filler; every word earns its place. It is scannable and appropriately minimal, though its brevity contributes to the completeness gaps seen in other dimensions.

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

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

Given no annotations, no output schema, and 0% schema-description coverage, the description needs to supply substantially more context than it does. It omits return format, default limit behavior, the role of the optional hierarchyName parameter, and any error or permission considerations, leaving the agent poorly equipped to call this 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 compensate, but it only loosely maps to the parameters: 'dimension hierarchy' hints at dimensionName and hierarchyName, while 'capped' hints at limit. It leaves requiredness, types, defaults, and the exact cap behavior unspecified, which is not enough for an agent invoking this tool with confidence.

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 identifies a specific operation—listing elements—and names the resource ('dimension hierarchy'), which is precise and matches the tool name. It differentiates by resource type from siblings like tm1_list_dimensions and tm1_list_hierarchies, though it does not explicitly call out those siblings.

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

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

The phrase 'elements of a dimension hierarchy' implies this tool is for retrieving dimension elements, and the sibling list tools suggest the broader category. However, there is no explicit guidance about when to prefer this tool over alternatives such as tm1_list_subsets or tm1_get_cube_dimensions, and no exclusions or prerequisite conditions are given.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only restates the operation and gives no information about output shape, pagination, permissions, or whether control dimensions are included. The read-only nature is inferable from 'list', but no deeper behavioral context is provided.

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

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

The description is extremely short and front-loaded, but it is under-specified rather than appropriately concise. The two words merely restate the tool name and omit essential 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?

For a tool with no output schema, no annotations, and an undocumented boolean parameter, the description is too sparse to fully guide selection and invocation. It does not clarify whether this returns all dimensions on the server or supports filtering, nor how includeControl should be set.

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 only parameter, includeControl, is not mentioned or explained in the description, and schema description coverage is 0%. The property name suggests its meaning, but the description contributes nothing beyond the input 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 and resource, 'List dimensions', and is immediately understandable as an enumeration action. However, it does not distinguish this tool from sibling tm1_get_cube_dimensions, which also lists dimensions within a cube.

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 call this tool versus alternatives like tm1_get_cube_dimensions, tm1_list_cubes, or tm1_list_views. There are no exclusion criteria or context signals to help an agent choose this tool over its 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?

There are no annotations, so the description carries the full behavioral disclosure burden. It only says 'List,' which implies read-only behavior, but it does not mention output format, pagination, ordering, error behavior, or anything beyond the action already captured by the tool name.

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 with no filler, and the key action and target are front-loaded. Every word contributes to the meaning.

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

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

This is a simple one-parameter listing tool, and the description gives enough to understand its basic purpose and required argument. However, without annotations or an output schema, it would benefit from a note on what is returned or any failure conditions.

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

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

With one parameter and 0% schema description coverage, the description adds minimal semantic value by linking 'dimension' in the text to dimensionName. It does not explain the expected format, examples, or edge cases, but the single parameter is simple and largely self-explanatory.

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

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

The description uses a specific verb and resource: 'List hierarchies of a dimension.' It clearly states what the tool does and the target resource, though it does not explicitly differentiate itself from sibling listing 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 phrase 'of a dimension' implies the tool is used when the caller needs hierarchies for a specific, named dimension. However, it does not state when to choose this tool over similar listing tools or provide any exclusions.

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

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

With no annotations, the description carries the full behavioral disclosure burden. The verb 'list' reasonably implies a read-only operation, but the description does not explicitly state that there are no side effects, what the return payload contains, or whether control processes are included by default.

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

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

The description is a single efficient sentence with no filler or redundancy. The verb and object are front-loaded, so an agent can immediately grasp the purpose.

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

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

Given no output schema, no annotations, and an undocumented optional parameter, the description is too sparse for fully informed invocation. An agent can call the tool with no arguments, but it cannot reason about includeControl or the expected return format.

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 no description for includeControl (0% coverage), and the tool description does not mention or explain it. The parameter name is somewhat self-explanatory, but the description adds no semantic value to compensate for the missing schema documentation.

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

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

The description names a specific action ('List') and resource ('TI processes'), making it immediately clear what the tool does. It also distinguishes this tool from sibling list tools for views, cubes, and dimensions.

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 prefer this tool over alternatives, nor does it mention related tools like tm1_get_process_code. The agent is left to infer usage context solely from the tool name and the one-line 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. 'List' implies a read-only operation, but the description does not mention output format, whether private and public subsets are included, or how the optional hierarchyName affects behavior. Minimal behavioral context is provided.

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

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

The description is a single efficient sentence with no wasted words. It is front-loaded and readable, though its brevity contributes to the lack of completeness in other dimensions.

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 two parameters and no annotations or output schema, the description is too thin. It names the primary resource and dimension, but leaves the optional hierarchy parameter and result behavior unexplained. An agent could make basic assumptions but would lack critical context for correct invocation in edge 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%, and the description only implicitly maps to dimensionName via 'of a dimension.' The optional hierarchyName parameter is completely unexplained, including whether it filters results to a specific hierarchy. The description adds little meaning beyond the parameter names themselves.

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: 'List subsets of a dimension.' It is immediately distinguishable from sibling tools that list views, cubes, dimensions, processes, or elements. However, it does not clarify scope (e.g., all subsets, public/private, or subsets for a specific hierarchy), which keeps it from being fully precise.

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

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

There is no guidance about when to use this tool versus alternatives such as tm1_list_hierarchies or tm1_list_dimension_elements. No context is provided for when listing subsets is appropriate or how it differs from related list operations.

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

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

With no annotations provided, the description carries the full behavioral burden. 'List views' effectively signals a read-only operation and identifies what is returned, but it does not disclose output structure, pagination, or whether private and public views are included. This is adequate but minimal.

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

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

The description is five words and contains no filler. The core purpose is front-loaded and easy to scan, making it highly efficient for an agent evaluating it.

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 list tool, this description is nearly sufficient, but the absence of annotations and an output schema leaves the agent to assume the return shape and view scope. It covers the essential invocation but skips details that would make it fully self-contained.

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 parameter, cubeName, with no description. The description's 'on a cube' provides some context linking the parameter to the operation, but it does not explain the parameter's format or expected values. The parameter is self-explanatory, so this is acceptable but not enriching.

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 action ('List') and resource ('views') scoped to a cube, so an agent can tell what the tool operates on. It does not explicitly distinguish itself from sibling tools, but the resource type is distinct enough to avoid confusion with list_cubes, list_dimensions, or list_hierarchies.

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 'on a cube' implies when the tool should be used: when the user wants the views associated with a specific cube. However, there is no explicit guidance about alternatives or when not to use it, leaving the usage context only implied.

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