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

The description discloses several behavioral details: state accepts both code and Russian name, group has specific allowed values, and every changes the semantic from 'any of' to 'all'. It does not, however, mention side effects, reversibility, or any side effects of adding a clause, and annotations are absent. It adds some context but leaves the operation's overall effects under-specified for a mutation tool.

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

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

The description is a single multi-part sentence that front-loads the primary purpose and then packs parameter-specific details. While it is a bit dense and uses a run-on structure, it avoids fluff and communicates the core intent first. It could be split for readability, but it remains acceptably 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?

For a mutation tool with 8 parameters, an output schema (which relieves return-value description), and no annotations, this description is incomplete. It covers some parameter semantics but omits context on how handle/owner/tag/join are used, any prerequisites, or how the added clause integrates with existing logic. An agent would struggle to construct a valid call without additional schema or background 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?

With 8 parameters and 0% schema description coverage, the description must compensate heavily. It adds meaning for 'group' (enumerating valid values), 'state' (explaining accepted formats), 'every' (explaining the semantic difference), and 'targets' (selection based on target type). However, it does not explain 'handle', 'owner', 'tag', or 'join', leaving half the parameters under-specified despite the description's partial help.

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 — adding a condition to the logic of a device or object — with a clear subject and resource. It distinguishes from sibling tools like add_device or add_plan by the domain (logic of device/object), though it doesn't explicitly contrast those alternatives. The verb and resource are clear enough for an agent to understand the operation's 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 offers no guidance on when to prefer this tool over alternatives. It only explains internal behavior (group options, state formats, every flag, target selection) but never states conditions like 'use this when you need to add a condition to existing logic' versus other tools. No explicit when-not or alternative routing is provided.

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

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

With no annotations provided, the description must carry full behavioral disclosure. It does explain that without int_address the first free address on the line is used, and count > 1 adds multiple devices. Yet it omits side effects, error conditions, permission requirements, or whether the operation is reversible. This is significant for a mutation tool.

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

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

Three concise sentences with the purpose front-loaded. It efficiently packs key behavioral details without fluff, though it could be structured into bullets for clarity.

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

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

Given the lack of annotations and the presence of an output schema, the description still misses critical context for correct invocation: meaning of handle and parent, any constraints, and return behavior. An agent would need additional schema inspection to safely use this tool.

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

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

The description adds meaning for driver (type and source), int_address (auto-assignment if null), and count (multiplicity). However, handle and parent—both required—are not explained beyond the vague 'under the specified tree node', and description default is ignored. Schema coverage is effectively 0%, so the description compensates only partially.

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: 'Add a device under the specified tree node'. The verb 'add' and resource 'device' are specific. It distinguishes itself from sibling tools like add_object or add_plan by focusing on devices, though it doesn't explicitly reference 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 description provides some usage context: how to specify the driver (from list_drivers) and optional behavior when int_address is omitted or count > 1. However, it lacks guidance on when to prefer this tool over sibling device tools like set_device or move_device, nor does it mention 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?

With no annotations, the description carries the burden of behavioral disclosure. It reveals automatic No assignment and the restriction on certain kinds. However, it omits other behavioral aspects such as permissions, mutability, or side effects on existing objects, so transparency is only partial.

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

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

The description is three concise sentences with no filler. It front-loads the core purpose and provides essential constraints without redundancy, making it efficient and easy to scan.

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 5 parameters, no annotations, and only a partial description, the tool is incomplete for correct invocation. Parameter semantics are missing entirely, and there is no guidance on fields/handle/description. The output schema exists, so return values are not required, but the description fails to give enough context for an agent to call the tool correctly.

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

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

Schema description coverage is 0%, so the description must explain parameters, but it does not. It only indirectly hints at 'kind' by naming zone/scenario; 'handle', 'name', 'fields', and 'description' are left unexplained. This is a significant gap for a 5-parameter tool.

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

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

The description clearly states the action ('create'), the resource ('top-level object'), and the specific kinds ('zone' or 'scenario'). It also notes auto-numbering, making the tool's purpose unambiguous and distinguishing it from sibling add_* tools by specifying the object type.

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

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

The description implies usage for creating top-level objects and includes a constraint on which kinds cannot be created (when schema is not removed from working configs). However, it does not explicitly contrast with siblings like add_device or add_plan, so an agent must infer when to choose this tool over alternatives.

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

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

With no annotations provided, the description carries the full burden. It does disclose meaningful behavior: parent_uid nests the plan into another, and image_path is a PNG/JPEG placed in Content/ with plan dimensions taken from its header. However, it omits side effects, failure modes, or behavior when both image_path and width/height are supplied. Partial disclosure, so a 3 is appropriate.

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

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

Two concise sentences, front-loaded with the core action. No wasted words. The parameter explanations are packed efficiently, making it easy to scan.

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 7-parameter mutation tool with no annotations, the description leaves significant gaps: meaning of handle, default behavior without image_path, interaction of width/height with image_path, and any prerequisites. Even though an output schema exists, an agent cannot reliably construct a correct call without more detail on these parameters.

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%, so the description must explain parameters. It covers parent_uid and image_path (the non-obvious ones), but leaves handle, name, width, height, and description unaddressed. In particular, the interplay between width/height and image_path (are they overridden?) is not clarified. Since it explains only 2 of 7 parameters, it falls short.

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 'Создать план' (Create a plan), a clear verb+resource pairing. It also explains two parameters' roles (parent_uid, image_path), adding specificity. It doesn't explicitly contrast with sibling tools like set_plan, so it stops short of a 5, but the purpose is unmistakable.

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

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

There is no guidance on when to use this tool versus alternatives such as set_plan or remove_plan. No conditions, exclusions, or scenarios are mentioned. An agent must infer from the name that it creates a new plan, but no explicit routing advice is 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?

With no annotations provided, the description bears the full burden of behavioral disclosure. It states that the operation removes logic (implying mutation/destruction), but it does not disclose side effects, error behavior, reversibility, or what happens if the group/owner does not exist. Given the destructive nature, more transparency (e.g., 'this irreversibly deletes conditions') is expected.

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. It front-loads the verb and immediately explains the two execution modes. All information is relevant, and nothing is redundant.

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

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

Despite having an output schema, the description is insufficient for a 4-parameter mutation tool with zero annotations. It omits the roles of 'handle' and 'tag', does not mention return type or error conditions, and lacks details on how to select the target. For a destructive operation, this is a significant 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?

