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

With no annotations, the description must disclose behavioral traits. It only states the action ('activate/focus') without explaining effects (e.g., whether the field becomes interactive, whether session state is required, or any side effects). No details on session_id or search_by_title behavior are 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, front-loaded sentence with no filler. It is appropriately concise for a simple tool, though it sacrifices detail for brevity. It earns a high score for structure but not for completeness.

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

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

Given the tool's simplicity and lack of output schema, the description should clarify usage semantics, especially for session_id and search_by_title. It also doesn't explain what 'activate' means operationally. This leaves gaps an agent would need to resolve experimentally.

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

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

Schema description coverage is 0%, so the description must explain parameters. It partially covers field_name and search_by_title ('by name or title') but omits session_id entirely and doesn't clarify the default behavior of search_by_title or how field_name is resolved. This is insufficient for the 3 parameters.

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

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

The description clearly states a specific verb ('activate/focus') and resource ('form field'), and hints at the lookup method ('by name or title'). It is distinguishable from siblings like focus_object (which targets generic objects) and set_field_value (which sets values), though it doesn't explicitly name 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 explicit when-to-use or when-not-to-use guidance is given. The description implies it's for focusing form fields but doesn't contrast with other focus tools like focus_object or toggle_field. An agent would have to infer the right context without clear direction.

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 burden of behavioral disclosure, but it only restates the operation itself. It does not explain what happens when no window matches, how multiple criteria are resolved, whether it waits for the window, or what error behavior to expect.

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

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

The description is a single, front-loaded sentence with no filler. It efficiently communicates the action and the primary selection mechanisms, even though other dimensions carry the cost of its brevity.

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

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

For a tool with four undocumented parameters, no output schema, and no annotations, this description is not complete enough to support confident invocation. An agent would still need to infer parameter precedence, failure behavior, session scoping, and when to choose a sibling window-related tool instead.

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 names three of four parameters as selector modes. It does not clarify precedence or combination of name, title, and index, and it silently omits session_id and its role in targeting the window.

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 ('Activate/switch to') and the resource ('tested 1C client window'), and specifies that selection is by index, title, or name. It is distinguishable from nearby siblings like active_window, windows_list, and goto_next_window, though it does not explicitly contrast with them.

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

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

The description implies when to use the tool: when a 1C client window needs to be brought forward. However, it provides no explicit when-not guidance, no alternative tool names, and no suggestions like 'use active_window to read the current window' or 'use windows_list to find an index.'

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 burden of behavioral disclosure. The verb 'Return' implies a read-only query, but the description does not disclose whether the tool blocks, errors when no active window exists, or what side effects if any it has. Minimal behavioral information 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, concise, front-loaded sentence with no filler. Every word contributes to the core meaning, and it is appropriately sized for the tool's simple apparent 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 that there is no output schema, no annotations, and only a vague 'window state' phrase, the description is not complete enough for an agent to know what the returned state contains, what the expected format is, or how to interpret edge cases such as no active window. The tool's position among many window-related siblings amplifies the need for 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 0%, and the description does not mention session_id at all. The only parameter is optional and has a default, and its name is somewhat self-explanatory, but the description adds no meaning about why a session is needed, how the session ID relates to the active window, or what value formats are valid.

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 is a specific verb+resource phrase: 'Return active 1C test client window state.' It clearly identifies a query operation for the active window consistent with the tool's name Mend can be distinguished from siblings like windows_list (listing windows) and activate_window (changing the active window). However, 'state' is somewhat vague, as it does not define what aspects of the window state are returned.

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 alternatives such as windows_list, activate_window, wait_window, or current_element. The intended use is only implicit from the name and phrase 'active window state,' but there are no explicit conditions or exclusions to help an agent choose correctly.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure, but it only restates the action. It does not disclose what 'choose' does mechanically, whether it waits for a dialog, how it behaves if no row is current, or what side effects occur. The expected_text parameter hints at verification behavior that is never explained.

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

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

The description is a single efficient sentence with the action front-loaded and no wasted words. It is concise, though the brevity comes partly from under-specification rather than from trimming excess.

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 3 parameters, no output schema, no annotations, and 0% schema coverage, a one-sentence description is insufficient. An agent cannot determine what form to target, what expected_text is for, what a successful invocation looks like, or what conditions must hold before calling it.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented parameters, and it does not. Neither name, session_id, nor expected_text is explained; the description adds no meaning beyond the parameter names and defaults already present in 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 states a recognizable verb ('Choose') and a specific resource ('the current row in the active selection/list form'), so an agent can grasp the core operation. However, it does not distinguish this from siblings such as choose_field_first_row or table_choose_field_from_list, and 'choose' is ambiguous between selecting and confirming a row.

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

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

No guidance is given about when to use this tool versus alternatives. The description does not mention prerequisites (e.g., a selection dialog must be active), conditions, or exclusion cases, leaving the agent to guess when this is the right call among many row-related 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It describes the action of opening a form and pressing a button, but omits any side effects, whether it is a read or write operation, or what happens after the button press. This is minimal disclosure.

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

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

The description is a single sentence, which is short, but it is under-specified rather than concise. It lacks essential details about parameters and usage, making it too thin to be effective.

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

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

Given three parameters, no annotations, and no output schema, the description is extremely incomplete. An agent would not know what field_name refers to, what session_id represents, or how search_by_title affects behavior, making it nearly impossible to call correctly.

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

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

Schema description coverage is 0%, meaning the description provides no explanation of any parameters. The field_name, session_id, and search_by_title parameters are not described at all, leaving their purpose and expected values entirely ambiguous.

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: opening a reference selection form and pressing its standard Choose button. It names the verb and resource, but it doesn't explicitly differentiate from sibling tools like choose_field_from_list or choose_current_row, which might perform similar selection actions.

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 tells what the tool does but offers no guidance on when to use it versus alternatives. It doesn't mention prerequisites, such as an active form, or when a different tool like choose_field_from_list would be more appropriate.

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

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

With no annotations provided, the description carries the full burden of disclosure, but it only says 'open' and gives no indication of side effects, return behavior, waiting semantics, or whether the field value is affected. The operational impact on the session or form is not explained.

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

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

The description is a single efficient sentence with no fluff or repetition. However, its brevity comes at the cost of missing parameter and usage context, so it is concise without being informative.

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 three undocumented parameters, no annotations, and no output schema, this description is insufficiently complete. It provides no information about how the selection form is opened, which session is used, or what the agent should do after invoking it.

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

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

Schema description coverage is 0%, and the description adds no meaning to field_name, session_id, or search_by_title. An agent is left without any explanation of how to supply these parameters or what search_by_title controls.

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 a specific verb and resource: it opens the standard selection form for a reference field. This distinguishes it from generic field operations, though it does not explicitly contrast it with similar sibling tools like table_choose_field_from_list.

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

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

There is no guidance about when to use this tool versus alternatives, nor any mention of prerequisites such as an active form or a valid field_name. The context in which selection form opening is appropriate or inappropriate is left entirely unstated.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only says 'clear' without explaining side effects, such as whether it clears results for the specified session only, whether it is destructive to other state, or what happens to the queue. This is insufficient for a mutation 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 a single sentence and is concise, but it is under-specified rather than efficiently worded. It lacks essential context, so the brevity does not serve the agent well.

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 tool with one parameter and no annotations, the description still fails to explain the relationship with set_file_dialog_result, the meaning of 'queued', or the effect on the session. An agent cannot fully understand when or how to use 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?

The schema provides no description for the session_id parameter (0% coverage), and the description does not explain its meaning or how it relates to the queued results. The agent has no guidance on what value to pass or why it matters.

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 (clear) and the target (queued file selection dialog results), and implicitly distinguishes itself from the sibling tool set_file_dialog_result by being the inverse operation. The verb-resource pair is specific and unambiguous.

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

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

No guidance is provided on when to invoke this tool versus the sibling set_file_dialog_result, nor are any prerequisites or typical workflows mentioned. The agent must infer usage 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?

With no annotations provided, the description must disclose behavioral traits itself, but it only says 'find' and 'press it.' It does not explain whether the tool waits for the button, how watchdog_timeout affects behavior, whether a failed search throws an error, or what side effects pressing the button may have.

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 unnecessary words. It is efficient, though the brevity comes at the cost of useful detail.

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

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

For a tool with four parameters, no annotations, and no output schema, this description is too sparse. It omits parameter semantics, timing behavior, search behavior, and typical use context, leaving an agent underinformed for reliable invocation.

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

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

Schema description coverage is 0%, and the description adds no meaning for any of the four parameters. The 'name' parameter is self-evident from the schema, but 'search_by_title' and especially 'watchdog_timeout' receive no explanation, leaving the agent without necessary context to set them correctly.

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

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

