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. The one-sentence description only states the action and does not reveal side effects, error behavior, validation rules, or return value semantics. Critical behavioral details like prop-name validation and name_hint being ignored are hidden in the schema descriptions, not the main description.

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

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

The description is a single short sentence with no redundant wording. It is appropriately concise for stating the core purpose. However, it is not front-loaded with any operational caveats, and while brevity is good, the lack of additional context is a weakness. Still, for what it contains, it is efficiently written.

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 7 parameters, a rich schema, and an output schema, the description is severely incomplete. It does not explain what the tool returns, how to interpret the response, or how it fits into the workflow (e.g., that the returned name must be used in connect). The schema provides substantial detail, but the description fails to offer any usage context or integration 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 71%, so the baseline is 3. The description itself adds no parameter information, but the schema includes detailed descriptions for most parameters (e.g., props, in_ports, name_hint, allow_unknown_props). The description does not compensate for the ~29% of undocumented parameters, but the baseline holds because the schema largely covers the semantics.

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

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

The description clearly states the action ('Добавить' - add) and the resource ('блок на главную страницу проекта' - block to the project's main page). It is unambiguous and distinguishes from sibling tools like list_blocks, connect, or set_block_param, which perform different operations. The Russian phrasing is specific enough for an agent to know exactly what the tool does.

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

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

The description provides no guidance on when to use this tool versus alternatives. It does not mention prerequisites (e.g., an open project), exclusions, or contexts where a different tool would be more appropriate. Some usage hints appear in the parameter descriptions (e.g., name_hint tells the agent to use the returned name in connect), but the main description itself lacks any such guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It only states the action and does not mention whether unsaved changes are lost, whether confirmation is required, or whether the close is reversible. For a state-changing tool, this is a notable 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 sentence with no filler, so it is concise. However, it largely restates the tool's title and adds no distinguishing details, making it minimally informative rather than genuinely useful.

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

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

For a zero-parameter tool with an output schema, the description covers the basic action, but it omits usage conditions and side effects. With no annotations, the agent cannot tell whether closing the project might discard unsaved work or require an open project.

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

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

The tool has zero parameters and an empty input schema, so there is nothing for the description to clarify. Per the rubric, zero parameters earns the baseline score of 4.

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

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

The description uses the specific verb 'Закрыть' (close) and identifies the exact resource, 'текущий проект' (current project). This clearly distinguishes it from sibling tools like open_project, create_project, and save_project.

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 close_project versus alternatives, what prerequisites exist (such as a project being open), or when it should not be used. The description simply restates the action without adding 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 provided, the description carries the full burden, and it delivers richly: it discloses that the line is remembered but not routed yet, explains why immediate NormalizeWire produces bad geometry (blocks stacked at 0,0 generating points like (-160,-1056)), and notes these points are never recalculated, leaving a crooked line even after layout. This is excellent behavioral disclosure backed by a version verification.

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 structure front-loads the purpose, then explains the deferred-routing gotcha efficiently. The specific coordinates and version date are detailed evidence for a real pitfall and earn their place, though slightly more verbose than strictly necessary.

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 4-parameter tool with a documented schema and an output schema present, the description covers purpose, workflow timing, and the critical normalization pitfall. It does not cover error cases such as missing ports, but nothing essential for a correct call is missing.

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

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

Schema description coverage is 100%, so the schema already documents src, dst, in_index and out_index with adequate descriptions. The tool description adds contextual meaning about the connection operation but no parameter-specific detail beyond what the schema provides, so the baseline of 3 applies.

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

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

The description opens with a specific verb+resource: 'Соединить выход блока src с входом блока dst линией связи' (connect block src's output to block dst's input). This clearly distinguishes the tool from siblings like disconnect (opposite action) and add_block, and leaves no ambiguity about what resource is operated on.

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

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

The description gives workflow context by noting that routing is deferred to layout_place and warns against immediate normalization, which implies when this tool fits in the pipeline. However, it never explicitly states when to choose connect over alternatives (e.g., disconnect) or names exclusions, leaving usage timing mostly to inference.

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

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

With no annotations, the description carries the full burden. It discloses that the tool uses a specific template, that an empty project is insufficient, and that the previous open project is closed (a side effect). It also references documentation for environment specifics. This is substantial behavioral disclosure, covering key side effects and constraints. It doesn't mention error handling or return format, but the output schema covers that. Score 4 is appropriate.

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

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

The description is concise (a few sentences), well-structured, and front-loaded with the core purpose. It delivers the critical behavioral details (template choice, why not empty, closing previous project) without any fluff. Every sentence earns its place, and the structure is easy to scan. No redundancy.

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

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

For a tool with 2 optional parameters and no required ones, the description covers the essential aspects: template selection, rationale for not using empty projects, the side effect of closing the previous project, and a documentation reference. The output schema presumably covers return values. It doesn't mention potential errors or prerequisites, but given the simplicity and existing schema coverage, it is sufficiently complete. A 4 is fair.

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

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

Schema description coverage is 100%, so both parameters are already documented. The description adds extra context: end_time is changed via set_calc_time, and project_hint is just a message hint while the actual name is set by the environment. This goes beyond the schema's basic descriptions and clarifies the practical use of the parameters. Thus it adds meaningful value, earning a 4.

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 creates a new SimInTech project from a specific template ('empty model' but actually the delivery template). It distinguishes this from the default empty project and from sibling tools like open_project and close_project. The verb 'create' and resource 'project' are explicit, and the template distinction is a strong differentiator.

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

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

The description explains when to use this tool: to create a project with proper calculation settings, and explicitly warns against using NewProject or an empty project. It also mentions that the previous project is closed, which is important context. However, it doesn't explicitly state alternatives like open_project for existing projects, but the context is clear enough. It gives a usage scenario and a warning, so it's above average.

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?

This is unusually strong: it explicitly discloses that all session state is reset, that the client is zeroed, and importantly that the project previously persisted in a global variable. It warns that subsequent calls would use a dead ProjectId. This goes beyond what annotations (none) provide and clearly explains side effects.

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

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

The description is concise, with the core purpose front-loaded. The additional sentence about session state adds crucial context without surplus. Every sentence serves a purpose.

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

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

The description is complete for a zero-parameter tool: it explains what it does and the behavioral implications. However, it doesn't mention prerequisites (e.g., must be connected) or what happens after disconnection, but for a state-reset tool, the key side effects are covered. Output schema exists, so no return value explanation needed.

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

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

The tool has no parameters, so schema coverage is 100%. The description correctly notes there are no parameters and thus no further explanation is needed. The baseline for zero parameters is 4, and the description fulfills 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 states that the tool ends a session by closing the project and disconnecting from the COM server, which is clear in purpose. However, it does not explicitly distinguish itself from the sibling 'close_project', though the broader scope (session vs just project) is implied.

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 like 'close_project' or 'connect'. The description implies it is for ending a session, but without context on trade-offs or prerequisites, an agent may not know when to choose it.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It reveals a non-obvious implementation detail: parameter names are read from a local block catalog file rather than queried live from COM, and names vary by block class. This is meaningful transparency about data source and naming conventions, though it does not cover 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?

Three short sentences: a one-line purpose, an implementation rationale, and concrete examples. Every sentence adds information, and the purpose is front-loaded. The size is appropriate for the tool's complexity with no wasted words.

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

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

With an output schema present and the only parameter fully described in the schema, the tool description covers essential usage grounds: what it reads, how it sources names, and what names look like. It does not mention error behavior or explicitly route to set_block_param for writes, but for a single-parameter getter these are minor gaps.

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

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

The single required parameter 'block' is already fully documented in the schema with 100% coverage, including its source (list_blocks) and a caveat about renaming via COM. The description adds no input-parameter semantics beyond that; its examples concern output parameter names. Baseline 3 is appropriate because the schema does the heavy lifting.

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

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

The opening sentence 'Прочитать параметры блока' (read block parameters) is a specific verb+resource statement. It clearly distinguishes the tool from siblings like set_block_param and get_signal by targeting block parameter names. The catalog examples further clarify what kind of parameters are returned for different block classes.

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 reading block parameter names and explains that COM API cannot enumerate them, making this the tool to use for discovering parameter names. It does not explicitly name alternatives or state when not to use it, but the read/set contrast with set_block_param is clear enough. This is clear context without explicit 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 burden. It discloses that the tool returns an error when no signal database is present and notes that list_signals will report the absence directly. This is useful behavioral context, though it doesn't cover all error cases or side effects (e.g., permission requirements), which is acceptable for a read-only 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 three sentences, front-loading the purpose and immediately addressing usage constraints and alternatives. Every sentence earns its place with no redundancy or fluff.

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 an output schema, the description does not need to explain return values. It covers the core use case, error condition, and the correct alternative for a specific scenario. An agent has all necessary information to call this tool correctly.

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

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

The schema already describes the block parameter as the auto-name from list_blocks, and the description merely restates 'addressed by block name' without adding new syntax or format details. With 100% schema coverage, the baseline of 3 is appropriate; the description adds minimal extra value.

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

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

The description states a specific verb ('read') and resource ('signal'), and clarifies addressing by block name. It also distinguishes from set_signal and list_signals by implying read-only behavior and direct value retrieval, making it unambiguous.

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

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

It explicitly states the tool only works with a connected signal database, and that models created via create_project lack this database. It further advises using list_signals to check and read_output_file for self-made model results, providing clear when-to-use and alternatives.

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

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

No annotations are provided, so the description carries the full burden. It states 'return,' implying a read-only operation, and adds the important nuance of 'model time' rather than wall-clock time. However, it does not explicitly state the absence of side effects or any other behavioral traits beyond the immediate action.

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

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

A single, front-loaded sentence in Russian that accurately describes the tool without any fluff. It is concise and to the point, earning its place with zero waste.

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

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

For a simple zero-parameter getter with an output schema (not shown but present), the description is nearly complete. It conveys the core behavior. It lacks any mention of when to use it or caveats about the time format, but the output schema likely covers return details. Minor 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 tool has zero parameters and the schema coverage is trivially 100%. With no parameters to document, the baseline is 4. The description adds semantic value by clarifying that the returned value is the project's model time, which is not conveyed by the empty schema.

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

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

The description uses a specific verb and resource: 'Return the current model time of the project.' It clearly distinguishes this from siblings like set_calc_time or get_signal, which are about signals or setting time. An agent can immediately understand what the tool does.

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

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

The usage context is implied: retrieve the current model time. There are no explicit alternatives or exclusions, but given the simplicity and lack of competing getters for time, the absence of explicit guidance is acceptable. It is not misleading.

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 the full burden. It discloses that the tool intentionally omits a command list and points to `tools/list` as the source of truth, which is helpful behavioral context. However, it does not specify what the response format will be, and given the output schema exists, the agent might expect some structure but the description doesn't clarify.

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

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

The description is short and front-loaded with the purpose. It is concise with no redundant sentences. It might be slightly abstract for a non-technical agent, but the content is efficient.

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

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

Given the tool has no parameters, the description is sufficient for an agent to invoke it. It explains the purpose, mentions the alternative for tool listing, and is clear about the intentional omission. The output schema existence might give some clues about the response structure, so the description doesn't need to detail it.

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

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

The tool has zero parameters, and the schema coverage is 100%, which is trivially complete. The description adds value by explaining what the tool does not do (doesn't list commands) and what it does (explains workflow and points to tools/list). This exceeds the baseline expectation for a no-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 tool's purpose: providing help on how to work and where to find the tool list. It explicitly says it does not contain a command list, which distinguishes it from a generic help tool. However, it does not explicitly differentiate from siblings, so a 4 is appropriate.

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

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

The description implies when to use this tool: when the user needs help on workflow or where to find tools. It explicitly says that for a list of tools, one should use `tools/list`, providing a clear alternative. However, it does not state when not to use this tool beyond that.

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 and does so thoroughly. It discloses that this is a parse-only operation, that writing to computed parameters changes nothing, that values are instance-specific and not shown, and that connections/coordinates are not reliably recoverable. This gives an agent a realistic picture of the tool's capabilities and 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?

Although longer than a one-liner, the description is tightly organized: main claim first, then use case, then explicit what-it-provides and what-it-does-not sections. Every sentence carries functional information, and the limitations are separated into a clear list, so an agent can quickly extract the critical 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?

For a single-parameter inspection tool with an output schema, the description covers all essential context: what file it reads, where that file must live, how it differs from running the model, what results are available, and what limitations apply. Nothing an agent needs to decide whether and how to call this tool is missing.

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

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

There is only one parameter and the schema already documents it at 100% coverage, so the baseline is 3. The description adds value by tying the path to the results directory, comparing it to read_output_file, and clarifying that the file must be inside that directory. This extra context makes the parameter semantics clearer than the schema alone.

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

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

The description opens with a specific verb and resource ('Разобрать сохранённый проект (.xprt)') and immediately distinguishes itself from live simulation by stating it works without COM and on Linux. It then enumerates exactly what the parse yields (block classes and parameter names) and what it does not yield (connections, coordinates, calculation), making its role unmistakable among siblings like open_project, run, and connect.

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

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

The description clearly states when this tool is useful: inspecting a foreign model without launching the SimInTech environment, and on Linux where COM is unavailable. It also explains exclusions (no connection/coordinate recovery, no calculation, no parameter values). It does not name a direct alternative tool, but the context is strong enough for an agent to select it appropriately.

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 full burden and does so thoroughly. It discloses that coordinates are applied immediately, that block sizes are preserved (not changed), that wires are normalized after movement, and that only lines created in the current session are traced. It even mentions the historical flaw (previously only returned coordinates without moving blocks) and the technical limitation of COM not enumerating page lines. These are precisely the behavioral traits an agent needs to predict side effects.

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

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

The description is front-loaded with the primary purpose, then expands on critical behavioral details. It is longer than strictly necessary—some historical context (e.g., 'Раньше инструмент только возвращал координаты текстом') could be trimmed without losing essential guidance. However, every sentence contributes to understanding when and how to use the tool, and the structure is logical, so it earns a 4 rather than a 3.

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

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

Given the tool's complexity (applies layout, traces wires, interacts with connect), the description covers all necessary aspects: it states the action, the constraints (block sizes fixed, only session lines), the side effects (wire normalization), and the technical limitations. The presence of an output schema reduces the need to describe return values. Nothing critical is missing for an agent to decide when to call it and what to expect.

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

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

The input schema already describes both parameters (block_ids and connections) with examples and constraints, achieving 100% schema description coverage. The tool description does not add meaningful semantics beyond the schema—it mentions that position is set before calculation, but that refers to internal state rather than the parameters. It does not explain parameter formats or relationships beyond what the schema already states, so the baseline of 3 is appropriate.

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

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

The description clearly states the tool's core action: 'Расставить блоки по слоям без наложений — с применением координат' (arrange blocks into layers without overlaps, applying coordinates). It further clarifies that it actually moves blocks via set_center, unlike previous behavior that only returned coordinates. This verb+resource+outcome statement distinguishes it from siblings like connect (which creates wires) and list_blocks (which enumerates).

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 strong usage context: it is the only place where tracing of lines created by connect in this session is possible, and it explains why (blocks start at (0,0) overlapped). It also notes that lines from outside the session are unavailable. While it doesn't explicitly state 'use this instead of X', the exclusive tracing role and the mention that it applies coordinates serve as clear guidance. There's no explicit when-not-to-use, but the context is sufficient.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It only says 'output a list' and does not explicitly state read-only behavior, lack of side effects, required project/page state, ordering, or error conditions.

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

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

A single, front-loaded sentence with no filler. It is appropriately sized for a zero-parameter tool.

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

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

The description is minimally viable given no parameters and the presence of an output schema. It does not explain prerequisites such as needing an open project or what 'current page' depends on, which could matter for correct 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 tool has zero parameters and the schema is completely covered, so the description does not need to add parameter detail. The baseline for zero-parameter tools is 4.

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 and resource: 'list the blocks of the current page of the project.' It is clearly distinguishable from siblings such as list_signals, add_block, and get_block_params.

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

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

Usage is implied: call this tool when you need a listing of blocks in the current page. However, there is no explicit guidance about when not to use it or how it compares to related tools like list_signals or get_block_params.

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 burden of behavioral disclosure. It adds meaningful context: signals have descriptors, are readable via get_signal, and block names from XML are not readable, framing the output as a schema-content hint. This goes beyond the empty input schema and clarifies what the listed items represent.

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 short sentences with no filler. The main purpose is front-loaded, and the second sentence adds necessary semantic distinction between signals and block names.

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

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

For a zero-parameter listing tool with an output schema, the description provides sufficient context: what is listed, how signals are identified, and why block names appear. It could be slightly more explicit about output format, but the output schema likely covers that.

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

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

The tool has zero parameters, so the baseline is 4. The description does not need to explain parameters, and the empty schema already covers parameter semantics fully.

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 outputs readable project signals and block names separately, using a specific verb ('Вывести') and a concrete resource. It distinguishes itself from related tools by focusing on both signals and block names, though it does not explicitly name sibling tools like list_blocks.

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

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

The description implies when the tool is useful by explaining that signals are readable via get_signal and that block names cannot be read directly from XML, making this tool a source for those block-name hints. However, it does not explicitly state when to prefer list_signals over alternatives such as list_blocks or get_signal.

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 carries the full burden. It discloses a key non-obvious behavior: opening a project closes the previously open project. This is valuable. It also mentions the file extensions. However, it doesn't disclose other potential behaviors like error handling, behavior when the path is invalid, or whether the operation is destructive. Still, the disclosed side effect is significant, so a 4 is appropriate.

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

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

The description is two sentences with zero fluff. The primary action is front-loaded, and the secondary behavior is succinctly added. Every word earns its place.

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

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

For a simple one-parameter tool with an output schema, the description covers the main purpose and an important side effect. It lacks details on error conditions or return values, but those are partially covered by the output schema. Given the tool's simplicity, it's fairly complete, though not exhaustive.

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 the parameter. It does add meaning by implying the path should be to a .prt or .xprt file, which guides the agent. However, it doesn't explicitly state whether the path should be a file or directory, nor does it specify the expected format (absolute/relative). It's a modest improvement over the bare schema, so a 3 is fair.

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 opens an existing SimInTech project, with specific file extensions (.prt/.xprt). It uses a specific verb and resource, distinguishing it from sibling tools like create_project and close_project. However, it doesn't explicitly contrast with all siblings, leaving some differentiation to the reader.

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 behavioral note about closing the previous project, which hints at usage context, but it doesn't explicitly state when to use this tool versus alternatives (e.g., 'use this to open existing projects, use create_project to make new ones'). The guidance is implied rather than explicit, so it's adequate but not strong.

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 explains the file format (one time step per line with values), the restriction to the results directory, how relative paths are resolved, and that symlinks are expanded before checks so escaping via '..' or links is blocked. This is rich, actionable behavioral context.

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

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

The description is moderately long but every sentence adds value: purpose, usage, file format, workflow, and security boundaries are all clearly separated. The most important information is front-loaded, and the rationale for the directory restriction is concise rather than rambling.

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

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

For a two-parameter tool with an output schema, the description is complete. It covers what the file contains, how to produce it, how to reference it, and the security constraints. The agent has everything needed to invoke read_output_file correctly without further exploration.

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?

Although schema coverage is 100%, the description adds substantial meaning beyond the schema: absolute versus relative path resolution, the requirement that the file live inside the results directory, and the per-line format. It also clarifies the default directory and how to override it with SIMINTECH_OUTPUT_DIR.

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

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

The description clearly states a specific verb and resource: reading a text file of calculation results. It also distinguishes itself from the sibling get_signal by explaining that get_signal requires a signal database while this tool reads file output regardless. The scope 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 explicitly explains when to use this tool versus get_signal, and provides a full workflow: add_block('В файл'), connect, run, then read_output_file. It also states the security restriction on which directory may be read, so an agent knows the expected usage constraints.

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 fully carries the burden. It discloses critical edge cases: false success on missing calc layer, error reported via isError rather than text, and the dependency on project endtime. This level of transparency prevents an agent from misinterpreting results.

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

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

The description is dense and well-structured. It front-loads the core action, then methodically covers pitfalls and error semantics. Every sentence adds value, and the length is appropriate for the complexity—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?

Given the tool's complexity and the existence of an output schema, the description covers all essential behavioral aspects: success criteria, failure signaling, time constraints, and a pointer to a related tool. An agent has everything needed to call it correctly without guessing.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context for to_time by explaining its relationship to project endtime and the practical implication of setting it too high. It does not add detail to wait_timeout or stall_seconds beyond schema, but the added to_time insight justifies a 4.

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 (run project calculation) with an optional time limit, and distinguishes its behavior from a naive run by emphasizing the check on actual model time. This differentiates it from siblings like step and stop, making the tool's purpose specific and unambiguous.

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

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

It explains when the tool returns success without advancing time (no calc layer or disconnected inputs), and advises to check actual time rather than return code. It also explicitly mentions that to_time beyond project endtime is unreachable and directs to set_calc_time as an alternative. However, it does not explicitly contrast with step for incremental execution, leaving some ambiguity.

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

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

With no annotations, the description carries the full behavioral burden and does so exceptionally. It discloses that a project form is shown before writing unless show_form=False, and explains the subtle side effect of writing a "window hidden" flag that can make the project appear unopened in the GUI.

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 longer than average, but every sentence earns its place by explaining format differences or critical window-state behavior. It is structured with a clear opening statement, a bullet-style format comparison, and a focused paragraph on form behavior, making it readable despite the length.

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 output schema exists and the input schema fully covers the parameters, the description is complete enough for an agent to call the tool correctly. It covers parameter purpose, defaults, format selection, and a non-obvious behavioral side effect. No crucial information needed for invocation 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 coverage is 100%, so the baseline is 3, but the description adds real meaning beyond the schema. It explains why binary=True matters (native GUI format, double-click association) and what show_form=False actually does to the saved project's window state. The path parameter is not enriched beyond the schema's absolute-path note, but the other two parameters are significantly clarified.

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

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

The description opens with a specific action and resource: "Сохранить текущий проект в файл" (save the current project to a file). It further distinguishes this tool from siblings like create_project, open_project, and close_project by focusing on persisting the existing project rather than creating, opening, or closing it.

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 clear format-selection guidance: XML for readable/diffable/version-portable text, binary .prt for the native GUI format. It also explains when to use show_form=False (headless machines) and the consequences of doing so, though it does not explicitly compare save_project to alternative sibling tools or state 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 full behavioral burden and does so excellently. It discloses that the block is reinitialized via InitBlock, explains why this matters for already-initialized blocks, reveals that parameter names are validated before writing, and notes the special rejection of 'Name'. This is rich, non-obvious behavioral context.

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

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

The description is structured into three short paragraphs, each focused on a meaningful behavioral caveat. It is slightly longer than strictly necessary due to the historical note about the old warning, but that context justifies the design and every sentence contributes to correct usage.

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

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

Given the tool's complexity and absence of annotations, the description covers the critical lifecycle behavior, validation flow, and special-case rejection. An output schema exists, so return-value details are not required here. An agent has enough information to invoke the tool correctly, including handling edge cases.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra semantic value beyond the schema by explaining that 'Name' is rejected despite being in the catalog and by describing the pre-write validation behavior. This helps the agent understand constraints that the schema alone does not convey.

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

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

The description opens with a specific verb and resource: 'Установить параметр блока' (set block parameter) and reinitialize the block. It clearly distinguishes from siblings like get_block_params (reading params) and set_signal (signals), and is not a tautology of the tool name.

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

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

The description does not explicitly say when to use this tool versus alternatives or mention any exclusion criteria. It implies usage through its main verb, but there is no guidance about, for example, using get_block_params to discover valid parameter names or avoiding this tool for signal manipulation.

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 states the effect (calculation runs up to this time) and a constraint (run cannot exceed it). However, it does not disclose what happens if `seconds` is set after a run has started, whether it resets the simulation, or if it affects current state. It also doesn't mention if the tool is idempotent or if setting a smaller time than current truncates results. This is a moderate gap for a setting 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 remarkably concise: two sentences. It front-loads the purpose and then adds a key constraint. No unnecessary words; every sentence adds value.

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

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

Given that there is an output schema (though not shown) and only one parameter with full schema description, the description is nearly complete. It explains the core functionality and a critical limitation. However, it could benefit from noting any side effects or dependencies, such as whether this only affects future runs or also current simulation state. Still, for a simple setter, it is 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?

The schema provides 100% coverage with a description for the `seconds` parameter: 'конечное время расчёта в секундах (> 0).' This is clear and includes a constraint (>0). The description adds no additional parameter information, but with full schema coverage, the baseline is 3, and the schema's explicit constraint and unit justify a 4.

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 that the tool sets the end time for a project calculation, specifically the `endtime` of the calculation layer. It distinguishes itself from other time-related tools like `get_time` or `run`, which are siblings, by focusing on setting a limit. However, it does not explicitly mention that it is for setting (not getting) time, but the verb 'Задать' (set) 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?

The description implies usage: it is used to define the upper bound for calculations. It explicitly mentions that `run(to_time=…)` cannot exceed this value, which gives a clear constraint. However, it does not explicitly say when to use this tool vs alternatives like `run` or `step`, or when not to use it (e.g., when only a single step is needed). The context provided is useful but not comprehensive.

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 discloses one important constraint (requires connected signal database) but does not mention side effects, error handling, return value, or whether the write is synchronous. 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 exceptionally concise: two short sentences that state the action, the addressing method, and the key prerequisite. Every word earns its place, and the critical constraint is front-loaded. No redundancy or fluff.

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 write tool with two well-documented parameters and an output schema (per context), the description covers the core usage. However, it lacks details on failure behavior, return values, and the exact meaning of 'connected signal database'. It is adequate but not exhaustive; an agent might still need to infer edge cases.

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

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

Schema coverage is 100% for both parameters, with descriptions for block and value. The tool description adds no additional meaning beyond what the schema provides, merely echoing the block-name addressing. Since the schema already documents the parameters thoroughly, the description adds no extra value, warranting the baseline score of 3.

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 'write a value to a signal' and the addressing method (by block name). It distinguishes itself from get_signal by referencing it, and the verb 'write' makes the operation obvious. However, it does not explicitly name a sibling like set_block_param as an alternative, so it stops short of perfect differentiation.

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

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

The description gives a clear condition for use: only project signals with a connected signal database, and it mentions get_signal as a similar constraint. This implies when to use it (writing signals) but does not explicitly state when not to use it or point to alternatives. The guidance is present but not fully developed.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. 'Проверить доступность' clearly indicates a read-only diagnostic action and rules out mutation, which is meaningful given the absence of explicit readOnly/destructive hints. It could add more detail about failure behavior or timeouts, but for a zero-parameter status check the core behavior is transparent.

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

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

The description is a single short sentence with no filler. It front-loads the action ('Проверить доступность') and includes only the necessary scoping information (COM-server, SimInTech, Windows).

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

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

For a zero-parameter status tool with an output schema, the description is nearly complete: it identifies what is checked, the exact server type, and the platform. It does not narrate return values, but the output schema covers that, so the gap is minor.

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

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

The tool has zero parameters, so the baseline is 4. The description correctly adds no parameter details because none exist; the input schema is fully covered and there is nothing for the description to clarify.

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 ('Проверить' / check) and a specific resource (availability of the SimInTech COM server), with a useful platform qualifier (Windows). This clearly distinguishes it from sibling tools like connect, run, or get_signal, since it is a connectivity/availability check rather than a manipulation or data-retrieval 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?

There is no guidance about when to use this tool versus alternatives, nor any mention of prerequisites or typical call flow. The name and description imply it is a pre-flight health check, but the description does not explicitly say to call this before connect/run or how to interpret the result.

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 and does an excellent job: it discloses that actual model-time growth is verified, explains that ProjectStep can falsely report success, and states that the tool now refuses when time does not move. This is genuine transparency beyond what the schema or annotations provide.

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, front-loads the core action, and then adds the important behavioral caveat. The historical note about previous behavior is slightly extra but earns its place by clarifying the current failure semantics.

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

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

The description is complete enough for a single-parameter tool with an output schema: it explains what the tool does, how success is verified, and when it will refuse. It could be more complete by giving explicit guidance about when to choose step over run, but that is a minor 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 100%, so the parameter is already documented with its default and constraints. The tool description adds little beyond the word 'specified number', so it does not meaningfully improve on the schema. Baseline 3 is appropriate.

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

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

The description clearly states the tool executes a specified number of calculation steps ('Выполнить указанное число шагов расчёта'), naming both a concrete verb and resource. It does not explicitly distinguish itself from sibling tools like run or get_time, so it misses the last step of differentiation.

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

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

The behavioral note implies when the tool is unreliable (projects without a calculation layer or with unconnected block inputs), but it does not explicitly say when to use this tool instead of alternatives like run or set_calc_time. The usage context is mostly inferred from the core action rather than stated.

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

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

No annotations are provided, so the description carries the full burden. It discloses that the call is non-blocking, that it reports success even on a stopped project, and that state should be checked via get_time. This is valuable behavioral information beyond the schema.

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, front-loaded with the primary action, followed by the key behavioral caveats. It is concise and every sentence earns its place.

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

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

The tool has an output schema (not shown), so return values need not be described. The description covers the action, the non-blocking nature, and the false-success caveat, plus a pointer to get_time for state verification. This is complete for a zero-parameter stop 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?

There are zero parameters, so schema description coverage is trivially 100%. The description does not need to add parameter information, and it correctly omits it. Baseline for 0 parameters is 4.

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 explicitly states the action: 'Остановить расчёт' (stop the calculation). This is a clear verb and resource, and it is unambiguous among siblings like run, step, and get_time. It even adds a nuance about the success report, which further clarifies its 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 provides guidance on how to use it: it notes the call is non-blocking and does not confirm whether the calculation was running, and instructs to verify state via get_time. This gives clear context on usage and points to an alternative for verification, though it does not explicitly state when not to use it.

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

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

With no annotations provided, the description carries the full burden. It discloses that the tool parses the saved file without COM dependency, states the default column behavior (last column as model output), and explains the file column convention. It doesn't explicitly claim non-destructiveness, but the read-only nature is strongly implied by 'reduce result to numbers.'

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 short paragraphs, each with a distinct purpose: purpose, usage context, and parameter/file-format detail. The core intent is front-loaded in the first sentence, and there is no redundant or filler content.

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

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

Given an output schema exists (though not shown here), the description doesn't need to explain return values. It covers purpose, usage, file format, and parameter behavior. It could mention error handling (e.g., missing file), but that's not critical for an agent to call it correctly. Overall, it's sufficiently complete for a summarization 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?

Schema coverage is 100% for both parameters, so the schema already documents `path` and `column`. The description adds context about the file format (column 0 = time, 1..n = values) and clarifies the default column selection, which slightly enhances understanding but doesn't add critical semantics beyond what the schema provides.

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

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

The description opens with a concrete verb and resource — "Reduce calculation result to numbers: range, min/max, average, slope." — and immediately distinguishes itself from `read_output_file`, which returns raw lines. This makes the tool's purpose unambiguous and differentiates it from its closest sibling.

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

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

The description explicitly names `read_output_file` as the alternative and explains when to use the summary instead: checking whether the curve hit expectations is easier with a compact summary than scanning hundreds of lines. It also notes the tool works without COM, which is a strong usage hint for environments lacking SimInTech.

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