Schema coverage is 0%, so the description must compensate. It indirectly clarifies 'group' (a group of conditions) and 'owner' (the owner of groups), but it entirely ignores the required 'handle' and the optional 'tag' parameters. Without these, an agent cannot fully understand how to specify the target. It adds only partial meaning to two of four 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's purpose: to remove logic, either a specified group of conditions entirely or, without a group, all groups belonging to an owner. It uses a specific verb and identifies the resource (logic/conditions) and the two distinct modes. This distinguishes it from siblings like remove_plan, which targets plans rather than logic groups.

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 conveys when to use the tool: when clearing logic for a specific group, pass 'group'; when clearing all groups for an owner, omit it. It provides conditional usage guidance, but it does not explicitly state when not to use it or mention alternatives like remove_plan. Still, the two scenarios give clear usage 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. It mentions depth and node caps, but this merely restates what the schema parameters convey. It does not disclose output format, error behavior, read-only status, or what the handle represents. This is insufficient for a tool with no 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?

A single, compact sentence with no wasted words. The core concept (compact text tree) is front-loaded, making it easy to scan. Perfectly 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?

The tool has 4 parameters, one required, yet the description does not explain the required handle or the optional root. While an output schema exists, the description still leaves the agent guessing about what the tree represents, how to invoke it, and what constraints apply beyond depth and node limits.

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 vaguely references 'depth and nodes' but never names handle or root, nor explains their meaning. The description adds minimal value over the bare 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 clearly states it is a compact text tree of devices with depth and node limits, which differentiates it from list/get tools that return flat collections. However, it does not explicitly state the action (e.g., 'returns') and is terse, so it is not a perfect 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?

No guidance on when to use this tool versus alternatives like list_devices or get_device. The description does not mention any specific use cases or exclusions, leaving the agent to infer when a tree view is appropriate.

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

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

Annotations are absent, so the description bears the full responsibility for disclosing behavioral effects. It states the action (export to CSV) but omits critical side effects, such as file creation, overwrite behavior, path requirements, or permission needs. Since this is a write operation, this is a major 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, front-loaded sentence with no fluff. It communicates the core action and destination efficiently, earning high marks for conciseness.

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 presence of many sibling tools and a non-trivial write operation, the description is incomplete. It does not explain the 'handle' parameter, which is required, nor does it detail the expected 'out_path' format. The output schema exists, but parameter comprehension is still lacking.

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 clarify both parameters. It only implies 'out_path' with 'по указанному пути', but never explains what 'handle' refers to (device list handle? plan handle?). No additional meaning beyond the raw schema names is provided.

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

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

The description states a specific verb ('Выгрузить' - export), a resource ('плоский список устройств' - flat list of devices), and a format ('CSV'), along with an optional path qualifier. This clearly distinguishes it from other device-related tools like list_devices or search_devices, none of which mention file export.

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 guidance is given on when to choose this tool over alternatives like list_devices or export variants. The phrase 'вне архива' hints at a specific use case but does not clarify when to use it or when not to. There is no mention of alternatives or conditions.

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

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

With no annotations provided, the description bears the full burden of behavioral disclosure. It only states the intent to export to a disk file but does not mention potential side effects (e.g., file overwriting, permissions), how handle and guid are used, or error scenarios. This is insufficient for the agent to anticipate 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, clear sentence that front-loads the action. It is concise, well-structured, and free of unnecessary detail, earning a top score for efficiency.

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

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

For a tool with three required parameters and no schema descriptions, the definition lacks essential details about parameter meanings, usage examples, and expected outputs. The description explains the purpose but not the mechanics, leaving the tool incomplete for correct 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 the parameters (handle, guid, out_path). Without any elaboration, an agent cannot infer what these values mean or how to populate them, making parameter semantics almost entirely opaque.

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

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

The description clearly states the action: exporting the plan substrate (image) to a file on disk outside the archive for viewing. It identifies the resource and intent with a specific verb, though it does not explicitly differentiate from sibling tools like get_plan_image. This makes the purpose understandable but not fully distinct.

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

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

The description provides no guidance on when to use this tool versus alternatives such as get_plan_image or list_plan_images. It does not mention context, prerequisites, or exclusions, leaving the agent without direction on tool selection.

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 implies a read-only operation ('find'), but does not explicitly state side effects or permissions. Given the simple nature of a lookup, this is adequate but not rich. It does not contradict any annotations (none exist).

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 in Russian that communicates the core purpose without any fluff. It is appropriately sized for a simple query tool.

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

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

Given that an output schema exists, the return values are likely documented structurally. The description is minimal but sufficient for a straightforward lookup, except for the unexplained 'handle' parameter. It does not mention any preconditions or context, but that may be unnecessary for a read 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 description explains that 'uid' identifies the object, but does not explain what 'handle' refers to. With 0% schema description coverage, the description should compensate for both parameters. It only partially does, leaving 'handle' 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: finding which plans contain an object with a given UID. The verb is implicit but clear ('find'), the resource is 'plans', and it distinguishes from siblings like list_plans (lists all plans) or get_plan (retrieves a specific plan).

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 purpose implies when to use it (when you need to know which plans reference an object), but it does not mention alternatives or explicitly state when not to use it. No exclusions are given, but the intent is fairly obvious from the context of 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?

With no annotations provided, the description carries the full burden. It discloses one side effect (freeing memory) but fails to mention whether closing is irreversible, whether it requires specific permissions, what happens to the handle after closing, or what the response contains. The operation is mutative, so more transparency is expected.

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 that is front-loaded with the core action and side effect. It is appropriately concise for a simple operation, but the extreme brevity contributes to the lack of contextual detail 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?

Despite having only one parameter and a simple purpose, the description omits essential usage context: no mention of when to call this versus other fscp_* tools, no parameter explanation, and no clarity on the side effects beyond memory freeing. The output schema exists but does not compensate for the missing usage and parameter guidance.

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 zero description coverage (0%) for the handle parameter, and the description does not explain that 'handle' refers to the archive identifier. The description only vaguely mentions 'archive' but never connects it to the parameter. The agent is left without any clue about the expected format, purpose, or lifecycle of the handle.

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

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

The description states a clear action ('close') on a specific resource ('archive') and adds a side effect ('free session memory'). It differentiates from siblings like fscp_open and fscp_save by the verb. However, it does not explicitly contrast with other fscp_* operations, and the Russian wording adds minor ambiguity for non-Russian agents.

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 (close when done with the archive) but provides no explicit when-to-use or when-not-to-use guidance, nor any mention of alternatives like fscp_save or fscp_revert. An agent must infer context from the operation 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, the description carries the full burden. It discloses side effects (create/open, donor byte-copy, server not parsing/showing donor data) and a caveat about acceptance. However, it does not explain the overwrite parameter's behavior (e.g., what happens if the file exists) or error conditions, leaving a meaningful transparency 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 block but front-loads the primary action and includes necessary caveats. It is reasonably concise, though the final clause about Global Monitor acceptance could be trimmed without loss of core 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?