The description clearly states a specific verb ('find' and 'press') with a resource ('button in the active UI tree'), so an agent can infer the action of clicking a button. However, it does not differentiate this from sibling tools like find_object, focus_object, or decoration_click, which may overlap in 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?

No guidance is given about when to use this tool versus alternatives such as find_object, click_link, or field interactions. There is no mention of exclusions, prerequisites, or conditions that would make this tool the right choice.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool checks responsiveness and blocking but does not mention whether it is read-only, what it returns, whether it waits, or any side effects. This is insufficient for an agent to understand the tool's full behavior.

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

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

The description is a single sentence with no wasted words, making it very concise. However, it is so terse that it sacrifices necessary detail. It is structured as a straightforward statement but lacks any breakdown of parameters or usage scenarios.

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

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

For a tool with no output schema and minimal description, the definition is incomplete. It does not explain the return format, how to interpret the status, or when to prefer this over siblings like wait_client_idle. The two parameters are undocumented, and no behavioral or usage context is provided.

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 two parameters (session_id and probe_timeout) with 0% description coverage, and the tool description does not mention them at all. No meaning, format, or expected values are provided, leaving the agent without any guidance on how to use these parameters.

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

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

The description clearly states the tool checks two specific conditions: whether the 1C client/bridge is responsive and whether a dangerous action is blocking the interface. It uses a specific verb 'Check' and names the exact resource, distinguishing it from siblings like wait_client_idle which implies waiting rather than checking.

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 what the tool does but provides no guidance on when to use it versus alternatives such as wait_client_idle or session_status. There are no explicit conditions for when this tool is preferred, nor any exclusions. The context of checking status is implied, but not enough to route an agent correctly.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It states the action but does not mention side effects such as unsaved data loss, whether a confirmation is needed, or whether the close is asynchronous. This is a significant gap for a mutating 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 extremely concise: four words with no filler. Every word carries meaning and the action is front-loaded, though the brevity contributes to the lack of behavioral 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?

Given no output schema and no annotations, the description should explain return behavior, side effects, and parameter meaning. It does none of this, making it incomplete for an autonomous agent choosing among many sibling form-management 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 input schema has one parameter, session_id, with 0% description coverage. The description does not mention or explain session_id at all, so it adds no meaning beyond the schema field name and default value.

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: 'Close the active form.' It is clear and unambiguous about the core action, though it does not explicitly differentiate itself from sibling form-related tools like save_form or wait_form_closed.

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, no prerequisites, and no exclusions. It only states what the tool does, leaving the agent to infer the appropriate context.

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

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

No annotations are provided, so the description carries the full burden of behavior disclosure. It only states the action itself, without explaining side effects, failure behavior when the panel is not open, idempotency, or the role of session_id. Beyond the verb 'Close', there is little transparency.

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

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

The description is a single, front-loaded sentence with zero filler. It states the action and target immediately, making it highly scannable and efficient for agents.

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 tool, the description covers the core purpose but omits critical context: what session_id means, whether the panel must be open, and what happens on failure. With no annotations and no output schema, an agent gets barely enough information to invoke it correctly.

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

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

Schema description coverage is 0% and the description never mentions session_id. The agent only sees a parameter titled 'Session Id' with a default in the schema, but no explanation of what it references or how it interacts with the 'active test-client window'. The description adds no value to parameter understanding.

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 ('Close'), identifies the exact resource ('user messages panel'), and scopes it to the active test-client window. This clearly distinguishes it from sibling tools like close_form and field_dropdown_close, leaving no ambiguity about what it operates on.

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

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

The description implies when to use it (whenever you need to close the user messages panel), but it does not explicitly mention alternatives, prerequisites, or when not to use it. There is no routing guidance to other tools, though the verb and resource are self-explanatory for this narrow action.

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

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

No annotations are provided, so the description carries the burden. It characterizes the tool as a 'low-level diagnostic' and says data is returned 'when available', which signals that results may be empty and that the call is read-oriented. It does not describe side effects, failure modes, or what 'available' means, but the diagnostic framing covers the core safety expectation.

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

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

The description is two sentences long and front-loads the primary purpose in the first sentence. The second sentence earns its place by routing to alternatives. There is no filler, repetition, or unnecessary detail.

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

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

The description covers purpose and usage routing, which lets an agent decide when to call it. However, with no output schema and no parameter explanation, an agent is left to guess at the return shape and the effect of include_timings. For a low-level diagnostic tool this is a notable but not fatal gap.

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

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

The input schema has 0% description coverage and the description never mentions session_id or include_timings. Neither the text nor the schema explains how these parameters affect the result or what values are expected beyond the titles and defaults. The description therefore adds no meaning beyond the structured 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 opens with a specific verb and resource: 'return active window/form command-bar data'. It labels the tool as a 'low-level diagnostic', and the second sentence names sibling tools (command_interface_*, object_command_panel) to distinguish this tool's scope. This clearly identifies what the tool does and how it differs from nearby 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 second sentence explicitly instructs the agent to prefer command_interface_sections/commands/search for application navigation commands, and object_command_panel/object_context_menu for commands of a specific UI object. This provides clear when-to-use alternatives for the two main competing use cases. It implies this tool is for low-level diagnostic command-bar data only, which is sufficient 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 present, so the description must carry the behavioral disclosure burden. It states the tool returns a command tree and flattened list, but does not disclose whether this is a read-only operation, what the output structure looks like (e.g., nested objects vs. flat array), or any side effects. It lacks depth about ordering, filtering behavior, or if it reflects current session state.

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

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

The description is a single sentence, concise and front-loaded with the main purpose. It wastes no words and clearly states the core functionality and optional filter. It is appropriately sized for the tool's simplicity, though it could have added more behavioral detail without becoming verbose.

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

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

Given the lack of output schema and annotations, the description is somewhat minimal. It captures the main output (tree and flattened list) and the optional section filter, but misses clarification on the relationship to sibling commands, the meaning of the three parameters, and return format. For a tool that appears relatively simple, it is adequate but not complete; an agent could call it without critical errors, but might misjudge its scope.

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

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

Schema coverage is 0% and no parameter descriptions are provided, so the description must compensate. It mentions 'optionally filtered by section,' which gives meaning to the 'section' parameter, but does not explain 'session_id' or 'window_title.' However, given the tool context, session_id and window_title are likely common across many tools, and the description provides partial compensation for the undocumented parameters.

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

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

The description clearly states it returns the command-interface command tree and flattened list, with optional section filtering. This distinguishes it from sibling tools like command_interface_sections and command_interface_search which likely return different subsets or perform searches. It is specific enough for an agent to understand the resource and action.

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 does not explicitly state when to use this tool versus alternatives. Sibling tools like command_interface_sections and command_interface_search exist, but no guidance is given on when to prefer this tool. The optional section filter is mentioned, but no context on typical use cases or when the flattened list is needed vs. other views.

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 burden of behavioral disclosure. It only states what is searched, not whether the operation is read-only, how matching behaves, whether results are ordered, or what happens with no matches. A search tool should disclose at least basic search semantics and result 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?

The description is a single sentence with no filler and puts the core action and search fields first. It is appropriately concise, though it sacrifices needed detail.

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

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

For a six-parameter tool with no annotationsyb and no output schema, the one-sentence description is substantially incomplete. It does not explain the role of session_id/window_title, the effects of max_results, the meaning of include_timings, or what the search returns. An agent would need to guess at most invocation details.

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

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

Schema description coverage is 0%, so the description must compensate. It adds meaning to the query parameter by mentioning title, path, and navigation URL, but it leaves five of six parameters (section, session_id, max_results, window_title, include_timings) completely unexplained. The agent cannot reliably know how session_id and window_title scope the search or what include_timings controls.

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 ('Search') with a clear resource ('live command-interface commands') and narrows the search scope to 'title, path or navigation URL.' It is understandable on its own, though it does not explicitly contrast with siblings like command_interface_commands or command_interface_sections.

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 command_interface_commands or window_command_interface. The description implies a search use case but provides no context about when searching is preferable to listing or browsing commands.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It indicates a read operation but does not state whether it is non-destructive, requires an active window, or has side effects. The term 'top-level sections' is undefined, leaving the agent to infer what is returned.

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

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

The description is a single, concise sentence that front-loads the core action. However, it is under-specified, lacking critical details; conciseness does not compensate for missing information.

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

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

Given the absence of annotations, output schema, and parameter descriptions, the description is severely incomplete. It does not explain the return format, the meaning of 'sections,' or how the parameters affect the result, making it insufficient for correct tool invocation.

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

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

Schema description coverage is 0%, and the description provides no explanation of the two parameters (session_id and window_title). It does not compensate for the schema's lack of descriptions, leaving the agent with no guidance on how to set these parameters.

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

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