Given three parameters and no annotations, the description is incomplete. It omits overwrite semantics entirely, does not specify the target path parameter explicitly, and does not mention potential errors or prerequisites. The output schema is present but not detailed in the description, so the tool appears only partially documented.

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%, so the description must compensate. It explains donor thoroughly (path to existing .fscp, byte-copy of SecurityConfiguration.xml) but does not describe 'path' (the target location) or 'overwrite' at all. Two of three parameters remain semantically unclear.

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

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

The description clearly states the verb (create), resource (.fscp configuration), and the immediate action of opening it with a handle return. It distinguishes from siblings like fscp_open (which opens existing configs) and fscp_save by specifying 'new empty' and 'immediately open'.

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 contextual guidance on the donor parameter and what happens without it, but it does not explicitly state when to use this tool versus alternatives (e.g., 'use fscp_open for existing files'). The usage context is implied but not made explicit.

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

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

With no annotations, the description carries the full burden. It discloses what the tool returns (list of edits and overwritten archive records) but does not state whether it is read-only or has side effects. It also omits any mention of permissions, rate limits, or error behavior. The lack of a readOnly hint makes its safety profile unclear.

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 function ('What has been accumulated in the session') and elaborates concisely. Every word contributes to understanding the tool's purpose and output. 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?

The description adequately summarizes the output but fails to provide essential context: parameter explanations, usage timing, and any operational constraints. Given it has three parameters and no annotations, the agent lacks critical information to call it correctly. The presence of an output schema does not compensate for missing input guidance.

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 (handle, limit, offset). It mentions 'session' and 'edit list' but gives no guidance on what handle refers to or how limit/offset affect output. The agent is left to infer parameter semantics entirely from names, which is insufficient.

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: showing accumulated session edits and which archive records will be overwritten on save. It uses a specific resource ('session edits', 'archive records') and implies a verb ('shows'). It does not explicitly contrast with siblings, but among the fscp* family it is unique in focus, so it distinguishes itself implicitly.

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

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

The description implies a use case: checking session changes before saving (mentions 'when saving'). It gives context but lacks explicit guidance on when to use this tool versus alternatives like fscp_info or fscp_save. No exclusions or alternative tools are named, so the agent must infer timing.

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 entirely absent, so the description must disclose behavioral aspects. It only says it returns a summary, but it does not state whether it is read-only, whether it requires an archive to already be open, or what happens if no archive is available. It does not describe any side effects, permissions, or error behavior, leaving significant behavioral ambiguity.

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

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

The description is a single short sentence that is front-loaded with the core purpose. It is concise and avoids redundancy, but it is so minimal that it misses critical information (like parameter semantics and usage context). It earns its place for stating purpose, but the brevity works against 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?

For a simple one-parameter tool with an output schema, the description should at least explain what 'handle' is and any preconditions (e.g., needing an open archive). It does neither. While the output schema might cover return value structure, the tool's inputs and prerequisites are left undefined, making the overall definition incomplete for correct invocation.

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

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

The schema has 0% description coverage, and the description does not mention the 'handle' parameter at all. The agent receives no explanation of what 'handle' refers to (e.g., an archive handle, a file path, an ID). The description completely fails to compensate for the lack of schema parameter documentation.

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

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

The description clearly indicates this tool produces a summary of an open archive, listing specific content (versions, counters, list of GC, ZIP records). It is distinct from sibling fscp_* tools like fscp_open, fscp_save, or fscp_diff, since it focuses on retrieving informational summary data rather than performing mutating or navigation actions. However, it lacks a verb like 'retrieve' or 'return', which slightly weakens the action clarity.

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

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

The description provides no guidance on when to use this tool versus any alternative. It does not mention conditions, prerequisites, or exclusions. The only implicit hint is that it operates on an 'open archive', but there is no explicit statement about when to choose fscp_info over other 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 the file is opened and a handle is returned. It does not mention whether the file is locked, what happens if the path is invalid, whether the operation has side effects, or any permission requirements. This is a significant gap for an open operation that likely leads to file modifications.

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 redundant words. The key information (file type and purpose) is front-loaded. However, it could be longer to include critical usage guidance, so it loses a point for being overly terse.

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 tool is the entry point to a family of fscp_* operations and there is an output schema (though not shown), the description lacks essential context. It omits error handling (e.g., what if the file does not exist), the nature of the returned handle, prerequisites, and the fact that to create a new file one should use fscp_create. This makes it incomplete for an agent deciding when and how to invoke it correctly.

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

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

The single parameter 'path' has no description in the schema (0% coverage), so the description must compensate. It clarifies that the path should point to a .fscp file, which adds minimal meaning. However, it does not specify whether the path should be absolute/relative, accepted file extensions, or error conditions. The compensation is insufficient for a parameter with zero 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 verb (open), the resource (a .fscp file), and the outcome (get a handle for other calls). It distinguishes from siblings like fscp_create and fscp_close by indicating it's the entry-point open operation. However, it does not explicitly contrast with fscp_create, so it falls short of a 5.

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

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