The description clearly states the action ('Return') and the resource ('top-level sections of the active window command interface'). It is specific enough to identify the tool's purpose, though it does not differentiate it from siblings like command_interface_commands or window_command_interface.

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 its siblings. The description implies it is for retrieving sections but gives no context on prerequisites (e.g., an active window) or when other tools would be more appropriate.

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

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

With no annotations, the description carries the full burden. It does disclose a useful behavioral detail: it reads the register via the list output command so hidden columns like 'Это основная конфигурация' are available. However, it does not state whether the operation has UI side effects, whether it is strictly read-only, or what happens with caching/refresh.

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

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

The description is concise and front-loaded: the first sentence states the action and result, the second explains the non-obvious implementation choice. No filler or repetition.

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 core read behavior and there is an output schema for return values, but it omits parameter semantics and usage context. For a simple read tool this is adequate but not complete.

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

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

Schema description coverage is 0%, and the description adds no meaning for session_id or refresh_cache. The agent must infer their roles from parameter names and defaults alone, which is insufficient when the description is the main source of 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 clearly states the tool's function with a specific verb ('Open ... and return') and resource ('Subsystem versions' information register, РегистрСведений.ВерсииПодсистем). It identifies the output as the main configuration name/version, but it does not explicitly contrast this with sibling tools, so it falls short of full sibling differentiation.

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

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

No guidance is given about when to use this tool instead of alternatives, nor are any exclusions or prerequisites mentioned. The intended use is only implied by the description's purpose statement.

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 explains the exact algorithm (UUID reordering), gives an example, and states the transformation is reversible ('and back'). This gives an agent confidence in the deterministic, side-effect-free nature of the operation. However, it does not mention error handling for invalid inputs or the behavior when direction is 'auto', which would be useful.

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

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

The description is concise and well-structured: it starts with the purpose, then provides the algorithm, and finishes with a concrete example. Every sentence earns its place, and the example is particularly valuable for understanding the transformation. No wasted words.

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

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

Given the complexity of the tool (3 parameters, bidirectional conversion, metadata handling), the description is incomplete. It covers the core algorithm but leaves parameter semantics unexplained. Since an output schema exists, return values are presumably covered there, but the agent still needs to know how to set direction and metadata_name. Edge cases and error behavior are also absent.

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

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

Schema coverage is 0%, meaning the description must explain all three parameters: value, direction, and metadata_name. The description only indirectly references 'value' through the example, but never explains what 'direction' (auto/forward/backward) means or what 'metadata_name' is used for. This is a significant omission because an agent cannot correctly choose direction or fill metadata_name based on the description alone.

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 conversion operation: converting 1C object reference GUIDs to e1cib/data navigation links and back. It clearly identifies the resource (1C GUIDs) and the transformation, distinguishing it from any sibling tool that might handle navigation links directly (e.g., open_navigation_link). The example solidifies the 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?

The description clearly implies when to use this tool (when converting between GUIDs and navigation links) and gives an example that demonstrates its use. There are no obvious sibling alternatives for this conversion, so explicit 'when not to use' guidance is not critical. However, it does not explicitly state that this is a pure utility and should be used only for conversion, not for opening links, which is a minor gap.

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

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

With no annotations, the description carries the burden of behavioral disclosure. It explicitly states that secrets are not returned, which is a relevant behavioral guarantee派驻. However, it does not explicitly confirm that the operation is read-only or describe any other side effects, though 'check' strongly implies a non-mutating 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 a single, front-loaded sentence that directly communicates the tool's purpose and its key security-relevant behavior. There is no filler or redundant restating of the tool name, and every word contributes 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?

Despite the low parameter count and presence of an output schema, the description is incomplete because it fails to explain how the lone base_url parameter relates to the 'saved title' lookup mentioned in the description. An agent cannot confidently determine how to invoke this tool for all declared scenarios, so the definition is not 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?

Schema description coverage is 0%, so the description must explain the base_url parameter, but it does not clarify whether the parameter accepts a base URL, a saved title, or both. The phrase 'base URL or saved title' suggests the single parameter may serve two purposes, but no format or precedence is documented, leaving meaningful ambiguity.

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

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

The description clearly states a specific verb ('check whether credentials exist') and resource ('credentials'), and explicitly distinguishes itself from credential-retrieval tools by noting it returns no secrets. However, the phrase 'or saved title' introduces a second lookup mode that is not reflected in the schema, which slightly blurs the tool's exact scope.

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 should be used when you need to verify existence rather than retrieve secret values, but it does not explicitly mention any sibling alternatives such as credentials_list or credentials_titles. No when-to-use or when-not-to-use guidance is provided beyond the general purpose.

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

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

With no annotations, the description carries the full burden. It explicitly states that the tool does NOT return usernames or passwords, which is a key behavioral trait and adds clarity beyond a generic 'list' action. It also implies a read-only operation through 'List'. While it doesn't detail return format or error handling, it sufficiently discloses the non-sensitive nature of the output.

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

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

The description is a single, efficient sentence that front-loads the action ('List') and the resource ('configured credential URL patterns/titles'). Every word adds value, and the exclusion of sensitive data is a concise, important qualifier. No fluff or repetition.

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 parameterless list tool with an output schema, the description is complete. It specifies what is returned (URL patterns/titles) and what is excluded (usernames/passwords). The existence of an output schema covers the return structure, so no further detail is necessary. The low complexity makes this sufficient.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to add parameter semantics because there are none. It correctly focuses on what the tool returns rather than 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 clearly states the tool lists configured credential URL patterns/titles, using a specific verb and resource. It also explicitly excludes usernames and passwords, distinguishing it from potential credential-related tools. This makes its purpose unambiguous and distinct from siblings like credentials_check or credentials_save.

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

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

The description implies usage: if you need to list credential URL patterns/titles, use this tool. However, it does not explicitly name alternatives or provide conditions for when not to use it, especially given the existence of a similar sibling 'credentials_titles'. The exclusion of usernames/passwords hints that other tools handle those, but it's left to inference.

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

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

With no annotations, the description alone must carry behavioral disclosure. It does disclose the destructive operation and the exact-URL matching rule, but it does not state what happens when no matching credential exists, whether removal is permanent, or any error/edge-case behavior.

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

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

The description is a single, front-loaded sentence with no filler. Every word contributes: remove, credential, local store, and exact URL match.

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 an output schema available, so the description provides enough context for correct invocation. The only notable gap is the lack of detail about the no-match case, but this is minor for a straightforward deletion operation.

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 only declares 'url' as a required string with no description, so the phrase 'by exact URL match' adds meaning that is not present in the schema. It tells the agent that partial or normalized URLs will not match, which is valuable for a single-parameter tool.

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

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

The description uses a specific action ('Remove'), a clear resource ('credential entry'), and a scope ('local store') with an exact-match constraint. This distinguishes it from sibling credentials_save, credentials_list, and credentials_check without needing any additional context.

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

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

The intended use is implied by the action and resource, so an agent can infer that this tool is for deleting stored credentials rather than saving or checking them. However, there is no explicit guidance about when to prefer this over alternatives, nor any mention of prerequisites or side effects.

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

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

With no annotations provided, the description carries the full burden. It discloses two useful behaviors: the credentials file is never committed to git, and entries are scoped to the current MCP account. However, it does not disclose overwrite/idempotency behavior, side effects on existing sessions, or any permission requirements. 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 four sentences, each providing distinct value: the primary action, git exclusion, intended integration with start_session, and account scoping. It is front-loaded with the purpose and contains no filler or redundancy.

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

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

For a 5-parameter tool with zero schema descriptions and no annotations, the description covers the core parameters and key behavioral constraints, but leaves two optional parameters unexplained and does not define what a 'URL pattern' constitutes. The output schema exists, which helps, but the missing parameter semantics and pattern ambiguity prevent it from being fully complete.

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

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

Schema description coverage is 0%, so the description must compensate entirely. It explains url as a 'URL pattern' and username/password as a 'login/password pair', covering three required parameters. But the optional parameters title and aliases are completely unmentioned, leaving an agent guessing about their meaning and format. This is a significant gap.

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-resource pair ('Save or update credentials') and adds scope ('for a URL pattern in the local credentials store'), which is far more than a restatement of the tool name. It semantically differentiates from siblings like credentials_remove, credentials_list, and credentials_check by making the write action explicit.

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

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

It gives clear context for when to use the tool: to persist login/password pairs for automatic pickup by start_session and to avoid exposing secrets in tool-call arguments. It does not explicitly name alternatives or state when not to use it, so it stops short of full exclusion 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?

With no annotations, the description must carry the behavioral burden. It discloses that the tool is a read-only listing operation and that it returns aliases/titles rather than full credential information. A zero-parameter listing tool implies no hidden side effects, though error/availability behavior is not elaborated.

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

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

One sentence, front-loaded with the action and resource, followed by a purpose clause. There is no filler, repetition of schema content, or unnecessary detail.

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

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

For a zero-parameter listing tool with an output schema, the description provides the essential context an agent needs: what is listed and how the result should be used. Nothing required to decide whether and when to invoke the tool 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 tool has zero parameters, so the input schema is fully complete and there is no parameter documentation burden on the description. The description adds semantic value by explaining that the returned titles are meaningful as start_session base_url values.

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 ('saved credential titles/aliases'), and immediately states their purpose as start_session base_url values. This clearly differentiates the tool from sibling credentials_list and credentials_check by framing the output as aliases usable for session startup.

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

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

The description gives a clear usage context: call this when you need credential titles/aliases to supply as start_session base_url. It does not explicitly mention when to prefer sibling tools like credentials_list or credentials_check, so it stops short of full when/when-not guidance.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only says 'return', implying a read operation, but never states what the response looks like, what happens when no element is active, or whether the tool waits for an element to become active.

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 is efficient, though the brevity comes at the cost of the missing behavioral and usage context noted 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?

With no output schema and no annotations, a one-sentence description is insufficient. An agent cannot know the return format, the null/empty behavior, or the precondition (e.g., a form must be open). For a getter tool this is a moderate gap; a bit more detail would fully equip the agent.

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

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

With 0% schema description coverage, the description must compensate for the undocumented session_id parameter, but it says nothing about it. The parameter is at least inferable from its title 'Session Id' and default value, so the gap is small, but the description adds zero semantic value 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 states a specific verb and resource: "Return the current active form element." This is clear and an agent can tell it is a read/getter tool. However, it does not differentiate itself from siblings like field_info, form_state, or active_window, which could overlap in the mind of an agent.

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

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

No guidance is given about when to use this tool versus alternatives. Siblings such as field_info, form_next_element, form_previous_element, and active_window exist, but the description offers no context for when 'the current active form element' is the right thing to fetch instead of those.

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

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

Annotations are absent, so the description carries the full burden. It states the tool returns error information, but does not disclose what happens when no error exists (e.g., returns null, empty string, or throws). It also does not mention any side effects or requirements, such as the role of session_id. The behavior is underspecified.

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

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

The description is a single, concise sentence with no extraneous words. It is front-loaded with the core action and resource. Efficiency is excellent, though it sacrifices necessary detail.

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

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

For a tool that returns error information with an optional parameter, the description is incomplete. It does not explain the format of the error information, what constitutes an error, or how session_id affects the result. Without an output schema, the agent has no idea what to expect. The description should clarify these aspects.

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 sole parameter session_id has zero schema description coverage, and the description does not mention it at all. The agent has no idea what session_id does, whether it is optional (though required=0 suggests it is), or what the default 'default-18' means. This is a critical gap.

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) and the resource (current 1C script error information) and the context (displayed in the tested client). It distinguishes from siblings like user_messages by focusing specifically on script errors, though it does not explicitly name an alternative.

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 user_messages or client_busy_status. The phrase 'if any' implies it handles absence of errors, but there is no explicit context, 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?

No annotations are present, so the description must carry the full behavioral disclosure burden. It describes only intent to click; it says nothing about whether the click is a synthetic UI event, whether it waits for rendering, whether it requires the decoration to be visible, or what happens on failure.

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 text is short, but brevity comes at the cost of all explanatory value. A single sentence does not earn conciseness credit because it omits parameter semantics and behavioral context rather than condensing them.

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 three undocumented optional parameters, no annotations, and no output schema, the description is too sparse for an agent to call the tool reliably. It provides no context for selecting decorations, no session scoping, and no expected outcome.

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 mention name, title, or session_id. The agent cannot determine what name/title select or whether session_id scopes the click, so the parameters carry no communicated semantics.

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

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

The description gives a recognizable action/resource pair: 'Click a form decoration.' However, 'decoration' is left as an unexplained domain term, and nothing in the text distinguishes this from the sibling decoration_click_link, so the precision needed to choose between them is absent.

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 call this tool, what form/context it applies to, or which sibling to use instead. The description provides only the action noun phrase, leaving all routing decisions 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?

With no annotations, the description must carry the full behavioral disclosure burden. It only states the action with no mention of side effects, required context (e.g., must a decoration be visible?), failure modes, or what happens on a successful click. The one-line description is nearly empty of behavioral detail.

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

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

The description is a single concise sentence with no filler, which earns a mid score. However, it is under-specified to the point of being unhelpful, so the brevity works against clarity rather than for 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 tool with 4 undocumented optional parameters, no output schema, and no annotations, the description is far too thin. The agent needs to know what the parameters refer to, what a 'formatted-string decoration' is, and what happens after the click, all of which are 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 schema has 4 parameters with 0% description coverage, and the tool description provides no parameter explanations. The agent cannot infer what 'name', 'title', 'session_id', or 'presentation' mean or how they relate to the hyperlink, leaving parameter usage entirely ambiguous.

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 ('Click') and a resource ('a hyperlink inside a formatted-string decoration'), which clearly distinguishes it from generic actions. However, it does not explicitly differentiate from the sibling tool 'decoration_click', which likely clicks the decoration itself; the phrase 'hyperlink inside' hints at the distinction but doesn't name the alternative.

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 like 'decoration_click' or 'decoration_links'. There is no mention of context, prerequisites, or fallback strategies, leaving the agent to infer usage 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It implies a read operation but doesn't explain what 'presentations' means, whether it returns a list, its format, or any side effects. Completely insufficient for a tool with zero annotation coverage.

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

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

The description is a single sentence, so it is concise, but it lacks structure and fails to front-load meaningful information. Being short is not a virtue when it omits essential details.

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 three parameters, no output schema, and no annotations, the description is drastically incomplete. It doesn't clarify the concept of a 'formatted-string decoration' or the structure of the returned hyperlink presentations, leaving the agent with no basis to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the three undocumented parameters (name, title, session_id). It provides no explanation of what these parameters control or how they affect the output, making it impossible for an agent to fill them correctly.

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 ('Return') and a specific resource ('hyperlink presentations from a formatted-string decoration'). It distinguishes itself from action-oriented siblings like decoration_click_link, though it doesn't explicitly name 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 on when to use this tool versus siblings like decoration_click_link or decoration_click. No context about typical scenarios or exclusions, leaving the agent to infer usage.

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

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

With no annotations available, the description must carry full behavioral disclosure. It states that filter/order/conditional formatting/grouping settings are cleared, but does not mention whether this is irreversible, whether it applies to the active dynamic list, or what side effects occur. For a destructive reset, this is a meaningful gap.

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

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

The description is a single focused sentence with the key operation front-loaded. The word 'Quickly' adds little, but it does not detract significantly from an otherwise compact 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 simple but destructive tool with no annotations and no output schema, the description should clarify scope, required context, and the role of 'button'. The current text is too thin for an agent to call this tool confidently in a real dynamic-list workflow.

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 either parameter. 'button' is particularly ambiguous, and 'session_id' is left without context, so the agent cannot determine what values are valid or what each parameter controls.

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 ('reset/clear') and resource ('dynamic-list filter/order/conditional formatting/grouping settings'), which clearly distinguishes it from sibling tools like dynamic_list_set_settings and dynamic_list_current_settings. There is no ambiguity about what operation is performed.

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 dynamic_list_set_settings, dynamic_list_open_settings, or dynamic_list_current_settings. It never states conditions, prerequisites, or exclusions, leaving the agent to infer context from the tool name alone.

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

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

With no annotations, the description carries the full burden. It clearly communicates a read-only purpose and explicitly warns against destructive replacement of settings. It does not describe the exact output shape or broader UI side effects, but it covers the main behavioral guardrail that an agent must know.

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. The remaining sentences each earn their place by disambiguating the sibling tool and giving safety guidance. Only minor redundancy could be trimmed, but the structure is strong.

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 is strong on scenario and behavioral context, but the tool has no output schema and no annotations, and close/session_id are left undefined. An agent could still invoke the tool based on the defaults, but cannot confidently predict the return value or side effects of the close flag.

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

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

Schema description coverage is 0%, so the description must compensate for the parameters. It mentions a 'section' in passing, but it does not explain the close boolean, the semantics of section values, or session_id. The parameter names alone are not enough for reliable invocation.

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

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

The description states a specific verb and resource: it opens the dynamic-list settings form and reads currently configured filter/order items. It also explicitly distinguishes the 'Доступные поля' table and references the sibling dynamic_list_settings_available_fields, making it easy to tell apart from related 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?