The phrase 'получить handle для остальных вызовов' implies this tool should be used first in a sequence of fscp_* operations, giving some usage context. But it does not explicitly state when not to use it (e.g., if the file doesn't exist, use fscp_create instead) or name any alternative tools. The guidance is implied rather than explicit.

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

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

With no annotations, the description carries the full burden. It discloses that the revert is complete and not partial, implying it discards all changes since archive open. This is a useful behavioral trait. However, it does not mention prerequisites (e.g., an active session), potential destructiveness to unsaved work, or any side effects. It is adequate but not thorough.

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

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

Two short sentences with no fluff. The core action is front-loaded, and the key limitation (no partial revert) is stated clearly. Every word earns its place.

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

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

The tool is simple, has an output schema (so return values need not be explained), and no annotations. The description covers the main behavior and a limitation, but omits any explanation of the handle parameter and any prerequisites. For a reversible/destructive operation, more context could be given, so it's just adequate.

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% for the only parameter 'handle'. The description does not explain what 'handle' refers to (presumably the session/archive handle). Since there is no schema description and the tool text ignores the parameter, an agent may guess its meaning from context, but the description adds no value beyond the schema placeholder. This is a 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 action ('revert') on a clear resource ('all edits of the session') and defines the target state ('at the moment of opening the archive'). It also notes a key constraint (no partial revert), which helps distinguish it from other fscp_* tools like fscp_save or fscp_diff. This 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?

The description implies usage: when you need to undo session edits. However, it does not explicitly compare with alternatives or state when not to use it. There are related tools like fscp_diff (to view changes) and fscp_save (to commit changes), but no explicit routing. The context is clear but lacks exclusions or alternative mentions.

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

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

With no annotations provided, the description carries the full behavioral burden. It thoroughly discloses that the source file is never touched, existing files at out_path are overwritten only when overwrite=true, untouched records are copied byte-for-byte, and an integrity check runs before writing (disabled via check=false). This is comprehensive transparency 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 three sentences: first states purpose and source safety, second details copying behavior, third explains integrity check. Each sentence adds essential information with no fluff, and the primary purpose is front-loaded.

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 core mechanics (source untouched, overwrite flag, integrity check) but leaves gaps: what 'handle' refers to, behavior when the target exists and overwrite=false, and error conditions. Since the tool likely requires an opened session, omitting handle context is notable. However, the presence of an output schema (not shown) may reduce the need to describe return values, so the description is fairly complete for a save 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%, so the description must compensate. It explains out_path (new file), overwrite (existing file behavior), and check (integrity check disabling), but does not explain what 'handle' refers to. Since handle is a required parameter and not described in the schema, the agent lacks crucial context about its purpose, leaving 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 clearly states the tool saves a configuration with edits to a NEW .fscp file, explicitly noting the source is never touched. This distinguishes it from sibling tools like fscp_open, fscp_close, and fscp_revert by specifying the exact verb (save), resource (configuration with edits), and target (new .fscp file).

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

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

The description implies the tool is for saving edited configurations to a new file and clarifies overwrite and integrity check behavior, but does not explicitly state when to use it versus alternatives like fscp_create or fscp_revert. No exclusions or prerequisites (e.g., an open handle) are mentioned, leaving usage context implied rather than explicit.

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

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

With no annotations, the description must carry the full transparency burden. It only says 'full device card' and gives an address format, but does not disclose read-only behavior, potential errors, or side effects. No contradictions exist since annotations are absent.

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, but it omits critical details. It is front-loaded with the primary purpose, yet lacks structure for parameter clarification or usage context, making it under-specified rather than efficiently 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?

For a tool with two required parameters and an output schema (not shown), the description fails to explain the parameter roles or any input-output mapping. The address format is given but not elaborated, leaving significant gaps for correct 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 coverage is 0% with no parameter descriptions. The description mentions 'by UID or address' but does not map these to the two required parameters 'device' and 'handle', nor clarify the format of the address beyond an example. An agent cannot determine what to pass for each parameter.

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 tool retrieves a full device card by UID or address, which is a clear verb-resource pairing. It distinguishes from list_devices and search_devices by implying a single-device lookup, but does not explicitly name alternatives or differentiate from get_object or resolve_uid.

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 the many sibling tools (e.g., list_devices, search_devices). The description does not mention contexts where this is preferred, nor any exclusions.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. Although 'get' implies a read operation, the description does not explicitly state it is read-only, nor does it mention error behavior, required permissions, or whether the handle parameter influences the result. It also does not clarify what 'card' means in terms of the returned data structure, leaving the agent to infer.

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, but it is under-specified. It omits critical context about parameters and usage, so it is not efficiently informative; it is simply too sparse. The sentence does not earn its place because it leaves major gaps.

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?

While an output schema exists (so return format is covered), the description still lacks essential context: the role of 'handle,' the meaning of 'top-level object' in this system, and any differentiation from sibling tools. With both parameters undocumented and no annotations, the description is incomplete for an agent to confidently invoke this tool correctly.

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

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

Schema description coverage is 0%, so the description must compensate for both parameters. It explains that the object is looked up by UID, which covers the 'uid' parameter, but it never mentions 'handle' or its purpose. The description adds only marginal meaning beyond the schema, failing to explain how the two parameters relate or which is primary.

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 (retrieve a card/record) on a resource (top-level object) by UID, and names the object types (zone, scenario, direction). This is clear and unambiguous about what the tool does, but it does not differentiate it from sibling tools like get_device, list_objects, or resolve_uid, which also operate on objects or UIDs.

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

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

The description provides no guidance on when to use this tool versus alternatives such as list_objects or resolve_uid. It does not state prerequisites, typical contexts, or when this tool would be preferred over siblings. The only hint is the phrase 'top-level object,' which implies a scope but no explicit selection criteria.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It does not state that this is a read-only retrieval, whether authentication or special permissions are required, what happens if the plan does not exist, or that pagination is applied. The only hint, 'by pages', 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?

The description is extremely short, but this is under-specification rather than effective conciseness. It does not front-load or convey the essential information an agent needs; it reads as a fragment that raises more questions than it answers.

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, two required, and an output schema, the description is severely incomplete. It fails to specify the core action, the required identifiers, when to use it, or any behavioral expectations, leaving the agent without sufficient context 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 lack of parameter documentation. It mentions none of the four parameters (handle, plan_uid, limit, offset). The parameter names offer some hint, but the description adds zero value in clarifying their meaning or usage.

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 noun phrase ('Plan with a list of objects drawn on it...') lacking an explicit verb such as 'retrieves' or 'gets'. The agent must infer the action from the name. It does not distinguish this tool from siblings like list_plans or get_object, making the purpose vague.

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 list_plans (listing plans) or get_object (retrieving a single object). There is no context about scenarios that favor this tool.

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

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

With no annotations, the description must disclose behavioral traits but only mentions a dependency on Pillow and the rationale for max_px. It does not state what is returned (e.g., image bytes, base64), whether the operation is read-only, or any potential side effects. Additionally, it claims max_px is 'required' while the schema shows it has a default and is optional, introducing inconsistency with the structured definition.

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, two sentences, and front-loads the main caveat about max_px. It earns points for brevity and highlighting a critical operational detail (dependency). However, its brevity comes at the cost of missing essential information about parameters and output, so it is concise but under-specified rather than efficiently complete.

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 no output schema, so the description must explain the return value, but it does not. It fails to state what the inline preview looks like (format, encoding), what handle and guid refer to, or any error conditions. Sibling tools like extract_plan_image and list_plan_images suggest a family of image tools, but without further context the agent cannot accurately construct a call or interpret the result. The false claim about max_px being required further compounds the incompleteness.

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%, so the description must compensate, but it only touches on max_px (and even that is ambiguous—it says 'required' but doesn't explain its meaning beyond 'originals can be larger'). It provides no explanation for handle or guid, which are the required parameters. The agent cannot infer what these strings represent or how they relate to a plan image, making the parameter semantics nearly absent.

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 'Inline preview of the substrate' in Russian, which conveys the tool's core function of returning a preview image of a plan's base image. It implies a preview rather than full extraction, loosely distinguishing it from sibling extract_plan_image. However, it does not explicitly use the verb 'returns' or clarify the term 'substrate' for non-Russian-speaking agents, so it is clear but not perfectly 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?

The description provides no guidance on when to prefer this tool over alternatives like extract_plan_image or get_plan. It only notes that max_px is necessary because originals can be large, which is a parameter usage hint, not a tool selection cue. There is no mention of context, prerequisites, or exclusions, leaving the agent without direction on which tool fits a given scenario.

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 bears full burden for behavioral disclosure. It only states what the tool returns (children of a node) but does not disclose any behavioral traits such as pagination behavior (limit/offset), handling of invalid parent handles, ordering, or any side effects. The description is too sparse to inform an agent about edge cases or operational 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, compact sentence with no redundancy. It is front-loaded with the core purpose and uses efficient language. However, it is so brief that it omits necessary details, but the conciseness itself is well-executed; there is 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?

Given the tool has 5 parameters, an output schema, and numerous sibling tools, the description is far from complete. It does not explain how to use the tool in a workflow, the meaning of required 'handle', the function of pagination, or how it relates to device_tree and other device list tools. An agent would likely struggle to call this correctly without additional context.

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

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

Schema coverage is 0%, and the description only hints at the 'parent' parameter semantics (root if omitted). It does not explain the required 'handle' parameter, nor 'limit', 'offset', or 'driver' meaning. The schema only provides types and defaults, but the description must compensate for low coverage; it fails to do so, leaving the agent with unclear meanings for most parameters.

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

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

The description states 'Children of a device tree node' which clearly conveys it lists sub-nodes of a device tree. The verb is implied by the tool name (list) and the resource is specific. It distinguishes from siblings like get_device (single) and search_devices (search) by focusing on tree hierarchy. However, it does not explicitly say 'list devices' or mention the return set, so it's a bit indirect.

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 usage hint: 'Without parent — root of configuration' implies that omitting parent returns the root node's children and providing parent returns children of that node. This gives context on parameter usage but does not mention alternatives or exclusions. There is no guidance on when to use this vs search_devices or device_tree, so it relies on the agent to infer.

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 that the tool lists drivers and filters them but does not explicitly indicate read-only semantics, pagination behavior, or any side effects. While listing is generally read-only, the description fails to state that this operation has no destructive intent or how results are sorted/truncated. The description is too sparse to fully disclose 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 fluff, which is concise. However, it is under-specified rather than appropriately concise; it front-loads the tool's purpose but omits critical details. It is not poorly structured, but its brevity works against it. The sentence is acceptable as a starting point but not as a complete 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 4 parameters and zero schema descriptions, the description is far from complete. It lacks explanations for limit, offset, and handle, and does not mention pagination or result ordering. Although an output schema exists, the description does not address how the results are shaped. An agent cannot reliably call this tool with correct parameter values based only on the description.

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

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

Schema description coverage is 0%, so the description must explain all parameters. It only explains 'query' (filters by name, description, category) and completely ignores 'limit', 'offset', and especially 'handle'. The description adds meaning to query but leaves the other three parameters unexplained. Given that 'handle' is an unusual parameter for a list operation, its omission is a significant gap. The description does not 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 it is a driver directory (Справочник драйверов Рубеж) and that query filters by name, description, and category. This distinguishes it from sibling tools like list_devices, list_plans, and list_objects, which cover different resources. It could be more explicit about what a driver represents, 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 provides no explicit guidance on when to use this tool versus alternatives. It implies usage for driver lookups but does not mention exclusions or extensions, nor does it reference any sibling tool for contrast. The only usage hint is the filtering behavior, which is not enough to route an agent away from similar listing 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 must carry the full burden of behavioral disclosure. It does not mention pagination, querying, filtering, sorting, or any side effects. The only hint is the 'kind' parameter, but its behavior is not explained. The description is entirely uninformative about what happens when the tool is called.

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

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

The description is extremely short (one phrase) but this is not conciseness—it is under-specification. While it is front-loaded with the main concept, it omits essential operational details. A concise description would leverage every word to convey useful semantics; this does not.

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

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

Despite having an output schema (which exempts return-value explanation), the description fails to provide any context for using the tool. With 5 parameters, many sibling tools, and no annotations, the description is completely inadequate for an agent to know how or when to use it. Even basic information like 'lists objects of a specified kind' is missing.

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

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

Schema description coverage is 0%, meaning the description provides no explanation of any parameter. The parameters (kind, limit, query, handle, offset) are not described at all. The description adds nothing to the input schema, so the agent must guess the meaning of each parameter from defaults and types alone, which is insufficient.

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 noun phrase listing object types ('Top-level objects: zone, guard_zone, ...') but never states a verb like 'list' or 'retrieve'. It implies listing but is ambiguous about the action. It also fails to differentiate from sibling tools such as list_devices, list_plans, or list_drivers, which likely have similar semantics but for different entity types.

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. There is no mention of context, prerequisites, or exclusions. With many sibling list tools, the absence of any usage direction leaves the agent to guess which tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It indicates what information is returned (size, resolution, references, orphans) but does not state whether the operation is read-only, whether it requires specific permissions, or if it has side effects. The listing nature implies read-only, but it is not explicitly 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?

The description is extremely terse, consisting of a single noun phrase. While concise, it lacks structural completeness and prioritizes brevity over utility. It is under-specification rather than good conciseness, omitting essential information that an agent needs.

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

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

With one required parameter that is not explained, no annotations, and an output schema present but not described, the tool is incomplete for an agent to call correctly. The lack of parameter semantics and any usage context makes it inadequate even for a getter/list tool. The presence of an output schema does not compensate for the missing input documentation.

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 'handle' is entirely undocumented. Schema description coverage is 0%, so the description must explain the meaning of 'handle' but does not. The phrase 'from Content/' hints at a location but does not clarify what the handle refers to (e.g., a plan identifier, a path, a UID). 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 states that the tool lists plan sublays from Content/ and returns size, resolution, references, and orphan status. This is a specific verb (list) and resource, and it implies a listing operation distinct from get_plan_image or extract_plan_image. However, it is a noun phrase rather than a full sentence, which slightly reduces clarity.

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

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

There is no guidance on when to use this tool versus alternatives like get_plan_image, extract_plan_image, or find_on_plans. No use cases, exclusions, or conditions are provided. The agent is left to infer usage from the name and fragment.

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 of behavioral disclosure. It states an outcome (a tree with counts) but does not mention whether the operation is read-only, whether it recurses into all levels of the tree, any pagination limits, or permissions required. This is minimal and leaves significant behavior inferred.

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 phrase with no filler or redundant wording. It immediately communicates the core output (tree of plans with counts) in an efficient manner. Given the simple interface (one parameter), this level of conciseness is appropriate.

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

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

Although the tool has an output schema that defines return values, the description omits the crucial meaning of the 'handle' parameter, without which the agent cannot correctly invoke the tool. It also lacks any context about scope (e.g., all plans or a subset) or how the tree is constructed. The lack of parameter guidance makes the definition incomplete.

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

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

The schema has one required parameter, 'handle', but the description does not explain what this handle refers to (e.g., a plan ID, a parent node, an owner). With 0% schema description coverage, the description must compensate, but it completely ignores the parameter. The agent cannot determine what value to supply.

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 indicates a list operation on plans, specifying the structure (tree) and the included information (object counts). It distinguishes this from siblings like get_plan (single plan retrieval) and find_on_plans (search), 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?

The description provides no guidance on when to use this tool versus alternatives such as get_plan, find_on_plans, or list_objects. There is no mention of intended use cases, required prerequisites, or situations where another tool would be preferred. The agent is left without 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?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions the subtree move and the free-address selection, but omits critical behavioral traits such as required permissions, reversibility, effects on existing references, or failure conditions. For a mutating operation, this is a significant gap.

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

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

The description is two sentences with no filler. It front-loads the core action, gives an example, and adds a parameter nuance—all in a compact, readable format.

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 and 0% schema coverage, the description is incomplete. It fails to explain three of four parameters, does not describe the output schema or return value, and omits side effects or error scenarios. An agent would lack essential context to call this tool correctly and safely.

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 explains int_address (optional, free-address selection). The required parameters device, handle, and new_parent are not described at all, leaving their meaning and format entirely to inference from parameter names, which is insufficient 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 clearly states the action: moving a device along with its subtree to another node, and provides a concrete example (hanging a device on another ALS). This unambiguously differentiates it from sibling tools like add_device, set_device, and remove_device.

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 example use case (перевесить прибор на другую АЛС) gives a practical scenario, and the note about int_address clarifies when an address is automatically chosen. However, it does not explicitly exclude alternatives or state when not to use this tool, so an agent might not fully distinguish it from add_device or set_device without deeper analysis.

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 explains that device placement uses a point (left, top) and that zones/scenarios require width/height, and that connections are drawn on both sides. This discloses shape-specific behavior, but it does not mention side effects such as overwriting existing objects, permissions, or return values. The output schema exists but is not described, so the behavioral story is partial.

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: two sentences that front-load the purpose and then detail the shape-specific behavior. Every clause adds meaningful information with minimal redundancy. The structure is clear and easy to scan.

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 seven parameters and zero schema descriptions, the description covers the spatial parameters but leaves required fields (handle, plan_uid, item) unexplained. It also does not address the return value or any preconditions. While the output schema exists, its content is not described, so an agent may not know what the tool responds with. The description is adequate for understanding basic placement logic but lacks details needed for fully correct 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 illuminate parameters. It explains the role of left, top, width, and height for different object types, but it does not clarify what 'handle', 'plan_uid', or 'item' represent. It also does not state that left/top are optional (defaults exist) or how they interact with the required fields. The explanation is useful but incomplete for the three required parameters.

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

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

The description states a clear purpose: 'Нарисовать объект ГК на плане' (draw an object on the plan). It distinguishes device placement (point) from zone/scenario placement (rectangle) and mentions connections. This is specific enough to separate it from sibling tools like add_object or set_object, though it does not name an alternative explicitly.

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

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

The description provides clear usage context: devices are placed as points with left/top, zones/scenarios are placed as rectangles requiring width/height, and connections are placed on both sides. This tells the agent when certain parameters are needed, but it does not explicitly mention when not to use this tool or name alternative 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?

Since no annotations are provided, the description must carry the full burden. It indicates the tool is a 'raw XML fragment' reader and a fallback, but it does not explicitly state behavioral traits such as read-only safety, potential error conditions, truncation behavior (though max_chars is in the schema), or formatting of the returned data. The description is not misleading but lacks depth in explaining side effects or limitations.

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 to the point, consisting of two sentences. The core purpose ('Raw XML fragment by ElementTree path') is front-loaded, followed by a concrete example and the fallback condition. No filler or redundant phrasing.

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 fallback nature and four parameters, the description provides enough to understand the general use case but leaves key parameter semantics ambiguous (handle, config). An output schema exists, which helps clarify return values, but for a tool with no annotations and zero schema parameter descriptions, the description alone is insufficient for a new agent to call it reliably without additional research.

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

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

Schema description coverage is 0%, so the description must explain parameters. It only gives an example for 'path' (e.g., 'Zones/GKZone[1]') and implies what the path means. It does not explain 'handle' (likely a device or config handle), 'config' (though a default is given), or 'max_chars' (truncation limit). An agent would be uncertain about what to supply for handle and how the config interacts with the path, making parameter usage underspecified.

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 reads a raw XML fragment by ElementTree path (with an explicit example 'Zones/GKZone[1]') and identifies itself as a fallback when typed tools are insufficient. This makes the purpose unambiguous and distinguishes it from the many sibling typed tools like get_object or set_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?

The description gives a clear usage condition: use when 'типизированных инструментов не хватает' (typed tools are insufficient). It implies when not to use it (when typed tools cover the need), but it does not explicitly name any specific alternative tools. This is helpful but could be more explicit about which siblings to prefer.

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 openly states the destructive nature (delete with subtree), the refusal condition when references exist, and the force option that overrides it. It also mentions that it lists the links, which is useful. This is transparent about the tool's side effects and guardrails.

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 primary action and then adds the conditional behavior. No filler or redundant words. Every part 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 description covers the core behavior and the force flag well, but it is incomplete regarding the parameters (handle and device). Since there is an output schema, return values may not need explanation, but the parameter semantics gap makes the overall description insufficient for an agent to call the tool correctly without 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%, so the description must compensate. It explicitly explains the force parameter (true deletes references) but does not clarify the 'handle' or 'device' parameters. The description mentions 'device' in prose but does not map it to the parameter explicitly, and 'handle' is entirely unexplained. This leaves two of three parameters 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: delete a device together with its subtree. It is a specific verb+resource combination and is easily distinguished from siblings like remove_plan (which deletes plans) or remove_object (which deletes objects). No ambiguity about what this tool does.

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

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

The description implies usage (delete a device) and provides a conditional behavior (refuses if references exist unless force=true). However, it does not explicitly mention alternatives or when NOT to use this tool. It gives contextual usage hints but stops short of comparing with sibling tools or stating prerequisites.

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

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

With no annotations provided, the description carries the full burden. It discloses side effects (cleaning up references: device bindings, logic conditions, plan objects) and the failure mode without force (refuses and lists referrers). This is substantive transparency for a delete operation, though it doesn't cover irreversibility or permission requirements.

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

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

The description is a single, well-structured sentence that leads with the core action, then adds the reference-cleaning detail, then the force behavior. It is concise without fluff, though the lack of parameter explanations is a drawback.

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 and zero schema coverage, the description must compensate, but it does not explain parameters or provide usage prerequisites. It covers behavior and side effects, but an agent lacks the information needed to confidently call the tool with correct arguments. The existence of an output schema reduces the need to describe returns, but parameter semantics remain a critical 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?

Schema description coverage is 0% and the description does not explain any of the three parameters (handle, uid, force). The text mentions 'force' in a behavioral sense but never maps it to the parameter, and handle/uid are completely unexplained. An agent would have to guess what values to provide.

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

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

The description clearly states the action ('Удалить' = remove) and the resource ('зону или сценарий' = zone or scenario), and adds a distinctive feature (cleaning references). It does not explicitly name sibling tools or differentiate by exclusion, but the resource type is distinct from tools like remove_plan and remove_device, so an agent can infer the intended 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 the tool is for zones/scenarios and mentions the force parameter behavior ('Без force отказывает...'), which gives practical guidance on when to pass force. It does not explicitly state alternatives or when-not-to-use, but the context is reasonably clear.

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

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

No annotations are present, so the description must fully disclose behavioral traits. It does mention the action 'сняв связь с обеих сторон' (unlinking both sides), which indicates the tool does not delete the object but removes its link to the plan. However, it omits critical details such as whether the operation is reversible, whether it affects other plans or objects, or if there are any side effects. For a mutation tool with zero annotations, this is a significant transparency 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, concise sentence that leads with the action and includes the key nuance about unlinking both sides. It avoids fluff and is front-loaded, making it easy to parse. While it might be slightly under-specified, the brevity is appropriate for the tool's simplicity and does not waste the agent's attention.

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

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

Despite having an output schema (which covers return values), the description lacks essential context such as parameter meanings, preconditions, and side effects. The operation's complexity is moderate (3 required params, mutation), but without annotations or schema descriptions, the description is too sparse. An agent would struggle to invoke this correctly without additional inference, making it incomplete for real-world use.

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

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

The input schema has zero description coverage, so the description must compensate by explaining each parameter. It only implies that 'item' is the object and 'plan_uid' is the plan, but says nothing about 'handle' – it could be the placement identifier or a unique link handle. Without explicit parameter explanations, the agent cannot confidently map arguments to their semantic roles, making this a weak area given the 0% 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 clearly states the action: 'Remove an object from the plan, unlinking both sides.' This specifies a verb (remove) and resource (object from plan), and distinguishes it from siblings like remove_plan (removes entire plan) and remove_object (likely removes object from catalog). The phrase 'сняв связь с обеих сторон' adds important scope by clarifying the bidirectional relationship removal, making the purpose specific enough for an agent to differentiate from similar tools.

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

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

The description provides no explicit guidance on when to use this tool versus alternatives. It does not mention scenarios, prerequisites, or exclusions. While the purpose implies this is the tool for removing a placement, there is no comparison with siblings like place_object or remove_object, leaving the agent to infer context. Without such clarity, it fails to guide selection in ambiguous 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 provided, the description must disclose all behavioral traits. It does state that the plan is deleted along with nested and drawn objects, and that without force it refuses if there is something to delete. However, it omits other important aspects such as reversibility, any side effects on related data, or permissions required. It does not contradict annotations (none exist), but the disclosure is incomplete for a destructive 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, concise sentence with no redundancy. It front-loads the main purpose and directly integrates the critical force behavior, making it efficient and easy to parse.

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 destructive delete operation with 3 parameters, the description is not fully complete. It covers the deletion scope and force logic but leaves parameter semantics (handle, plan_uid) unexplained and does not mention any prerequisites or expected output beyond what an output schema would provide. Given the presence of an output schema, return format is covered externally, but the missing parameter clarity reduces completeness.

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

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

Schema description coverage is 0%, so the description must compensate. It provides meaning for the 'force' parameter by explaining the refusal behavior when force is false. However, it does not clarify what 'handle' or 'plan_uid' represent or how they are used. Since two of three parameters remain undocumented, the description only partially compensates 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 a clear action ('Удалить план' - delete plan) and resource, with specific scope (including nested and drawn objects). It is distinct from sibling operations like add_plan, set_plan, and get_plan, clearly indicating a destructive plan-level operation.

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

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

No explicit guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., device handle) or situations where other tools (like remove_object) might be more appropriate. The only context provided is the force behavior, which is behavioral rather than usage 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?

No annotations are provided, so the description carries the full burden of explaining behavior. However, it only states the lookup purpose and does not disclose whether the operation is read-only, what it returns (e.g., the object type, a summary, full data), or any potential side effects. It is minimally informative.

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

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

The description is a single, concise sentence that immediately states the tool's purpose. It is front-loaded and uses no filler words. However, its brevity contributes to its lack of depth, so it earns a 4 rather than 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?

Even though an output schema exists, the description does not clarify what the resolved information will contain or how the parameters interact. The 'handle' parameter is unexplained, and there is no indication of the return format or any error conditions. Given that the tool requires two parameters, this is a noticeable 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 schema description coverage is 0% — the description does not explain either of the two parameters (uid and handle). While 'uid' likely corresponds to the GUID mentioned, the description does not explicitly map it, and the 'handle' parameter is entirely unexplained. 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 tool's function: resolving what kind of object a GUID represents (device, zone, plan, substrate, driver). The verb 'resolve' is implied by the name, and the resource (GUID) is explicit. It distinguishes from sibling tools like get_device or get_object by focusing on identifying the type rather than fetching details.

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

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

The description notes the purpose ('what object is hidden behind the GUID') but gives no explicit guidance on when to use this tool versus alternatives such as get_object or get_device. It does not mention any exclusions or specific conditions under which this tool should be 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?

No annotations are provided, so the description carries the full behavioral burden. It states what the tool does but not that it is read-only, how results are ordered, how pagination works (offset/limit), or what happens with no matches. The required 'handle' parameter is unexplained, which is a notable omission for a search tool.

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

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

The description is a single, concise sentence that is front-loaded with the core purpose. It is not verbose and avoids redundancy, but the brevity sacrifices important details like usage context and parameter behavior, making it less effective than a slightly longer, structured description.

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

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

While the output schema exists and likely describes the return format, the description lacks critical usage details: how filters combine, the meaning of the required 'handle' parameter, pagination semantics, and any constraints on parameter usage. An agent cannot correctly call this tool without additional inference from parameter names and defaults.

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

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

The description maps some parameters to search criteria: driver ('тип'), address_prefix ('префикс адреса'), description ('описанию'), and property_value ('значению свойства'). However, it omits property_name, handle (required), limit, and offset. With 0% schema description coverage, the description only partially compensates 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 the tool searches devices and lists the search criteria (type/driver, address prefix, description, property value). This is a specific verb + resource with distinct filter dimensions. However, it doesn't explicitly differentiate from siblings like list_devices, though the word 'search' implies filtered listing.

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 list_devices or get_device. The description does not mention prerequisites, typical use cases, or conditions for choosing this tool, leaving the agent to infer 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?

No annotations are provided, so the description must carry the behavioral burden. It discloses two behaviors: that unspecified fields remain unchanged (partial update) and that plan labels update automatically. However, it does not clarify the semantics of passing null (e.g., does null clear a field?), likely requiring experimentation. It also omits any mention of permissions, reversibility, or side effects beyond plan labels, leaving gaps for a mutation tool.

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

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

The description is a single, efficient sentence that front-loads the purpose, then adds the partial-update instruction and the plan-label behavior. No fluff, no repetition, and every clause adds information. It is well-structured for quick parsing.

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?

While an output schema exists (so return format is covered), the description leaves several gaps for an 8-parameter mutation. It does not specify how null values are interpreted for optional fields (clear vs. unchanged), does not explain what 'GKProperty' represents beyond the name, and omits any error or concurrency notes. For a tool with no annotations, this could be richer to ensure correct agent usage without extra trial-and-error.

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 explain parameter meaning. It enumerates most fields: description, IntAddress, disable, serial number, zones, and properties, giving context for what each changes. It does not explain the identifiers 'handle' and 'device', but these are required and their purpose is inferable from the name. The description adds value over the raw schema by mapping int_address to 'IntAddress' and properties to 'GKProperty', though it does not detail types or formats beyond that.

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

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

The description clearly states the verb 'Изменить' (change) and the resource 'устройства' (device), then enumerates the specific fields it modifies: description, IntAddress, disable, serial number, zones, and GKProperty. This distinguishes it from sibling tools like add_device, remove_device, and move_device, as it is squarely an update operation.

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

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

It provides a clear usage rule: 'Задавайте только то, что меняете' (only specify what you change), which tells the agent how to perform partial updates. While it does not explicitly contrast with alternatives, the context is clear that this tool is for modifying existing devices, and the name set_device implies that. It lacks explicit when-not-to-use or alternative routing, so not a 5.

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

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

No annotations are provided, so the description must disclose behavioral traits. It does state one key invariant: 'Номер No не меняется никогда' (No never changes) and that it is part of the displayed name and referenced. It also implicitly restricts which fields can be modified by listing them. However, it does not describe the outcome on success, error scenarios, permissions, or side effects, leaving significant gaps for a mutation tool with no annotation support.

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

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

The description is concise: two sentences in Russian, no fluff. It front-loads the main purpose and then adds a constraint. It is appropriately sized, though it could be slightly more structured to separate the 'what' from the 'constraints'.

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 0% schema coverage and no annotations, the description is insufficient for correct invocation. It does not explain required parameters (handle, uid), how the 'fields' object should be populated, return values (though an output schema exists, its content is not provided to the agent), or error behavior. The tool has 5 parameters and only partial field explanation, so agents will likely struggle to use 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. It mentions 'name' and 'description' (which map directly to parameters) and lists additional fields like Fire1Count/Fire2Count and DelayTime/Hold/DelayRegime. But it does not explain the 'fields' parameter, nor the 'handle' and 'uid' parameters. The relationship between the listed fields and the 'fields' object is unclear, so an agent cannot reliably construct a valid call.

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 purpose: 'Change object fields' (Изменить поля объекта). It lists specific fields (name, description, Fire1Count/Fire2Count for zones, DelayTime/Hold/DelayRegime for scenarios) which distinguishes it from sibling set_* tools like set_device or set_plan. However, it does not explicitly contrast with those siblings, so it is not a perfect 5.

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

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

The description gives no guidance on when to use this tool vs. alternatives. It does not mention when not to use it, nor does it reference sibling tools. While it lists allowed fields (implying it is for changing those specific object attributes), it lacks explicit routing or exclusions, leaving the agent to infer usage based on 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?

No annotations are provided, so the description must carry full behavioral disclosure. It only says 'change' without mentioning whether the operation is permanent, requires specific permissions, or how unlisted fields are treated. It does not disclose side effects or reversibility, which is a significant gap for a mutation tool.

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

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

The description is a single concise sentence that front-loads the action, but it is too short to convey necessary details. It is not wastefully verbose, but it lacks structure to guide the agent beyond the basic operation.

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 six parameters and is a mutation, yet the description provides minimal context. It does not explain prerequisites, return values, or edge cases, making it incomplete. While an output schema exists, it does not compensate for the lack of input semantics.

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 explain all parameters. It mentions name, description, and dimensions (width, height), covering four of six, but does not explain the role of 'handle' or clarify that 'plan_uid' is the identifier. The description offers minimal added meaning beyond field names.

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 ('Изменить' = change) and the resource (plan), and lists the fields affected (name, description, dimensions). This unambiguously distinguishes it from siblings like add_plan (create) and remove_plan (delete). The resource and operation are specific and actionable.

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

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

The description implies usage when modifying an existing plan, but it does not explicitly state when to use it versus alternatives like get_plan, add_plan, or remove_plan. It gives no prerequisites or exclusions, leaving usage context to inference.

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

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

With no annotations, the description carries the behavioral burden. It states what the tool checks but does not disclose whether it is read-only, whether it modifies state, or what side effects (if any) occur. 'Проверка' implies a check, but no explicit guarantee of non-mutation. The description also doesn't mention authentication 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 description is a single efficient sentence that front-loads the primary purpose and enumerates the checks. No filler or redundancy. However, it is under-specified in other dimensions, but for conciseness alone it earns a high 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 output schema exists, so return format may be covered, but the description omits any context about what the validation output looks like, whether it's a list of issues, a boolean, or a report. It also lacks usage conditions and parameter semantics. For a tool with 0% schema description coverage and no annotations, the description is insufficient for an agent to call it correctly without additional context.

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

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

Schema description coverage is 0%, so the description must compensate for parameter meaning. It provides no explanation of the required 'handle' or optional 'limit' parameters. An agent cannot determine what handle refers to (e.g., a plan handle, device handle, or config ID) or how limit influences results. 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 clearly states the tool performs an integrity check and lists specific items it validates (outdated signatures, broken links, orphans). This distinguishes it from sibling CRUD tools, though it doesn't explicitly name an alternative. The verb 'проверка' (check) plus resource (config integrity) is clear.

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

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

No explicit guidance on when to use this tool vs alternatives. It implies validation before modifications, but there is no statement of prerequisites, exclusions, or conditions. An agent would have to infer that it runs a read-only integrity check. Sibling tools are mostly mutation or lookup operations, so differentiation is weak.

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