It gives explicit when-to-use guidance: use dynamic_list_settings_available_fields when fields that can be added are needed, and read current settings before changing them. It also warns not to clear or replace existing filters/orders unless explicitly required, which directly prevents misuse.

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

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

No annotations are provided, so the description carries the full burden. It references UI elements but does not disclose side effects, requirements, or the impact on state. There is no info on permissions, reversibility, or whether the search is read-only.

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

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

A single sentence that is concise but under-informative. It is not verbose, but it sacrifices substance. There is no structured presentation or emphasis on key details.

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

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

With 6 parameters, no output schema, no annotations, and a terse description, the tool is severely underdocumented. An agent cannot know what inputs to provide or what to expect in return.

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

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

Schema description coverage is 0% and the description does not explain any of the 6 parameters (name, text, field, title, session_id, compare_type). The agent has no guidance on how to populate these fields.

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 'Search' and resource 'dynamic list', and mentions two UI paths. It distinguishes from sibling tools that handle settings or metadata, though it does not clarify what a successful search returns or how it behaves.

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

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

No guidance on when to use this tool versus alternatives. Does not mention any exclusions or conditions. The description is purely functional without routing the agent to appropriate use cases.

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

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

With no annotations, the description carries the full burden. It does disclose that the result is RAG/metadata-known and not from the live UI form, which is useful. But it does not describe the return shape, side effects, or dependency on parameters like rag_snapshot, leaving some behavior implicit.

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

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

A single sentence with no filler. The core action is front-loaded, and the exclusion of the live UI form is a valuable clarification that earns its place.

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

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

The tool has three parameters, no annotations, and no output schema, so the description must do substantial work. It clarifies the source of fields but leaves parameter semantics and expected outputs unexplained, making it incomplete for reliable invocation.

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

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

Schema description coverage is 0%, so the description must compensate. It only indirectly maps 'metadata object' to the 'object' parameter, leaving 'session_id' and 'rag_snapshot' unexplained. This is insufficient for an agent to know how to populate the parameters correctly.

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

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

The description uses a specific verb ('Return') and names a clear resource ('RAG/metadata-known fields for a metadata object'). It also distinguishes itself from the live UI settings form, which separates it from sibling tools like dynamic_list_settings_available_fields.

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

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

The description explicitly states what this tool does not do ('does not inspect the live UI settings form'), giving a clear when-not-to-use signal. However, it does not explicitly name the alternative tool to use for live UI settings, so the guidance is slightly incomplete.

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 alone must disclose side effects and requirements. It reveals only that this is a UI action that opens a settings dialog through a labeled button; it says nothing about modal behavior, waiting for the dialog, failure conditions, or whether it requires an existing dynamic list. This leaves the agent without a meaningful behavioral model.

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

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

A single compact sentence front-loads the action, resource, and the exact button label, with no filler. The parenthetical category list is useful and not redundant with the schema.

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 annotations or output schema, the description omits essential operational context: how it fits into the dynamic-list workflow, what to pass in the parameters, and what the agent should observe after invocation. Although the core action is simple, an agent cannot reliably distinguish when to use it or what happens when called.

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 either parameter. The label 'Настроить список' hints at what the button parameter might target, but session_id and the value format for button remain undocumented.

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

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

The description opens with a concrete verb-resource pair, 'Open dynamic-list settings', and enumerates the setting categories (filter/order/conditional formatting/grouping), so its purpose is immediately clear. It does not explicitly contrast it with sibling tools like dynamic_list_set_settings or form_open_settings, though the 'Open' verb implies the distinction.

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

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

The description tells the mechanism ('via Настроить список') but gives no guidance about when to call this tool instead of related dynamic-list operations such as dynamic_list_current_settings, dynamic_list_set_settings, or form_open_settings. No prerequisites or exclusions are stated, so an agent must infer the correct context.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the main action and result, but omits side effects, session/window requirements, the meaning of 'detected', or how include_text changes behavior.

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

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

The description is a single front-loaded sentence with no filler or redundancy. Every phrase contributes meaningful information, making it easy to scan and understand quickly.

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

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

Given no annotations, no output schema, and minimal parameter documentation, the description is too thin for robust invocation. It gives the essential action but leaves parameter semantics, expected output structure, and behavioral side effects largely unspecified.

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% across six parameters, and the description only loosely clarifies the button action and optional text inclusion. Parameters such as max_rows, max_columns, session_id, wait_seconds, and the expected value for button are left unexplained.

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 specifies a concrete action, pressing the dynamic list 'Вывести список' button, and the expected result: returning detected tabular document(s). It is clear about what the tool does but does not explicitly differentiate it from sibling tools such as tabular_documents or dynamic_list_current_settings.

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

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

There is no explicit guidance on when to use this tool versus alternatives, and no mention of conditions or exclusions. The phrase 'press dynamic list button' implies a workflow context, but the description does not help an agent decide between this and related dynamic list or tabular document tools.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It describes opening a dialog and adding elements, but does not explain the effect of the 'close' parameter, whether the dialog is submitted automatically, or any side effects. The phrase 'through the standard dialog' implies UI interaction but leaves the automation level ambiguous. This is a significant gap for a tool that manipulates a form.

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

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

The description is concise and front-loaded with the core action, then provides parameter formats and usage guidance. It contains a slight redundancy: 'This is the preferred way...' and 'uses the same dialog the user sees' repeat the idea from the first sentence, but overall it is well-structured and not overly long.

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

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

Given the lack of annotations and output schema, the description covers the filters/orders format and clear_first guidance but omits details about the 'close' parameter, session_id, error behavior, and whether the dialog is submitted or waits for user confirmation. This is incomplete for a tool that interacts with a UI form.

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

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

Schema description coverage is 0%, so the description must compensate. It explains the format for 'filters' and 'orders' with defaults (comparison defaults to 'Равно', direction defaults to empty) and gives explicit guidance on 'clear_first'. However, it does not clarify 'close' or 'session_id', leaving some parameters unexplained.

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 ('Open the dynamic-list settings form and add filter/order elements') and mentions using the standard dialog, which distinguishes it from sibling tools like dynamic_list_open_settings or dynamic_list_clear_settings. However, it doesn't explicitly contrast with those siblings, so a full 5 isn't warranted.

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

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

The description explicitly says 'This is the preferred way to apply settings' and provides guidance on the clear_first parameter ('Keep `clear_first=false` unless replacing all user settings was explicitly requested'). It doesn't mention when not to use the tool or name alternatives, but the preferred usage note and parameter advice give useful context.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It substantively discloses the UI navigation (open form, switch section, read table) and the live-source semantics. However, it omits side effects such as whether the settings form remains open, and does not explain the `close` behavior or any permission/error context.

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

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

The description is tight and front-loaded: the first sentence states the concrete workflow, and the second adds the key provenance distinction. There is no redundant filler or wasted wording.

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

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

For a tool with five undocumented parameters, no annotations, and no output schema, the description covers the main purpose but not the parameter semantics, UI side effects, or return format. An agent could call the tool with defaults, but cannot confidently choose correct non-default values.

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

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

The input schema has 0% description coverage and the prose only indirectly explains `section` via 'requested section tab'. The other parameters—`close`, `limit`, `session_id`, and `expand_tree`—are left entirely unexplained, so the description fails to compensate for the schema gap.

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 operation: open the dynamic-list settings form, switch to the requested section tab, and read the 'Доступные поля' table. It also clearly defines the output: the live list of fields available for filtering/ordering/conditional-formatting/grouping. The 'authoritative source... actual form, not RAG metadata' clause helps distinguish it from metadata-based 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?

The 'authoritative source' sentence gives clear context: use this tool when the actual form's field set is needed rather than metadata. It does not explicitly name a sibling tool or state 'use X instead', but the context is sufficiently clear for an agent to infer when this tool is preferred.

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 disclose behavioral traits, and it does mention the underlying API (УстановитьПорядок) and the 'active' requirement. However, it does not disclose potential side effects, error conditions, or what happens if the column is not visible, leaving notable gaps in behavioral context.

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

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

The description is a single, compact sentence that front-loads the core purpose ('Quickly sort') and includes the key differentiator. There is no wasted wording, making it highly concise and well-structured.

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

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

For a tool with four parameters, no output schema, and no annotations, the description is incomplete. It fails to explain three of the four parameters, omits prerequisites beyond 'active', and provides no information about error handling or expected behavior, leaving significant gaps for an agent to infer.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It only clarifies that 'column_title' refers to a visible column title, but provides no explanation for the other three parameters (name, title, session_id). This is insufficient given the lack of schema descriptions.

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

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

The description clearly states the tool sorts the active dynamic list by a visible column title, specifying the verb 'sort' and the resource 'active dynamic list'. It also distinguishes itself from the settings-form Sort tab, which is a related but different functionality.

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 a clear exclusion ('this is not the settings-form Sort tab') and implies it is for quick direct sorting. However, it does not explicitly mention when to prefer this tool over other dynamic list tools like dynamic_list_set_settings, leaving some usage context implicit.

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. Saying 'Export' implies some output artifact, but it does not state whether this writes a file, requires platform/eventlog directories, performs network calls, or has side effects. This is a significant gap for a tool with seven parameters.

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

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

The description is short and front-loaded, but it is under-specified rather than appropriately concise. It omits essential parameter and behavior information, so the single sentence does not earn its place relative to the tool's complexity. Conciseness is not a substitute for missing guidance.

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

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

With seven optional parameters, no annotations, and no schema descriptions, the description is far from complete. Even though an output schema exists, an agent cannot determine what parameters to set, what formats are accepted, or what the export produces. This is critically inadequate for successful invocation.

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

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

Schema description coverage is 0%, and the description adds no meaning to any of the seven parameters. Parameters like fmt, from_time, to_time, out_path, and platform_dir remain completely unexplained. The description fails to compensate for the schema's lack of detail.

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

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

The description clearly states the action ('Export') and the resource ('the 1C event log'), so an agent can understand the basic function. It does not describe scope, output format, or distinguish itself from sibling tools, but no sibling appears to handle event log exports. Therefore it is clear but lacks explicit sibling differentiation.

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

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

There is no guidance on when to use this tool versus alternatives, and no mention of prerequisites or exclusions. The surrounding sibling list contains many tools, but the description does not explain how export_eventlog relates to them. The agent is left to infer the appropriate invocation context.

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

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

No annotations are provided, so the description must carry the behavioral burden. It states 'if it is open,' suggesting a no-op when the dropdown is closed, but it does not specify whether the tool errors or silently succeeds in that case. It also does not disclose any other side effects (e.g., focus changes) or prerequisites, leaving the agent uncertain about invocation consequences.

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. It front-loads the action and conditional, making it easy to parse. Every word adds meaning, and it is appropriately sized for a simple atomic action.

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 three parameters and no schema descriptions, the description is incomplete. It lacks parameter semantics, usage guidance, and explicit behavioral details (e.g., error handling). While the action itself is simple, the missing parameter explanations make it impossible for an agent to invoke it correctly without external knowledge.

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

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

Schema description coverage is 0%, meaning the schema provides only parameter titles, not descriptions. The description does not mention any of the three parameters (field_name, session_id, search_by_title) or their roles. An agent has no guidance on what values to supply for field_name (e.g., label vs. identifier), what session_id controls, or how search_by_title affects behavior. The description fails to compensate for the schema gap.

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: 'Close an open dropdown for a form field.' It uses a specific verb (close) and resource (dropdown), and the conditional 'if it is open' clarifies the scope. It distinguishes itself from siblings like field_dropdown_items and field_dropdown_state, which handle listing items or checking state.

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

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

The description implies when to use the tool ('if it is open') but does not explicitly mention alternatives or when not to use it. It lacks guidance on preconditions (e.g., checking field_dropdown_state first) and does not name sibling tools for comparison. The conditional hints at usage, but the guidance is minimal.

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 transparency burden. It does disclose that the tool opens the dropdown and returns choices, and includes a 'when exposed by the API' caveat. However, it does not mention side effects such as whether the dropdown remains open, cleanup, permissions, or error behavior.

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

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

The core action is front-loaded in the first sentence, and the second sentence adds convenience context. The sibling reference is useful though slightly separated into a second paragraph; the overall length is acceptable and each sentence contributes.

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

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

Given zero schema description coverage, no annotations, and no output schema, the description does not adequately cover the tool's parameter semantics or return behavior. It conveys the basic purpose but leaves significant gaps for an agent to invoke the tool with confidence.

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 carries the full burden of explaining parameters. It mentions 'field_name' only indirectly as the form field dropdown, and provides no meaning for timeout, session_id, or search_by_title, all of which are left entirely to the schema's type/default fields.

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: 'Open a form field dropdown and return visible choice items.' It also differentiates from the sibling field_dropdown_state by noting that the latter is for non-mutating diagnostics, making the purpose unambiguous.

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

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

It explicitly frames the tool as a convenience action for the common 'open dropdown and read choices' scenario and directs the agent to use field_dropdown_state for non-mutating diagnostics of an already-open dropdown. This gives clear when-to-use and when-to-use-alternative 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?

With no annotations, the description must carry behavioral context, but it only names the return values. It does not disclose that the call may wait (timeout param), what happens when the dropdown is closed, or whether invoking it changes state. A read query's safety is only implied, never stated.

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

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

One sentence with no filler, and the output focus is front-loaded. However, it is under-specified rather than a model of concision, so it earns only an average score.

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

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

The description gives the tool's high-level result but no parameter semantics, usage context, or expected return structure. With four parameters and no output schema or annotations, this is not enough for reliable invocation.

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

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

Schema description coverage is 0%, and the description does not define field_name, search_by_title, session_id, or timeout. 'search_by_title' in particular is ambiguous and needs explanation. This forces the agent to guess the meaning of most arguments.

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 read operation ('Return whether...') and identifies the exact output: dropdown open state and visible choice items. It is distinguishable from siblings like field_dropdown_close and field_dropdown_items by combining state with visible items, though it doesn't explicitly draw the 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 on when to call this versus field_dropdown_items or field_dropdown_close, nor any criteria such as needing current state before interacting. The absence of any usage condition makes this a no-guidance dimension.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does convey a non-mutating read operation by using 'Return,' but it doesn't mention prerequisites such as an active form or a valid session, nor does it clarify error behavior or the relationship between session_id and field_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?

A single sentence that starts with a specific verb and immediately enumerates the result fields. It is appropriately sized, well-structured, and contains no filler.

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

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

The tool itself is simple and the core purpose plus output items are clear, so the required first call for a basic field_name query is probably usable. However, with no output schema, no annotations, and no explanation of the optional session_id/search_by_title parameters, the description is not fully complete for an agent needing to choose between it and multidimensional inspection 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 0%, so the description must compensate for undefined parameter semantics, but it does not. field_name, session_id, and search_by_title are not explained in the description, though the phrase 'form field and the schema property titles provide partial implicit clues. This is not enough to fill a 0% coverage gap.

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 ('Return'), a resource ('a form field'), and enumerates the exact diagnostics returned: visibility, availability, readonly, kind, title. This is enough to distinguish it from siblings like field_value_text, field_tooltip, and field_dropdown_items, even though no sibling names are mentioned.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no alternative tool is named. The usage is only implied by the word 'diagnostics,' so an agent has to guess whether this is appropriate versus the many related field inspection tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states that tooltip text is returned and does not mention how field_name is resolved, what search_by_title does, whether a visible field is required, or any error behavior.

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

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

The description is a single, front-loaded sentence with no filler words. It is concise, though it sacrifices necessary explanatory content; still, conciseness itself is handled well.

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

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

With no annotations, no output schema, and zero schema description coverage, the one-line description is far from complete. An agent cannot determine how to specify the field, what search_by_title changes, or what the returned tooltip text represents in different contexts.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters. The meanings of field_name, session_id, and search_by_title are left entirely to the schema property names, which is insufficient for correct invocation.

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

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

The description states a clear verb ('Return') and resource ('field tooltip text'), so an agent knows what the tool does. It is distinct enough from siblings like field_info and field_value_text, though it does not explicitly name them or contrast with them.

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

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

No guidance is provided on when to use this tool versus alternatives such as field_info, field_value_text, or field_dropdown_items. The intended context is only implied by the name and 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 behavioral disclosure burden. It mentions the API method ПолучитьПредставлениеДанных(), which hints at a read operation, but it does not disclose side effects, prerequisites like an active form or session, failure modes, or return 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 short, direct, and front-loaded with the action and subject. However, it is so terse that it sacrifices meaningful parameter and usage context, keeping it from a 5.

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

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

With no annotations, no output schema, and no parameter descriptions, the tool is severely under-specified. An agent cannot tell what field_name refers to, what search_by_title does, what session context is required, or what exact text format to expect in return.

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

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

Schema description coverage is 0% and the description does not explain any of the three parameters. field_name, session_id, and search_by_title are left entirely to inference from their names, with no clarification of formats, defaults beyond the schema, or how they affect the returned presentation text.

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 ('Return') and resource ('field data presentation text'), and references the underlying method ПолучитьПредставлениеДанных(). It does not explicitly differentiate this tool from related siblings like field_info, field_tooltip, or table_cell_text, so it does not earn 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 field_info, field_tooltip, or table_cell_text. The description only states what it does, not when it should be selected or when it should not be used.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state what happens when no object is found, whether matching is exact or partial, how multiple criteria are combined, or what the return value is. The behavior beyond the basic search action is undisclosed.

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

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

The description is a single efficient sentence with the core action and criteria front-loaded. It contains no filler, though it could be slightly longer to cover missing behavioral details without becoming bloated.

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, no annotations, and no mention of return values, error behavior, or matching semantics. For a tool with four optional parameters and many closely related siblings, this description leaves significant gaps that an agent would need to resolve before calling it 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 schema provides no parameter descriptions (0% coverage), so the description's mention of searching 'by name, title, or test object type' does add meaning for three of the four parameters. However, session_id is not explained, and the description does not clarify how the optional parameters interact when multiple are supplied.

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 ('find') and resource ('object in the active UI hierarchy'), and lists the search criteria (name, title, test object type). It is clear about what the tool does, though it does not explicitly differentiate itself from sibling tools like search_objects or get_object.

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

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

No guidance is given about when to use this tool instead of alternatives such as search_objects, get_object, or wait_object. The phrase 'active UI hierarchy' implies current-session scope, but there are no exclusions, preconditions, or alternative routing.

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

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

With no annotations provided, the description carries the full burden and it delivers the key behavioral trait: 'This tool only changes focus/activation; it does not change values.' This prevents an agent from assuming the call mutates data. It does not cover failure modes or visibility requirements, but for a focus-only operation the disclosed side-effect boundary is the most important context.

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

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

Three sentences with no filler: the core action is front-loaded, the side-effect boundary is stated next, and the alternative/sibling routing comes last. Every sentence earns its place and the length is appropriate for the tool's simplicity.

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 focus tool with no output schema and no annotations, the description covers the action, side-effect boundary, and a usage pattern. However, with 0% parameter coverage across four locator-like parameters, the agent is left guessing how name/type/title identify the object. The behavior when the object is not found is also unaddressed, so it is adequate but not fully complete.

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

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

Schema description coverage is 0%, so the description must compensate, but it never explains what name, type, title, or session_id mean or how they identify the target object. It hints at identification by 'visible caption' and mentions 'the page object', but does not map these concepts to the four parameters. This is a clear gap for a schema with zero 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 first sentence states a specific verb and resource: 'Move focus to a UI object in the active test client window.' It clearly differentiates from set_field_value by explicitly noting it does not change values, and the radio/dropdown guidance names the sibling to use instead. An agent can tell what this tool does without opening the schema.

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

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

The description gives explicit when-not-to-use guidance: 'For radio buttons and dropdowns use set_field_value with the visible caption.' It also provides a concrete usage pattern: 'To switch to an inactive page, focus the page object first, then interact with its children.' Both the condition and the alternative are named, leaving nothing 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?

With no annotations, the description carries the burden of behavioral disclosure. 'Return' suggests a read-only operation, and 'when available' hints that the result may be absent, but the description does not state whether it returns null, throws an error, or requires an active form.

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 information. It is appropriately concise for such a straightforward getter 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 optional-parameter getter, the description is close to sufficient, but it lacks session_id semantics and explicit behavior when no default button is available. The missing parameter documentation and lack of output schema keep it at minimum viability.

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 mention session_id at all. The schema only provides the parameter name and a default value, leaving the agent to guess what session the tool operates on.

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

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

The description uses a specific verb ('Return') and resource ('active form default button'), making the tool's core purpose clear. It is distinct from siblings like current_element or form_state, though it does not explicitly name or contrast them.

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

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

No guidance is given about when to use this tool versus alternatives. The phrase 'when available' implies a condition, but it does not explain when a default button exists, what to do if unavailable, or which sibling tool might be a better fit.

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, and it does disclose the key behavior: focus moves to the next element and the current element is returned. This reveals both the state change and the return value, which is enough for a simple navigation tool, though it does not mention boundary conditions such as reaching the last element.

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 conveys the action and the return value with no wasted words. The verb is front-loaded and the sentence is appropriately sized for the simplicity of the tool.

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

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

For a simple one-parameter navigation tool, the description covers the essential behavior and return value. However, it omits the session parameter's role and does not relate this tool to sibling navigation tools such as current_element or form_previous_element, leaving some contextual gaps.

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

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

The only parameter is session_id, and the schema provides no description coverage (0%). The description does not explain what session_id refers to, why it is needed, or how the default behaves, leaving the agent to infer the parameter semantics from context.

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 ('move focus'), a specific resource ('next form element'), and a return value ('return the current element'). The word 'next' implicitly distinguishes it from the sibling form_previous_element, so an agent can tell them apart without opening schemas.

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

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

The intended use is implied by the phrase 'move focus to the next form element' — it is for forward navigation through a form. However, it does not explicitly mention alternatives like current_element or form_previous_element, nor does it say when not to use 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?

The description only says 'Open... via ИЗменить форму' without disclosing side effects, prerequisites, or failure modes. With no annotations, this minimal statement carries the full burden of behavioral disclosure and is insufficient for an agent to understand whether it changes UI state, requires a focused form, or can fail.

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, and the action and mechanism are front-loaded. It is as concise as possible, though the terseness comes at the cost of needed detail.

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

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

For a simple UI action the basic purpose is clear, but the undefined parameters, lack of usage context, and missing behavioral details make it incomplete for an agent. It does not explain what the customization dialog is, whether a form must already be open, or what session_id refers to.

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 two parameters, button and session_id, with defaults and zero description coverage. The description does not explain what either parameter means or how to populate them; the indirect reference to the button label is not enough to compensate for the complete 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 states a specific action: opens the current form customization dialog, and names the UI button label 'Изменить форму' as the mechanism. It distinguishes the tool from siblings like dynamic_list_open_settings by focusing on the current form, though it could be more explicit.

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

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

No guidance is provided on when to use this tool versus siblings such as dynamic_list_open_settings, save_form, or close_form. The only implied usage is that a form must be current, but prerequisites, exclusions, and alternative routing are absent.

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 disclose behavioral traits, but it only says 'move focus' without clarifying side effects like whether focus changes are reversible, if wrapping occurs at the first element, or if any state is modified. The return of 'current element' is ambiguous—does it return a string, object, or just an indication? This lack of detail leaves important behavior undisclosed.

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

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

The description is a single concise sentence, which is well-structured and front-loaded. However, it is minimal and does not include any additional useful context, making it more under-specified than appropriately concise.

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

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

Given that this is a UI automation tool with a single optional parameter and no output schema, the description is insufficient for an agent to know how to invoke it correctly. It omits prerequisites (e.g., active form), behavior when at the first element, error conditions, and the nature of the returned 'current element'. This is incomplete for a tool that likely relies on state.

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

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

The schema provides only session_id with a default but no description. Schema coverage is 0%, and the description does not explain session_id at all, nor does it add any context about how the parameter affects the operation. The description fails to compensate for the lack of schema documentation.

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

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

The description clearly states the action (move focus) and the resource (previous form element), and mentions the return of the current element. It is specific and easy to understand, but does not explicitly differentiate from sibling tools like form_next_element or current_element beyond the name itself.

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 form_next_element or current_element. There is no mention of preconditions, context, or exclusions, leaving the agent to infer usage 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 present, the description carries the full behavioral burden. It implies a read-only query, but it does not disclose whether the tool fails when no form is active, what 'availability' means, or whether session_id affects which form is inspected. The lack of any behavioral caveats or effect description leaves the agent guessing about side effects and error conditions.

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

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

The description is a single compact sentence with no wasted words. It is front-loaded with the main action and resource. However, it is so terse that it sacrifices important detail; still, for what it includes, it is efficiently structured.

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

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

Given that there is no output schema, the description should clarify what the returned state looks like, but it only names three abstract concepts (availability, modified, readonly). It also omits usage context, parameter rationale, and error behavior. An agent has just enough to guess the tool's purpose but not enough to use it confidently in a real workflow.

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

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

Schema coverage is 0% and the description does not mention session_id at all. While the parameter name and default ('default-18') hint at its purpose, the description adds no meaning. An agent cannot tell whether session_id is required, how it maps to a form, or why a default is provided. The description fails to compensate for the low 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 ('Return') and identifies a distinct resource ('active form availability/modified/readonly state'). It makes clear the tool is a state query for the currently active formaine, which separates it conceptually from other form-related siblings like wait_form or close_form. However, the phrase 'availability/modified/readonly' is compressed and not fully unpacked, leaving some ambiguity about what exactly is returned.

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

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

The description gives no indication of when to call this tool versus alternatives. It doesn't state prerequisites like an active form, nor does it mention that it's a read-only check to be used before interacting with a form. There are many form-related siblings, but no guidance is offered to route an agent to this one.

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

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

The description conveys that this is a passthrough to GetObject with wildcard name/title support and warns that it is a low-level escape hatch. However, with no annotations and no output schema, it carries the full burden and does not explain return behavior, error behavior, whether the call is read-only, or what 'direct GetObject semantics' means in terms of observable 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?

Three sentences, no filler, with the core identity front-loaded and the alternatives/usage guidance following in one compact paragraph. Every sentence earns its place.

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

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

For a tool with no annotations, no output schema, and zero schema parameter documentation, the description is too sparse to fully support correct invocation. It gives good routing guidance but omits return values, timeout meaning, session_id relevance, and type parameter behavior. An agent would still need to guess at important invocation details.

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

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

Schema description coverage is 0%, so the description must compensate. It adds that name/title support optional wildcards, but it does not explain type, timeout, or session_id semantics. Given five undocumented parameters, this is only partial 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 opens with a clear verb+resource statement: 'call TestedApplication.GetObject with optional wildcard name/title.' It immediately distinguishes itself from siblings by positioning this as a low-level escape hatch, not the structured diagnostic or focus-changing tool.

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

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

It explicitly says to prefer find_object/search_objects for structured diagnostics and focus_object for changing focus, and reserves this tool for 'platform/test-client edge cases where direct GetObject semantics matter.' This gives the agent concrete selection criteria and 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 provided, the description bears the full burden of behavioral disclosure. It states the intended action and target, but does not explain side effects on the current active window, what happens if there is no 'next' window, or whether navigation changes focus state. This is a state-changing operation and the description omits those behavioral details.

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 words; the core action and target are front-loaded and every word contributes. It is appropriately compact for a one-parameter navigation command.

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 has no output schema, so a short description can be viable. However, important context is missing: how the 'next' window is determined, whether this is a session-scoped operation, and how it relates to activate_window and goto_previous_window. It is minimally usable but not fully complete.

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

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

Schema description coverage is 0%, and the description does not mention session_id at all, leaving the agent to infer how session_id relates to the navigation. Since the schema is empty, the description should compensate by explaining which session/window context the action applies to, but it does not.

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

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

The description clearly states the action ('Navigate') and the resource ('the main test-client window'), and specifies direction ('to the next open window'), which distinguishes it from obvious siblings like goto_previous_window or goto_start_page. It does not explicitly differentiate from activate_window or windows_list, but the core purpose is unambiguous.

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

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

The phrase 'next open window' implies when this tool is useful, but the description provides no explicit guidance about when to prefer it over alternatives such as activate_window or goto_previous_window. No when-not conditions or exclusion criteria 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 present, so the description carries the full burden. It only states the navigation action without disclosing side effects, failure behavior (e.g., when no previous window exists), state changes, or any prerequisites. Minimal transparency.

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

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

The description is a single short sentence with no fluff. It is front-loaded with the core purpose. However, it is so minimal that it omits useful context, but that is a completeness issue rather than a conciseness problem.

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 annotations, no output schema, and one parameter with zero description coverage, the description is inadequate. It does not explain what 'previous open window' means, whether a window must be active, what happens if none exists, or how session_id factors in. Significant gaps remain.

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 makes no mention of the session_id parameter at all. With a parameter that has a default but no required flag, the agent receives no guidance on when to supply it or how it affects behavior, so the description adds no value 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 states a clear verb ('Navigate') and resource ('main test-client window to the previous open window'). It is specific enough to distinguish from siblings like goto_next_window, though it doesn't explicitly name alternatives. No tautology or ambiguity.

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

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

No guidance is provided on when to use this tool versus alternatives such as goto_next_window or activate_window. There is no mention of prerequisites, context, or exclusion conditions, leaving the agent to infer usage.

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

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

No annotations are provided, so the description must carry the full burden of behavioral disclosure. It only says 'navigate', which implies a view change, but does not mention side effects, prerequisites (e.g., active session), or outcomes (e.g., error if window is closed). This lack of detail for a simple yet potentially state-changing action is insufficient.

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, grammatically correct sentence that directly states the action and target. It is front-loaded and contains no filler, making it perfectly concise for its simple 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 the lack of annotations and output schema, the description should provide enough context for an agent to call the tool correctly. It does not mention any preconditions, failure modes, or effects beyond a generic navigation. For a tool with one parameter and likely simple behavior, a more thorough description is expected to cover edge cases or state changes, which 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 single parameter session_id is optional with a default, but the description does not explain its purpose or relation to the navigation. Schema description coverage is 0%, so the description should compensate but does not. Though the parameter name is somewhat self-explanatory, the tool description adds no semantic value 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 states a specific action (navigate) and resource (main test-client window to the start page). It is clear and distinct from sibling navigation tools like goto_previous_window or goto_next_window, which operate on windows rather than a start page. However, it does not explicitly differentiate itself from potential overlaps, so a 4 is appropriate.

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. It implies usage when a start page is needed, but does not mention any conditions, exclusions, or alternatives. Given the large number of sibling tools, explicit guidance would be valuable, and its absence warrants a low score.

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 implies a state-changing UI action but does not explain side effects, prerequisites, what happens to the previously active page, or whether any confirmation/response is returned.

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. It is concise, though it sacrifices necessary detail that would make it more useful.

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 five optional parameters, zero schema descriptions, no output schema, and no annotations, the description is too thin to support correct invocation. It does not clarify the relationship between parameters, the meaning of session_id, or the expected result of the operation.

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 fails to explain any of the five parameters. An agent cannot tell whether 'name'/'title' identify the page-group or the target page, nor how 'page_name' and 'page_title' differ from them, leaving all parameters effectively undocumented.

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

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

States a clear action ('Activate/switch') and a specific resource ('page-group form element'), so an agent can infer the tool changes the active page. It does not name or differentiate sibling tools like group_current_page or group_state, but the core purpose is unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives such as group_expand, group_collapse, or group_current_page. It only states what the tool does, leaving the selection decision entirely 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?

With no annotations, the description carries the full behavioral burden, but it only states the action. It does not disclose whether the group must already be expanded, whether the collapse is a toggle, what happens if the group is not collapsible, or whether any UI state changes beyond the collapse occur.

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

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

The description is short but under-specified; this is not effective conciseness. It provides a single clause with no structure, no context, and no parameter guidance, so it does not earn its place as a complete tool 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 three optional parameters, no annotations, and no output schema, the description is too thin. It leaves unresolved how to identify the target group, what 'title' means, and how the tool relates to group_expand and group_state, making it incomplete for reliable invocation.

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

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

Schema description coverage is 0%, and the description does not explain any of the three parameters (name, title, session_id). An agent cannot determine which parameter identifies the form group or how session_id is used, so the description fails to compensate for the schema's lack of 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 uses a specific verb ('Collapse') and resource ('a collapsible form group'), so the action is clear. It does not explicitly distinguish itself from sibling tools like group_expand, but the opposite verb makes the intent reasonably apparent.

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

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

No guidance is given about when to use this tool versus group_expand or other group-related tools. There are no conditions, prerequisites, or exclusions mentioned, leaving the agent to infer usage solely from the tool name and sibling list.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It does convey the core trait — this is a non-destructive read operation that 'returns' the current page. However, it does not disclose the return format (number vs. label, 0-based vs. 1-based) or behavior when the referenced element is not a page-group, leaving meaningful gaps.

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

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

The description is a single front-loaded sentence with no filler; the verb and resource appear immediately. It is appropriately brief for a simple getter, though the brevity is part of what allows parameter semantics and context to go unaddressed.

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

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

The tool has three undocumented parameters (all optional, with defaults), no output schema, and no annotations, yet the description explains neither how to identify the target form element nor what the tool returns. An agent cannot reliably invoke this tool correctly based on the definition alone.

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

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

Schema description coverage is 0% and the description mentions none of the three parameters (name, title, session_id), so it adds no meaning beyond the bare schema. The agent is left to guess which parameter identifies the form element or whether session_id scopes the lookup, and nothing compensates for the coverage gap.

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 ('Return') and a specific resource ('current page of a page-group form element'), which clearly identifies it as a read-only getter. This distinguishes it from siblings like group_activate_page (which changes pages) and group_expand/group_collapse (which alter visual state), so an agent can tell it apart without opening schemas.

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

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

No guidance is given on when to use this tool versus alternatives such as group_state or group_activate_page. There is no mention of when not to use it, no stated preconditions (e.g., the group must be a page-group), and no routing to sibling tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It only states the action and target, with no mention of side effects, prerequisites, state changes, or return behavior. For a UI interaction tool, this is insufficient.

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

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

The description is a single sentence, which is concise and front-loaded. However, it is so sparse that it lacks substantive information, making it more under-specified than appropriately concise.