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

The annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so safety is covered. The description adds that the result is a short combined summary (credits + subscription + storage), but says nothing about freshness, auth requirements, or what happens with multiple accounts.

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

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

One compact sentence that front-loads the covered resources, followed by a short usage trigger; every clause earns its place. Slightly terse given the undocumented parameter, but no 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 read-only summary with no output schema, the description adequately conveys what data comes back. It is incomplete regarding the 'account' selector and its default behaviour, which matters because there are multiple account-related siblings.

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 single 'account' parameter, so the description must carry the meaning and it does not — it never mentions the parameter, whether it is optional, or what format it takes. An agent cannot tell whether omitting it returns the default account's overview.

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

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

The description names specific resources — credit balance, subscription, and storage usage — plus the verb 'short summary', so the agent knows this is an aggregated overview rather than a single-metric call. It does not explicitly distinguish itself from neighbours such as neurover_balance or neurover_subscriptions, which is the only thing keeping it from 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?

It gives one concrete trigger: use this for the question 'how many credits'. That is clear positive guidance, but there are no exclusions or named alternatives (e.g. when to prefer neurover_balance or neurover_subscriptions), so routing among the several account-related siblings is left partly to inference.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds genuinely new context that passwords are never returned, which tells the agent what it cannot retrieve here. It says nothing about pagination, ordering, or what happens with zero configured accounts, so it is additive but thin.

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 states the resource and immediately parenthesizes the one important caveat. No filler, no restatement of the tool name, nothing that could be trimmed.

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

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

For a zero-parameter read tool with full annotation coverage, the essentials are present: what it lists and that secrets are excluded. However, with no output schema, the description leaves the returned fields (ids, names, statuses) and any result-size or empty-list behavior entirely to inference.

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

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

The tool takes zero parameters, so there is no parameter meaning to convey and the baseline of 4 applies. The description correctly avoids inventing arguments such as filters, which would mislead the agent.

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

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

The description gives a specific verb and resource ("Список настроенных аккаунтов Neurover" = list of configured Neurover accounts), so an agent knows it enumerates accounts rather than modifying them. It does not explicitly distinguish itself from near-siblings such as neurover_account_overview, neurover_account_settings or neurover_auth_status, which is why 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?

There is no when-to-use or when-not-to-use guidance and no named alternative, despite a dense sibling set of account-related tools (account_settings, account_overview, auth_status, profile). The agent must infer that this is the enumeration call and that the others are configuration or status calls.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds the useful detail that the returned value is one of two login modes (manual vs system keychain), which is genuine return-value context since no output schema exists. It does not say what happens when the account is unconfigured or unknown, which is the main remaining behavioral 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?

One short sentence with no filler, and the key qualifier ('already configured') is placed early. It loses a point only because the sentence is a fragment that omits the action verb, so it is terse at the cost of 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?

For a simple one-parameter read tool with no output schema, the description does supply the return-value domain, which is the most important missing piece. However, it leaves the sole parameter and the unconfigured-account case unexplained, so it is only partially complete.

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

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

Schema description coverage is 0% and the single 'account' parameter is undocumented in both schema and description. The description never mentions the parameter, so an agent gets no guidance on its format (name, ID, email?) or what happens when it is omitted, despite it being optional.

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

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

The description identifies the subject as the login mode of an already-configured account and even enumerates the possible values (manual / system keychain), but it is a bare noun phrase with no verb, so it never states that the tool reads/returns this setting. It also does not distinguish itself from near-siblings such as neurover_account_setup, neurover_login, or neurover_account_overview.

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 when-to-use guidance at all: nothing says whether to call this before neurover_login, after neurover_account_setup, or instead of neurover_account_overview. The only implicit cue is 'already configured', which hints at a precondition but is not framed as one.

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

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

Annotations already declare readOnlyHint=true and non-destructive, and the description supplies the reason: the tool does not create the account itself, it returns a terminal command for the user to run, keeping the password out of chat. That is real behavioral value beyond the annotations. It stops short of saying what the returned command looks like or what happens after the user executes it.

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

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

One compact sentence, front-loaded with the action and immediately followed by the key mechanism and security constraint. No filler; the only cost is that the terse phrasing leaves the parameter unexplained.

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

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

For a one-parameter tool with no output schema, an agent still needs to know what to pass as "account" and roughly what the returned command is. The description covers the mechanism but leaves the input side entirely to an undocumented schema.

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

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

Wait — schema description coverage is 0% for the single "account" parameter, and the description never explains whether it is a name, an identifier, or optional. Since the schema documents nothing, the description must compensate and does not.

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

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

The description names a specific verb and resource ("Добавить новый аккаунт") and adds the crucial detail that the result is a terminal command rather than a performed action. It does not explicitly distinguish itself from siblings like neurover_accounts or neurover_login, 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?

Usage is implied by "добавить новый аккаунт" and the note that the password is never sent to chat, which hints at the onboarding scenario. However, no alternative is named (e.g., when to use this versus neurover_login or neurover_browser_login), and no prerequisites are stated.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, and the description corroborates with 'Меняет полотно', so the mutation semantics are consistent and reinforced. It adds a safety-style usage constraint beyond annotations, but says nothing about duplicate-placement behavior, positioning defaults, or what the call returns.

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, zero filler, front-loaded with the action before the restriction and the alternative. Nothing could be removed without losing a decision-relevant fact.

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?

Purpose, mutation warning and the alternative tool are covered, which is the critical part for a write tool with no output schema. However, with 0% schema coverage and a nested position object, an agent still cannot tell what 'position' means or what 'account' selects, leaving a real gap for a 4-parameter 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 description coverage is 0% across four parameters including a nested position object, so the description must carry the load. It only implies mediaAssetId ('существующим файлом медиатеки') and workflowId ('полотно'); the optional 'account' and the nested 'position' x/y coordinates get no meaning at all.

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

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

States a concrete verb and resource ('Поставить на полотно плитку с уже существующим файлом медиатеки') and immediately distinguishes it from the generation path by naming prepare_generation. An agent can tell this is a canvas-mutation action adding an existing media asset, not a new generation.

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

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

Explicit gating condition: 'вызывать только по прямой просьбе пользователя о плитках или полотне', plus the alternative route for normal generation ('Для обычной генерации — prepare_generation (через чат полотна)'). Both when-to-use and when-not, with the sibling named.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the mutation safety profile is known. The description adds genuinely new behavioral information beyond that: the tile is placed without launching, and the tool mutates the canvas, which justifies the "ask first" rule. It stops short of saying what the call returns (e.g. a new node id) or what happens if workflowId is invalid.

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, front-loaded with what the tool does, then the guardrail, then the alternative. Every clause carries decision-relevant information and none 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?

With six parameters, a nested position object, no output schema and zero schema descriptions, the definition is only partially sufficient: it clarifies purpose and trigger but leaves the agent guessing how to populate workflowId, position and modelId. Adequate for routing, thin 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% across six parameters, so the description must carry the load and largely does not. Only the type dimension is hinted at ("генерации или текста"), while the required workflowId, the nested position object, modelId and account are never explained; the enum's video/audio values are not even implied by the wording.

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

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

The description names a specific verb and resource ("Добавить ... плитку генерации или текста") and pins the scope with "на полотно" plus "без запуска", so the agent knows this creates a canvas tile without starting any generation. It explicitly separates itself from prepare_generation, which is the nearest competing action.

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

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

It gives both a positive trigger (only on a direct user request about tiles or the canvas) and an exclusion (ordinary generation goes to prepare_generation via the canvas chat). Nothing is left for the agent to infer about when this tool is the right choice.

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

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

Annotations already declare read-only, non-destructive, open-world behavior. The description adds the fallback role but does not clarify what 'known routes' contains, whether results are live vs. static, or how large the catalog is; with annotations covering safety, this is adequate but thin.

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, front-loaded with purpose and then the constraint. No redundant restatement of the tool name.

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 no-parameter discovery tool with no output schema, the description identifies the return ('список маршрутов') and a usage boundary. It leaves unclear what a route entry includes and whether the catalog is authoritative or live, which slightly limits interpretation of results.

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?

Zero parameters, so the schema coverage baseline is 4. No additional parameter semantics are possible or needed.

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

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

States a specific verb ('Список') and resource ('известных маршрутов API сайта') and adds a gating condition. It does not explicitly contrast with the nearest siblings neurover_api_read and neurover_api_write, so the agent must infer that those count as 'separate 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?

Explicitly says to use this only when no dedicated tool exists for the task, which is a clear exclusion rule against the many specific workflow, media, and account tools. It does not name the dedicated alternatives (e.g., neurover_api_read) or say whether this should be preferred over guessing endpoints.

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

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

The description confirms the operational scope (GET request to a route). While annotations already provide safety details (readOnlyHint: true), the description adds the necessary context that this is a generalized web-reading operation, though it lacks specific behavioral details like expected latency or failure modes.

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 definition is extremely concise. It uses only two short sentences to define its function and its selection criteria, ensuring zero wasted language.

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

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

Despite the high-level purpose, the tool is complex with five parameters (account, route, page, query, params). Since the description provides no guidance on how to construct valid inputs for these complex parameters, it is contextually incomplete for a robust agent.

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

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

The description fails to add semantic meaning to the complex input parameters (route, query, params). With 0% schema description coverage, the tool does not clarify the functional difference between these inputs (e.g., should 'params' be used for path variables vs. 'query' for URL 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 provides a clear purpose: reading any website GET route. Furthermore, it explicitly distinguishes itself from the numerous sibling tools by stating it should only be used when no separate specific tool exists.

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 guideline is highly effective. It instructs the agent on when *not* to use the tool (when a specific tool is available), which is extremely helpful for an agent navigating a large API catalogue like the one 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?

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety profile is covered; the description adds the valuable constraint that paid operations must go through prepare/submit. However, it says nothing about the confirm flag, expectedWorkflowVersion optimistic-concurrency semantics, or what happens on failure — all behavioral traits the annotations do not convey.

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, zero filler, with the mutating nature stated first and the usage constraints immediately after. Every clause carries information the agent needs before invoking.

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, open-world, seven-parameter generic write with no output schema and no schema documentation, the description is thin: it does not explain how to obtain valid routes, what confirm or expectedWorkflowVersion do, or what a response/error looks like. The usage gate is helpful but far from sufficient for a tool of this complexity.

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

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

Schema description coverage is 0% across seven parameters, and the description compensates for none of them — route, method, data, params, account, confirm and expectedWorkflowVersion carry no meaning beyond their bare names. At best it implies that a route and a write method are involved, which the schema already states via required/enum.

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

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

The first sentence names a specific verb and resource pair ('Изменяющий запрос к маршруту сайта'), so an agent knows this is a generic mutating HTTP call rather than a domain operation. It is distinguishable from the many named siblings (add_node, delete_media, etc.) precisely because it is the fallback for routes lacking a dedicated tool, though 'маршрут сайта' stays vague about what routes are actually valid.

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

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

Explicitly gates usage with 'Только если нет отдельного инструмента' and carves out a hard exclusion for paid runs ('платные запуски — только через prepare/submit'), which routes the agent to neurover_prepare_run/neurover_submit_generation. What it omits is discoverability: the sibling neurover_api_catalog, the natural way to find valid routes, is never named.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that: no information about pagination behavior, ordering, retention window, or what entries contain. For a log-reading tool with an open-world hint, the description contributes essentially no 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?

It is a single short phrase with no wasted words, but brevity here comes from under-specification rather than tight writing. There is no front-loaded verb or scoping clause to anchor the agent, so the economy does not help selection.

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 two undocumented parameters, no output schema, and no description detail, an agent cannot know what the log entries look like or how to page through them. The annotations cover the read-only/non-destructive profile, but the functional gaps remain substantial for a data-retrieval tool whose results drive downstream reasoning.

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 two parameters, so the burden is entirely on the description, which only obliquely hints at 'account' via the word 'аккаунта'. It says nothing about what 'page' controls, pagination size, defaults, or whether account filtering is expected. This is a clear compensation failure.

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

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

The description identifies the resource as an account action/security journal, which tells an agent broadly what data it returns. However, it is a bare noun phrase with no verb and no differentiation from nearby siblings such as neurover_statistics, neurover_notifications, or neurover_auth_status, which could plausibly cover overlapping ground. The intent is inferable but not sharp.

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 at all on when to call this versus the many adjacent account/audit-related siblings. No prerequisites, no mention of what kinds of questions this log answers, and no exclusions are given. The agent must guess 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?

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so safety and network reach are covered. The description adds useful behavioral context - no credentials or browser needed, i.e. it never triggers a login flow - but says nothing about what the result looks like or whether it can fail with a network error.

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 short sentence with no filler; the key qualifier (no login, no browser) is present and nothing is redundant. It is arguably too terse rather than too verbose, but structurally sound and 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 tool itself is simple and the annotations cover its safety profile, so the description is close to complete for invoking it. Because there is no output schema, the description should have said what 'active' returns (boolean, expiry, account identity), and it should have explained the 'account' parameter - those two gaps keep it at adequate rather than complete.

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

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

There is one optional parameter, 'account', with 0% schema description coverage, and the description never mentions it. An agent cannot tell whether 'account' scopes the check to a named session or is ignored, leaving the single input entirely unexplained in both schema and prose.

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

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

States a specific verb and resource: check whether the session is active. The qualifier 'without login and without browser' implicitly separates it from the sibling auth tools neurover_login and neurover_browser_login, so an agent can tell it apart without opening a schema, though it never names those siblings 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?

Usage is implied by 'without login and without browser' - this is the cheap pre-check before triggering a real login - but the description never explicitly says when to prefer it over neurover_accounts or neurover_login. The agent must infer that this is the non-interactive session probe.

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

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

The description successfully adds context by specifying the types of information exposed (tariffs, history, subscription), which enhances the understanding of the tool's output data beyond what the general 'readOnlyHint' annotation provides.

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 definition is concise and highly effective. It uses minimal words to summarize a complex page view, placing the most critical information immediately at the beginning.

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 high-level functional purpose is complete, but the lack of detail regarding the mandatory parameters makes the tool definition incomplete for practical execution by an agent.

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

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

Despite being a 2-parameter tool, the description is completely silent on how the parameters ('page' and 'account') are used or what values they represent. Given 0% schema coverage, the description must define these semantics, but it fails to do so.

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 provides an extremely clear definition of the tool's purpose: viewing the entire 'Balance' page. It specifically lists the included elements like tariffs, current subscription, and payment history, leaving no doubt about its function.

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 focuses entirely on describing the tool's functionality and content, providing no guidance on when to use it versus alternatives or under what operational conditions it is most 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?

The annotations only declare readOnlyHint=false, openWorldHint=true and destructiveHint=false, and the description adds genuinely new behavior: a visible browser window opens, a human must complete the login, and the session is persisted on the second call. It does not cover failure modes (e.g. calling finish=true without step 1, or what happens if the window is closed without finishing).

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?

Front-loaded purpose sentence followed by a compact enumeration of the two steps; every sentence carries operational information and there is no filler.

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

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

For an open-world, human-in-the-loop fallback tool with an output schema absent, the description covers the happy path well but leaves the account parameter unexplained and says nothing about timeouts, interruption, or what is returned after the session is saved.

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 carries the burden. It fully explains the meaning of finish through the two-step protocol (false opens the window, true saves the session and closes it), but the account parameter is never mentioned, leaving half the parameters undocumented.

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

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

The description states a specific verb and resource (fallback login via a visible browser window) and immediately scopes it to the case where the normal login hits a CAPTCHA, which distinguishes it from the sibling neurover_login. An agent can tell which tool handles which situation without opening either schema.

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

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

It gives an explicit trigger condition (use only when the ordinary login asks for CAPTCHA) and a precise two-step invocation sequence, including when to pass finish=true. The only gap is that it references the alternative as 'обычный вход' rather than naming neurover_login outright.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description usefully clarifies that entries are per-generation cost figures, but says nothing about ordering, pagination behavior despite a 'page' parameter, result size, or account scoping. Given annotation coverage, this is a moderate contribution rather than a rich one.

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 short sentence with the key noun front-loaded and zero filler. It is efficient, though its brevity sits close to under-specification rather than tight editing.

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 paginated history endpoint with no output schema and a totally undocumented parameter set, the description leaves too much open: what a record contains, ordering, whether results are account-scoped or global, and how pagination terminates. The one useful addition, the per-generation cost framing, is not enough for the tool's complexity.

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 neither 'page' nor 'account' is documented anywhere. The description adds no meaning to either parameter — not the page size, not whether 'account' is an identifier or a name, not what happens when it is omitted. Baseline 3 applies only because there are just two simple, partially self-evident parameters, but the description does not compensate for the coverage gap.

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

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

The description names a specific resource and what it contains: charge history of credits, with a clarifying parenthetical 'how much each generation cost'. This is a concrete verb+resource statement an agent can act on, though it never distinguishes itself from near-siblings such as neurover_balance, neurover_statistics, neurover_audit, or neurover_generations.

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 when-to-use guidance and no exclusions. With many cost/usage-adjacent siblings (balance, statistics, audit, generations, subscriptions), the description never says which one answers which question, leaving the agent to guess from names 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?

The description's key behavioral claim, 'Ничего не удаляет' (deletes nothing), directly contradicts the supplied destructiveHint=true annotation, leaving the agent unsure whether approving is itself destructive or merely authorizes deletion downstream. The step framing and per-group choice semantics are genuinely useful context beyond the annotations, which is why this is not a 1, but the safety-relevant conflict is significant given there is no output schema to clarify the effect.

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 clauses, front-loaded with the step number and the action, with no filler or redundancy. It is efficiently structured, though the final reassurance clause is the one that introduces ambiguity rather than 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?

For a 7-parameter, nested-object approval step inside a destructive cleanup workflow with no output schema and no helpful annotations, this is thin. It omits what 'mode' changes, what happens after approval (does a later step delete?), and whether groupRetention overrides retention, all of which an agent needs 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 carry the parameter burden, and it does not. It hints at per-group selection ('по группам', keep_one/delete_all), but those values are already visible in the enums, while the critical 'mode' distinction (metadata vs hash), jobId, the required confirm flag, and allowUsedOnCanvas are entirely unexplained.

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

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

The description names the operation precisely: step 4 of duplicate cleanup, which records the user's per-group choice (keep one copy / delete all). That is a specific verb plus resource and it positions the tool in a multi-step pipeline, which separates it from siblings like cleanup_scan or cleanup_start. It stops short of explicitly contrasting with the closely named neurover_cleanup_approve_files, so it is not 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?

Sequencing is only implied by the phrase 'шаг 4' (step 4), which suggests it follows scan/report and precedes apply/verify, but no explicit when-to-use or when-not-to-use rule is given. Nothing says how this differs from neurover_cleanup_approve_files or neurover_cleanup_step, and there is no mention of prerequisites such as an existing jobId or a completed scan. Usage is inferable but not stated.

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

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

The line 'Ничего не удаляет' is the only behavioral disclosure and it sits in tension with destructiveHint=true and readOnlyHint=false, since approving files does commit them to deletion downstream. The description never says what record is actually mutated, that confirm must be literally true, or that expectedUpdatedAt is a concurrency token that makes the call fail on stale state — all material for a non-read-only 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?

Two short sentences, front-loaded with the action, and no filler. However, the cryptic 'шаг 4 (вариант)' wastes the lead while the genuinely non-obvious facts — confirm=true and expectedUpdatedAt semantics — are omitted, so the brevity costs more than it earns.

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?

A four-parameter, all-required mutation tool with 0% schema coverage, no output schema, and a dense cleanup sibling family demands far more than two sentences. Missing are the stage/state invariant behind jobId, the staleness contract for expectedUpdatedAt, and what a successful 'fixation' returns or blocks.

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 all four required parameters depend on the description, yet only mediaAssetIds is obliquely covered ('точные id отдельных файлов'). jobId, confirm, and especially expectedUpdatedAt (an optimistic-locking token) are left entirely unexplained, which is the main source of misuse risk.

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 second clause states a specific verb and resource: record ('зафиксировать') the exact ids of individual files for deletion. The framing 'Очистка, шаг 4 (вариант)' is opaque and does not separate it from the highly confusable siblings neurover_cleanup_approve and neurover_cleanup_step, so the agent gets the action but not the 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?

Only the fragment 'шаг 4 (вариант)' hints at placement in a sequence; there is no explicit statement of when to pick this over neurover_cleanup_approve or neurover_cleanup_step, no prerequisites (must a scan/report have produced the jobId?), and no note on whether a follow-up apply step exists.

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

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

Annotations already declare this is a non-read-only, non-destructive, open-world mutation, so the safety profile is partly covered. The description adds nothing beyond that: it doesn't say whether cancellation is reversible, whether in-flight cleanup work is aborted, whether a jobId must reference an active job, or what happens on an invalid/already-finished job.

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?

It is a single short, front-loaded sentence with no filler, which is good. But it is sized far below what this mutation tool needs, so the brevity reflects under-specification rather than efficient communication.

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?

A one-parameter mutation tool with no output schema and no annotations explaining outcomes needs the description to cover effect, reversibility and error conditions; none of that is present. Combined with 0% schema coverage, the agent is left guessing what cancelling actually does.

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 only information about the single required jobId is its type/format/pattern from the schema. The description never says that jobId identifies the cleanup job to cancel, whether it must be active, or how to obtain it (e.g. from cleanup_start/cleanup_status).

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

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

The description names a verb and resource ("Отменить оставшуюся очистку" = cancel the remaining cleanup), which is more than a tautology. But with siblings like neurover_cleanup_pause, neurover_cleanup_status and neurover_cleanup_step, it never explains what distinguishes cancelling from pausing, so an agent cannot route confidently among them.

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

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

There is no when-to-use guidance at all: no mention of prerequisites (a running cleanup job), no contrast with cleanup_pause, and no note about what happens to already-completed cleanup steps. The agent must infer everything from the tool name.

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

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

Annotations declare readOnlyHint=false, openWorldHint=true, destructiveHint=false, so the safety profile is known and the description does not contradict it. Beyond that, the description does not explain what 'new' actually does – whether it resets prior cleanup state, creates a fresh job, or reuses the supplied jobId – which matters for a non-read-only call. With zero annotation contradiction present, the gap is disclosure, not conflict.

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 short sentence with no filler; the precondition is front-loaded in a trailing clause. It is appropriately sized but too thin to be fully efficient, since brevity here comes at the cost of 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?

For a non-read-only tool with an undocumented UUID parameter, no output schema, and five closely related cleanup siblings, one sentence is not enough. The agent lacks the lifecycle context (where this sits between cleanup_scan, cleanup_step, cleanup_cancel) needed to call it with confidence.

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

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

Schema coverage is 0%, so the single required jobId parameter is completely undocumented. The description does not mention jobId at all, leaving it ambiguous whether it identifies the finished cleanup being followed on or the new analysis being created – a material distinction for a UUID-constrained 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 gives a verb ('Начать новый разбор' – start a new analysis) plus a precondition (after a completed or cancelled cleanup), so the general intent is discernible. However, 'разбор' is never defined in this tool family's vocabulary, and nothing distinguishes it from the neighbouring neurover_cleanup_start or neurover_cleanup_scan siblings.

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

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

The phrase 'после завершённой или отменённой очистки' implicitly states the triggering condition, which is a useful when-to-use hint. It says nothing about when not to use it, and does not point to cleanup_start or cleanup_step as the alternative for the initial or mid-run 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?

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real behavioral value by disclosing the timing semantics — the pause only takes effect after the current chunk finishes. It omits whether the pause is resumable, how long the paused state persists, and what the caller should observe afterwards.

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

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

One short sentence with zero filler and the action front-loaded. It is efficient but borders on underspecified rather than being deliberately 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?

For a state-mutating control tool with no output schema and an undocumented required parameter, the definition says too little: no indication of which jobId to supply, whether a paused job can be resumed, or how to confirm the pause took effect.

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 sole parameter 'jobId' is undocumented in both schema and description. The description never says the id must be a cleanup job id (from cleanup_start or cleanup_scan) rather than a workflow or generation id, which is a real ambiguity given the many id-bearing sibling tools.

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

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

States a specific verb and resource ('Приостановить фоновую очистку') plus a scope qualifier ('после текущей порции') that subtly separates it from neurover_cleanup_cancel. It never names the sibling explicitly, so an agent must infer the pause-vs-cancel distinction.

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

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

The phrase 'after the current portion' implies this is the graceful stop option, which hints at when to prefer it over cancellation, but no alternative tool is named and no preconditions (e.g. an active cleanup job id is required) are stated.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is partly covered. The description adds only that a reportUrl is produced. It says nothing about the groupRetention parameter, which accepts "delete_all" and clearly implies a destructive retention decision — a major behavior left undisclosed, especially given destructiveHint=false.

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

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

Two compact clauses with the step position front-loaded and the view options stated inline; nothing is padding. Slightly information-dense in a way that assumes the reader knows the cleanup flow, but it 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?

For a 3-parameter tool with a nested object, no output schema and no schema descriptions, the definition is thin: jobId's origin, the meaning of groupRetention, and what the reportUrl actually points to are all missing. An agent could not safely decide whether passing groupRetention here triggers real deletion.

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 carry the load. It explains the view enum values (duplicates vs library) well, but jobId is unexplained and the nested groupRetention map (group id -> keep_one/delete_all), the most consequential parameter, is never mentioned at all.

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

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

The description identifies the action ("открыть галерею для пользователя") and positions it as step 2 of duplicate cleanup, which is more than a restatement of the name. However, it never clarifies whether the result is a UI view, a generated report URL, or a persisted artifact, and it does not distinguish it from siblings like cleanup_status, cleanup_verify or cleanup_step.

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?

"шаг 2" implies sequencing — this is called after a scan/step 1 — which is genuine, if terse, usage context. There is no explicit when-not guidance and no named alternative among the many cleanup_* siblings (status, verify, approve, step, report), leaving the agent to infer the workflow order.

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?

Adds real context beyond annotations: it discloses asynchronous job semantics (a status of scanning means the scan is still running and the call should be repeated with the same jobId) and reassures that nothing is deleted, which aligns with destructiveHint=false despite readOnlyHint=false. It stops short of explaining what a completed scan produces or where that output is consumed.

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 compact sentences with the core purpose and the non-destructive guarantee front-loaded, then the retry rule. No filler, though the terseness leaves the surrounding workflow implicit.

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 an async scan tool with no output schema, it covers purpose, safety, and the poll-again rule, which is what an agent needs to invoke it correctly. The main gap is how an initial jobId is obtained and which sibling consumes the scan result.

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 four parameters, so the description carries the full burden. It only clarifies jobId (resume with the same value); kind, account, and workflowId receive no explanation, leaving an agent to guess at their meaning and interaction.

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

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

States a specific verb and resource: find similar files by metadata, as step 1 of duplicate cleanup, and explicitly notes it deletes nothing. The 'step 1' framing distinguishes it from the report/verify/approve siblings, though the exact boundary with cleanup_start, cleanup_step, and cleanup_new is left implicit.

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?

Gives one concrete usage rule — if status=scanning, retry with the same jobId — which is genuinely useful polling guidance. However, a crowded cleanup family (scan/start/step/status/new/report/verify/approve) is present and the description never says when to pick this tool over those 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?

Annotations already declare destructiveHint=true and openWorldHint=true, so the mutation risk is structured data. The description adds genuinely new behavioral facts: the work is asynchronous ('в фоне'), chunked ('порциями') and restart-resilient ('переживает перезапуск') — but says nothing about what happens to already-deleted files, whether the call is idempotent, or what handle it returns for tracking.

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 dense sentence with the action front-loaded and the behavioral caveats trailing. Nothing is padded or repeated from the annotations.

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, asynchronous, no-output-schema tool the description covers the essential async/resumable traits, but leaves the monitoring path (cleanup_status), failure behavior and the origin of jobId undocumented. The Russian-only text may also mismatch the language of the surrounding toolset.

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?

Only one parameter, jobId, with 0% schema description coverage — the schema gives just a uuid format. The description implies the id refers to an approved cleanup job but doesn't say where to obtain it (cleanup_scan/approve) or whether a stale id is rejected.

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

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

States a specific verb and resource: 'запустить одобренное удаление' (start the approved deletion) as step 5 of cleanup. The sequencing marker and the word 'одобренное' separate it from cleanup_scan, cleanup_approve and cleanup_step, though it never names those siblings 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?

'Шаг 5' and 'одобренное удаление' imply a prerequisite (approval must already have happened), which is real ordering guidance. However, it never says what to do instead if the job isn't approved, nor points to cleanup_status for monitoring or cleanup_pause/cancel once running.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds nothing beyond that: no indication of whether the status is pollable, what states exist, or whether the job may have expired — all of which matter for an async job-status endpoint.

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?

It is a single short sentence with no wasted wording, and the key information is front-loaded. But brevity here comes at the cost of under-specification rather than efficient communication.

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, no output schema, and no annotations explaining return values, the description is the only place an agent could learn what a status response contains or how to interpret it. It supplies none of that, so the definition is not complete enough for correct invocation in a cleanup workflow.

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

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

Schema description coverage is 0% for the single parameter, so the description must carry the burden. "по jobId" only confirms that the UUID identifies a cleanup job; it does not say where the jobId originates, whether it must be from a cleanup_start call, or what happens if the job is unknown.

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?

"Статус очистки по jobId" names a specific resource (cleanup status) and the key it is looked up by, so the basic purpose is inferable. However, it does not distinguish this from the many sibling cleanup tools (cleanup_report, cleanup_verify, cleanup_scan, cleanup_step), leaving the agent to guess how a 'status' differs from a 'report' or 'verify'.

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 when-to-use guidance, no mention of when a jobId exists, and no pointer to the tools that produce a jobId (cleanup_start / cleanup_new). The agent must infer usage entirely from the name and the single required parameter.

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

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

The annotations already declare destructiveHint=true, openWorldHint=true, and readOnlyHint=false, so the safety profile is covered by structured data. The description adds real value by stating that only already-approved items are removed and by disclosing a secondary after-failure verification mode. It does not explain irreversibility, partial-failure semantics, required permissions, or whether a second call resumes or repeats the batch, which a destructive pipeline step should cover.

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?

It is a single short sentence with the step identity front-loaded, so it is not bloated. But the trailing "также проверка..." clause is bolted on without structure and creates ambiguity rather than compactness, so the terseness costs more than it saves.

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, open-world step in a multi-tool cleanup pipeline with no output schema and zero parameter documentation, the description is thin. It omits the meaning of jobId, the batch/wait tradeoff, and what the agent should do after a partial or ambiguous failure, leaving an agent unable to call it correctly in the failure-recovery case it explicitly advertises.

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

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

Schema description coverage is 0% across three parameters, so the description carries the full burden and largely fails. "Одна порция" loosely maps to batchSize but gives no guidance on choosing a size within the 1-50 range, and neither waitSeconds nor the required jobId is mentioned at all – an agent cannot tell whether jobId is the cleanup job from cleanup_start or something else.

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

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

The first clause gives a specific verb and resource ("удалить одну порцию одобренного" – delete one batch of approved items), which is more than a restatement of the name. However, "шаг 5 (ручной режим)" references an undefined step pipeline, and the appended clause "также проверка неясного результата после сбоя" makes it unclear whether this is fundamentally a delete or a verify tool. It does not distinguish itself from cleanup_approve, cleanup_verify, or cleanup_start, so an agent cannot reliably route between them.

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

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

"Ручной режим" implies an automatic counterpart exists, and "после сбоя" hints at a recovery-use case, but neither is spelled out as a when-to-use rule. There is no statement of when to prefer this over cleanup_start, cleanup_approve_files, or cleanup_verify, and no prerequisites such as needing a prior approval step. Guidance is inferable at best.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, and the description's "deletes nothing" is consistent with that safety profile rather than contradicting it. It adds the background/asynchronous trait, but says nothing about cost (hashing reads file bytes, maxBytes bounding), what happens on a hash mismatch, or how results surface.

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 clauses, front-loaded with the step number and operation, with no filler. It is terse to the point of omitting needed detail, but nothing present is wasted.

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?

A five-parameter, nested-object tool with no output schema and 0% schema documentation needs more than this. An agent cannot tell what verification returns, how mismatches are reported, or how groupRetention interacts with the 'deletes nothing' promise before calling it.

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

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

Schema description coverage is 0% across 5 parameters, so the description must carry the load — yet it only explains 'background'. The purpose of groupIds, maxBytes (a size cap), and especially the nested groupRetention map with keep_one/delete_all values is left entirely to inference; the latter also sits awkwardly beside the claim that nothing is deleted.

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

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

The description names a specific operation (SHA-256 verification of originals in selected groups) and places it as step 3 of the duplicate-cleanup flow, which distinguishes it from siblings like neurover_cleanup_scan or neurover_cleanup_approve. It does not explicitly name the sibling it should be chained with, but the verb+resource 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?

It marks the step as optional and notes background=true runs asynchronously without waiting, which implies when to use it. However, it never says when to skip it, what precondition (a prior scan/step-2 result) is required, or where to fetch the verification outcome — guidance that matters for a multi-step cleanup flow.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so a baseline of safety context exists. The description adds nothing beyond 'makes a copy' – it does not say what gets copied (graph, nodes, media references, settings), whether the copy lands in the same account, or what identifier comes back. Since the tool is a write that reaches a remote service, this silence is a real 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?

A four-word sentence fragment is technically concise and front-loaded, but the sizing problem here is under-specification rather than verbosity. No structure, no differentiation, no detail an agent could act on beyond the tool name.

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 non-read-only, open-world mutation tool with zero parameter documentation and no output schema, one short sentence is completely inadequate. Nothing tells the agent what a successful clone produces or how to reference it afterwards.

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 two parameters, so the description carries the full explanatory burden and does not meet it. The word 'копию' faintly implies workflowId identifies the source canvas, but the optional 'account' parameter is entirely unexplained in both schema and description. Only the barest hint of parameter meaning is added.

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 plus object ('Создать копию полотна'), so the agent can tell this duplicates something. However, it calls the resource 'полотно' (canvas) while the tool name says 'workflow', and it never distinguishes the operation from sibling copy-like tools such as neurover_create_workflow or neurover_node_duplicate. The intent is inferable but not sharply scoped.

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 when-to-use guidance at all: nothing says whether this is the right call instead of creating a workflow from scratch or duplicating individual nodes. No preconditions (account selected, workflow existing) are mentioned. The agent must guess from the name alone.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false; the description adds the meaningful behavioral facts that the call mutates the canvas and requires a direct user request as a consent gate. It stops short of stating what happens when an edge already exists, whether handles are validated, or how to undo, so it is helpful rather than complete.

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 in parentheses-prefixed structure: action, precondition, alternative. The mutation warning and the sibling routing are front-loaded, and no sentence is filler.

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

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

For a mutation tool with annotations but no output schema, the description covers purpose, consent precondition, edge-creation guidance, and the correct alternative. Remaining gaps are duplicate-edge behavior, failure modes, and the undo path via delete_edge.

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

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

Schema description coverage is 0% across 6 parameters, so the description must carry the load. It does add real meaning for sourceHandle/targetHandle by saying to take them from the graph/model schema, but says nothing about workflowId, sourceNodeId, targetNodeId, or account, leaving most parameters unexplained.

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

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

The description names a specific verb and resource — 'Соединить две плитки связью' (connect two tiles with a link) — and clarifies that the handles come from the model graph/schema, which tells an agent exactly what operation is performed. It is clear against the mutation siblings on the canvas, though the domain term 'плитки' is left unexplained and the inverse operation (delete_edge) is never named.

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

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

Explicitly scopes invocation to 'только по прямой просьбе пользователя о плитках или полотне' and names the alternative for the common case ('Для обычной генерации — prepare_generation'). This gives both a when-to-use precondition and a when-not-to-use routing to a sibling.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, and the description is consistent with them by implying a creation operation. Beyond that it adds only that the new canvas is empty; it says nothing about persistence, whether the new workflow becomes active, or what is returned.

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

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

A single short sentence with no filler and the action front-loaded. It is efficient, though the brevity here reads as under-specification rather than disciplined concision.

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 mutating creation tool with a required parameter, no output schema, and zero schema documentation, the description is too thin. An agent cannot tell what it must supply or what a successful call produces, and must rely on the schema alone.

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

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

Schema description coverage is 0% and the description mentions no parameters whatsoever — critically, it never reveals that a `name` string (1-120 chars) is required, nor what `account` selects. With two fully undocumented parameters, the description fails to compensate for the schema gap.

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

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

The single sentence gives a verb and an object (create a new empty canvas), so the action is recognizable. However, it uses "canvas" (полотно) while the tool name and siblings speak of "workflow", and it does not distinguish this from siblings such as neurover_clone_workflow or neurover_workflows, which occupy adjacent territory.

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 when-to-use guidance at all — nothing says to prefer this over neurover_clone_workflow when duplicating an existing graph, nor what preconditions (e.g. an authenticated account) are needed. It is not misleading, but the agent must infer usage entirely.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, so the safety profile is covered. The description adds that the operation mutates the canvas and requires explicit user consent, but says nothing about reversibility, whether the edge can be recreated, or side effects on downstream nodes.

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, front-loaded with the action, then the gating condition, then the alternative. No redundant or decorative wording.

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

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

For a destructive mutation with no output schema and an entirely undocumented parameter set, the description covers intent and gating but not the mechanics of identifying the edge or what confirm enforces. Adequate to prevent accidental calls, but thin on execution detail.

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

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

Schema description coverage is 0% across four parameters, and the description contributes no meaning for edgeId, workflowId, account or confirm. The confirm boolean's const:true and the id types are only inferable from the schema itself, so the description fails to compensate for the documented coverage gap.

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

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

States a specific verb and resource in the first sentence: 'Удалить связь между плитками' (delete the connection between tiles), which is distinct from node operations. It does not explicitly name the neighbouring siblings neurover_connect_nodes or neurover_delete_node, so an agent must infer that this removes an edge rather than a tile.

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

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

Explicitly constrains when to call: only on a direct user request about tiles or the canvas. It also names the alternative path — prepare_generation via the canvas chat — for normal generation flows, so the agent has both the qualifying condition and the redirect target.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, so the description only needs to add workflow context; it does add the dryRun-first sequencing and the user-consent gate. However it never explains what confirm or allowUsedOnCanvas change about the destructive act, which is the most consequential behavior for a delete 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?

Two short sentences, front-loaded with the action and scope, then the safety rule. Very little wasted wording; the 'Сначала dryRun' clause is terse enough to be slightly ambiguous about whether dryRun is required or just recommended.

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?

A destructive, open-world tool with 7 undocumented parameters and no output schema. The description omits what happens on confirm=true, what allowUsedOnCanvas permits, and whether workflowId scopes the asset lookup, leaving too much for the agent to infer before an irreversible call.

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

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

Schema description coverage is 0% across 7 parameters, so the description must compensate. It only covers mediaAssetId/expectedName ('по id и точному имени') and hints at dryRun; confirm, allowUsedOnCanvas, account and workflowId are left entirely unexplained, including the safety-relevant ones.

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

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

States a specific verb and target: delete a particular file from the media library, identified by id and exact name. That distinguishes it in practice from sibling cleanup and reference-copy deletion tools, though it never names those siblings 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?

Gives real routing guidance: run dryRun first, and only delete when the user asks for it directly. It does not mention when a different tool (e.g. delete_reference_copies or the cleanup_* family) is the better choice, so it falls short of an explicit alternatives map.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false and openWorldHint=true, so the safety profile is covered upstream. The description adds genuinely useful context beyond that — that the underlying media file survives and the canvas is mutated — but says nothing about the required confirm flag, reversibility (is there an undo analogous to node_restore_last_success?), or the response. Given annotation coverage the bar is lower, but a destructive call deserves more than this.

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, front-loaded with the action and its side effect, then the call restriction, then the alternative. Every clause carries information an agent needs; there is no filler.

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

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

For a destructive, confirmation-gated mutation with no output schema and zero parameter descriptions, the definition covers intent and routing well but leaves gaps around the confirmation step and the account parameter. An agent could select the tool correctly yet still need to open the schema to call it, which is the modest shortfall against its complexity.

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

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

Schema description coverage is 0%, so the description carries the burden for all four parameters, and it explains none of them directly. The phrasing does weakly map "плитка" to nodeId and "полотно" to workflowId, but account and — critically — the mandatory confirm=true gate are entirely undiscussed, leaving an agent to discover the confirmation requirement only from the schema.

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

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

The description names a specific verb and resource ("Удалить плитку с полотна") and immediately scopes it with the reassurance that the media-library file remains. It also names a different tool, prepare_generation, for the normal generation path, so an agent can separate this destructive canvas edit from the creation workflow.

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 boundary is explicit: "вызывать только по прямой просьбе пользователя о плитках или полотне" states a precondition for calling, and "Для обычной генерации — prepare_generation" routes the agent to the alternative with the condition that selects it. Both a when-to-use and a when-to-use-something-else are present.

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 excellent behavioral disclosure: the description guarantees that 'sources and results are not touched' ('Исходники и результаты не трогает'). This vital scope information significantly enhances understanding beyond the generic 'destructiveHint: true' annotation.

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

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

The text is highly efficient and front-loaded. It addresses the What (delete utility copies), the Where (references), the Safety (sources/results untouched), and the How (dryRun first) in a very concise manner.

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 definition provides a complete conceptual picture of the tool: its target, its boundaries (what it won't affect), and its operational safety requirement. This is crucial given the destructive nature of the 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?

Given the 0% schema description coverage, the description is essential. It defines the target object type (utility copies of references) which provides the conceptual meaning behind the parameters it acts upon.

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

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

The description clearly identifies the function as deleting 'utility copies of references' and specifies the scope ('source_kind=reference_copy'), distinguishing this operation from deleting main sources or results.

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 explicit operational guidance by stating, 'First, dryRun,' which is critical for any destructive action. While it doesn't compare itself to siblings, it advises on a necessary sequence of use.

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, but the description adds the key nuance the annotations cannot convey: deletion is soft — the canvas goes to an archive on the server and only disappears from the list. It also states the confirm=true requirement. It does not say whether the archived canvas can be restored through this API or what the call returns.

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 compact sentences, with the action and its real-world effect front-loaded before the usage constraint. Nothing is redundant and nothing needs trimming.

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 tool, the description covers effect, soft-delete semantics, and the user-consent gate — enough to call it safely without an output schema. The remaining gap is the unexplained account parameter and the absence of any note on restore/reversibility.

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

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

Schema description coverage is 0% across three parameters, so the description carries the burden. It explicitly explains confirm=true and implies workflowId via "полотно", but the account parameter is never mentioned, leaving one of three parameters undocumented anywhere.

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

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

The description gives a specific verb plus resource ("Удалить полотно" = delete canvas/workflow), and the parenthetical clarifies the effect (archived server-side, removed from the list). It is clearly distinguishable from siblings like neurover_rename_workflow, neurover_clone_workflow, neurover_delete_node or neurover_delete_media, though it never names 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?

"Только по прямой просьбе пользователя, confirm=true" gives an explicit precondition for invoking the tool, which is exactly the gating an agent needs for a destructive operation. It stops short of naming alternatives (e.g. archive vs. node-level deletion) or stating what to do if the user is ambiguous.

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 cover only readOnlyHint=false / destructiveHint=false / openWorldHint=true; the description goes well beyond them by disclosing the exact data collected, an explicit privacy exclusion list (no email, passwords, cookies or prompts), that the artifact is written into the Downloads folder, and that nothing is transmitted to the author automatically. That last point is the behavior an agent most needs to know before invoking it.

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, front-loaded with purpose, then privacy guarantees, then the return value and the human follow-up step. Every clause carries information; nothing is restated from the title or schema.

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

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

There is no output schema, and the description compensates by stating exactly what is returned (a file path in Downloads) and what the caller must do next. Combined with the privacy scope and write-to-disk behavior, an agent has everything needed to decide and invoke.

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 input parameters, so the baseline is 4. The description does add useful meaning by clarifying that the report payload is gathered automatically rather than supplied by the caller, which heads off any attempt to pass content in.

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 ("Сохранить отчёт" / save a report) and immediately scopes it with the trigger condition "если что-то не работает". It then enumerates the exact contents (version, OS, login modes, app connections, recent-action log), which distinguishes it from nearby diagnostics-adjacent siblings like neurover_update_check or neurover_auth_status.

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 trigger condition for use is stated explicitly ("if something isn't working"), and the final sentence clarifies the follow-up workflow: the user must send the file to the author themselves. It does not name alternative tools or state when not to use it, which keeps it short of 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?

Annotations already declare readOnlyHint=false and destructiveHint=false, so the agent knows this performs a write without being destructive; the description correctly adds that the write lands at outputDir/fileName. It does not disclose overwrite behavior for an existing file, what happens if the generation is not yet complete, or any size/rate constraints, leaving notable gaps for a filesystem-writing 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?

Two short sentences with the step marker and the action front-loaded, then the one non-obvious parameter caveat. No filler or repetition of the tool name.

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 an 8-parameter tool with zero schema description coverage, no output schema, and filesystem side effects, the definition is thin: the required workflowId is never explained and four parameters are undocumented anywhere. The core mechanics are conveyed, but an agent could still mis-supply required inputs or mishandle an existing target file.

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

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

Schema description coverage is 0% across 8 parameters, so the schema carries no meaning. The description adds real semantics for 4 of them — messageId as the lookup key, outputDir as the destination, fileName as the output name, and mediaAssetId strictly as a selector among several results — but leaves workflowId (required), nodeId, account and details entirely unexplained.

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

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

The description states a specific verb and resource: 'Скачать готовый результат генерации' (download the finished generation result), plus the key inputs messageId, outputDir and fileName. The 'ШАГ 4' marker and the note that mediaAssetId only selects among multiple results distinguish it from siblings like neurover_download_media or neurover_wait_generation, though no sibling is named directly.

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?

'ШАГ 4' positions the tool in a generation pipeline and mediaAssetId's conditional use is explained, which implies when to call it. However, it never states prerequisites explicitly (e.g. that the generation must be finished, presumably after neurover_wait_generation), nor any when-not case, so the agent must infer the sequencing.

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

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

Annotations already declare a non-read-only, non-destructive, open-world operation, and the description is consistent with that by framing it as a file download. However, it does not say that files are written to a local directory, whether existing files at outputDir are overwritten, or what happens on a missing/invalid asset — meaningful context for a disk-writing tool that annotations do not cover.

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, purpose first and the sibling routing second — nothing redundant and nothing buried. The sizing matches the tool's modest scope.

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

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

There is no output schema and the description neither describes what is returned (path? bytes? status?) nor how the required outputDir argument is interpreted. With four undocumented parameters and a filesystem side effect, the definition leaves too much for the agent to infer before a correct call.

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

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

Schema description coverage is 0% across four parameters, and the description only hints at mediaAssetId ('по mediaAssetId'), leaving outputDir (required), fileName, and account entirely unexplained in both schema and description. For a tool where the caller must supply a local destination path, that is a real gap rather than a minor one.

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

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

The description states a specific verb and resource ('Скачать файл из медиатеки') and keys it to a named identifier (mediaAssetId), so the agent knows exactly which object class this acts on. It also contrasts itself with the generation-oriented sibling, making the boundary between the two 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 gives explicit routing: use this for media-library assets, and prefer download_generation for generation results. It stops short of saying where mediaAssetId comes from (e.g. neurover_media / neurover_ensure_media), which is the main usability gap, but there are no misleading cues.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, so safety is covered; the description usefully adds that this shows 'exactly what will go to the server', i.e. a non-submitting preview with warnings surfaced. It does not disclose token lifetime/expiry, what happens if the token is stale or already submitted, or error behavior — relevant for an openWorldHint tool keyed by a token.

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; the enumerated return contents are the useful part. The dash-separated list is slightly dense but adds information rather than noise.

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

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

For a one-parameter read-only tool with no output schema, the description does the important work of enumerating what is returned, which largely substitutes for a missing output schema. It still leaves gaps on token provenance and expiry, which an agent needs to call it successfully in an open-world, session-based workflow.

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

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

One required parameter with 0% schema description coverage: the schema only types it as a UUID pattern. The description partially compensates by saying the token identifies a 'подготовленный запрос', implying it originates from a preparation step, but it never says where the agent obtains that token or how long it stays valid.

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

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

States a specific verb and resource ('Показать подготовленный запрос по токену') and enumerates exactly what the result contains: final prompt, references table, settings, warnings. An agent can distinguish this read-only preview from write-oriented siblings like neurover_submit_generation or neurover_prepare_generation, though no sibling is named 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 phrase 'ровно то, что уйдёт на сервер' implies this is a pre-submission preview step, so usage is inferable. But there is no explicit when-to-use, no statement that the token must first be obtained from a prepare_* call, and no guidance on when to use this versus calling the preparation tools directly.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true. Beyond that, the description adds real behavior: the operation is content-deduplicating (find by content before uploading) and it writes only to the media library, never the canvas. It stops short of covering failure modes, whether a new asset is created on every upload, or any auth/quota constraints.

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 clauses, front-loaded with the outcome, then the mechanism, then the usage caveat. No filler and no repetition of the schema.

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

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

The return value (mediaAssetId) is explained in lieu of an output schema and the when-not-to-use case is fully covered, so the agent knows whether to call it. However, for a 7-parameter tool with zero schema descriptions, the unexplained workflowId and model/account fields leave the invocation underspecified.

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

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

Schema description coverage is 0% across 7 parameters, so the description must carry the meaning. It only implicitly identifies filePath as the local file and says nothing about the other required parameter (workflowId) or about model, account, modelId, mimeType and referenceField, leaving most of the schema 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?

States a specific verb and outcome: resolve a local file to a mediaAssetId, either by content-matching in the media library or by uploading. It also scopes the write precisely ('ТОЛЬКО в медиатеку, на полотне ничего не появляется'), which separates it from media-on-canvas siblings like neurover_add_media_to_workflow.

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 discourages use ('Обычно не нужен') and names the alternative that makes it unnecessary — prepare_generation accepts filePath directly. That is a when-not-to-use rule plus the replacement tool in one clause, which is exactly what usage guidance should do.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds only a list of returned fields, which is closer to return-value documentation than behavioral disclosure, and omits pagination behavior (limit/beforeId), whether history is truncated, and any account scoping semantics. With no output schema, some credit is due for describing what comes back, but not much.

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

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

A single compact sentence, front-loaded with the resource, with no filler. It is efficient, though the colon-separated field list substitutes enumeration for explanation rather than earning each item's 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?

Five parameters with zero schema documentation, no output schema, and a paginated history tool that never explains paging or the meaning of details/account. The definition is not complete enough for an agent to invoke it confidently beyond passing workflowId.

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 5 parameters, so the description carries the full burden and largely fails: limit, account, details and beforeId are never mentioned, and even the required workflowId is only hinted at via the word 'полотно' (canvas). Only a vague implication that results are scoped to a canvas generation exists.

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

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

The description names the resource and its content specifically: generation history of the canvas, enumerating prompts, settings, sent references, price, results and messageId. This makes it clearly a read/history tool and distinguishes it from creation-oriented siblings like neurover_submit_generation or neurover_prepare_generation. It falls short of a 5 because it never states the scope/verb in a routing way (e.g. per-workflow history) and offers no explicit sibling differentiation.

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

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

There is no guidance on when to call this versus adjacent read tools such as neurover_media, neurover_statistics, neurover_charges or neurover_wait_generation. No prerequisites, no mention of needing a workflow ID first. The agent must infer usage entirely from the tool name.

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

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

Annotations declare a non-read-only, open-world, non-destructive operation, so the agent already knows this is a mutating external call. The description adds that credentials come from the system keychain, which hints at an OS-level prompt, but it never says whether a session token is stored, how long it lasts, or what a failed login looks like.

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

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

Two short sentences, no filler, with the action stated before the troubleshooting cue. Nothing is redundant, though the brevity comes at the cost of the missing parameter and outcome detail.

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

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

For an authentication entry point with an undocumented parameter and no output schema, the definition omits what matters most: how the account argument selects a credential, what the call returns, and what the caller should do when it fails. The single troubleshooting sentence does not fill those 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 schema has one parameter, account, with 0% description coverage, and the description says nothing about it — not whether it is optional, what value format it takes, or what happens when omitted. With zero structured documentation, the description had to carry this and does not.

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

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

States a concrete verb+resource: log into the account using the OS password store. That distinguishes it from neurover_auth_status (status check) and neurover_account_setup, though it never names those siblings or contrasts with neurover_browser_login, which reads similarly.

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?

"First thing to do on an authorization error" gives a real trigger condition, which is better than nothing. But there is no guidance on when NOT to use it, no mention of neurover_browser_login as the alternative path, and no prerequisites (e.g. whether an account must already exist).

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is somewhat covered. But the description adds nothing beyond restating the name: it does not say whether credentials or cached tokens are cleared, whether other devices' sessions are terminated, whether the call fails if no session exists, or what the caller must do afterwards. For a state-changing auth operation this is a meaningful gap.

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

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

The description is a single short sentence with no filler, so it is front-loaded and efficient. But its brevity comes at the cost of substance rather than from tight editing, leaving it barely at the minimum-viable level.

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 an auth-state mutation with an undocumented optional parameter and no output schema, the description should at minimum clarify session scope, side effects, and expected result. None of that is present, so an agent cannot reliably decide when to call it or 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 single 'account' parameter has 0% schema description coverage, and the description never mentions it. The most important semantic question — whether logout applies to a specific account or to all accounts — is completely unanswered, so the agent cannot know how to populate or omit the 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 sentence 'Выйти из сессии MCP' gives a verb (log out) and a resource (MCP session), so an agent can tell it is a session-termination action. However, it never distinguishes it from the sibling neurover_login / neurover_auth_status / neurover_accounts beyond the obvious opposite, and the scope of 'session' (one account vs all) is left undefined.

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 when-to-use or when-not-to-use guidance, no mention of neurover_login as the counterpart, and no indication of prerequisites such as whether a session must be active first. The agent must infer everything from the tool name.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered and the description only needs to add context. It adds that results carry mediaAssetId for reuse, but says nothing about pagination behavior, result ordering, or what happens when nothing matches. Adequate but thin beyond the annotations.

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

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

A single compact sentence with the search intent front-loaded and the motivation appended after the dash. No filler, though the dashes-and-parenthetical construction packs three ideas into one clause and the return-value hint could be clearer.

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 read-only lookup with 6 undocumented parameters and no output schema, the description covers the core intent and the key output field but omits pagination, account scoping and workflow filtering. An agent could call it with kind alone, but would likely misuse or ignore half the 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 description coverage is 0% across 6 parameters, so the description carries real weight and only partially discharges it: 'по типу и имени' maps to kind and query, and the mention of mediaAssetId hints at what is returned. The remaining parameters — limit, account, beforeId, workflowId — are left entirely undefined in both schema and description, including the paging cursor beforeId and the workflow scoping of workflowId.

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 concrete verb and resource ('Найти файлы в медиатеке'), names the two filter dimensions (type and name), and says what it returns (mediaAssetId). It also frames the payoff (reusing an already-uploaded image), which separates it from upload-oriented siblings, though it does not explicitly name those siblings.

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

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

Usage is implied through the stated goal of avoiding a re-upload, which tells an agent roughly when to reach for it. There is no explicit 'use this instead of X' routing against close siblings such as neurover_ensure_media, neurover_media_access or neurover_download_media, and no exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds real value by disclosing the returned fields (name, size, resolution, links), but says nothing about auth requirements, per-account scoping, or behavior when the asset is missing.

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 the key identifier first and zero filler. It is efficient, though its terseness contributes to the missing parameter and usage context.

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

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

With no output schema, the description does partially cover return content, which is the main gap-filler. However, for a three-parameter tool where two parameters are undocumented anywhere, and with no error or auth behavior described, the definition is only minimally complete.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It explains mediaAssetId as the single-file identifier, but the account and workflowId parameters are left completely unexplained in both the schema and the description — two of three parameters are undocumented.

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

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

The description states a concrete verb-resource pair: fetch details of a single media library file identified by mediaAssetId, and enumerates the fields returned (name, size, resolution, links). That implicitly separates it from the listing-style sibling neurover_media, though it never names that sibling 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?

There is no explicit when-to-use or when-not-to-use guidance, no mention of alternatives such as neurover_media (list) or neurover_download_media, and no stated prerequisites like account or workflow scoping. The only guidance is the implicit 'one file by id' framing.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, so the safety profile is covered. Because there is no output schema, the description earns credit for disclosing the returned fields (id, name, prompt character limit) and the per-model limit semantics with concrete examples (30000 vs 5000), which materially affects how an agent writes prompts. Auth requirements and any filtering behavior remain unspecified.

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 compact sentences, front-loaded with the step marker and the returned fields, with the limit constraint placed where it matters most. The parenthetical model examples are dense but useful rather than filler.

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

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

For a three-parameter read tool with no output schema and no annotation detail beyond safety, the description adequately explains what comes back and why the character limits matter. It is not complete on the input side: a required workflowId and an enum parameter are left entirely unexplained.

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

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

Schema description coverage is 0%, so the description carries the full burden, yet it never mentions workflowId (required), type (an enum of image/video/audio/text), or account. The enum values map plausibly to what the tool returns, but the agent gets no guidance on what workflowId must be or how account changes results.

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

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

The description gives a concrete verb+resource: it lists canvas models and states what each record contains (id, name, prompt character limit). "ШАГ 0" also situates the tool as the first step before prompt writing. It does not differentiate against the nearest sibling, neurover_model_settings, 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 "ШАГ 0" prefix implies this should be called first, before composing a prompt, which is usable guidance. However, there is no explicit statement of when not to use it or which sibling to use instead for model configuration, so usage must be inferred.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds genuinely new behavioral context — that the number of results and which fields are disabled are decided by the site — but says nothing about what the response looks like or how the model is identified.

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 sentences, front-loaded with the 'step 0' cue and dense with concrete field examples (images, reference_videos, cref, sref) instead of filler. No redundancy, though the second sentence is long and could be split.

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 readOnly annotations covering safety and no output schema, the description should at least indicate that the return value is a per-model settings specification and identify how the model is selected. It does the former implicitly and omits the latter, so an agent still has to guess which of model/modelId/workflowId to pass.

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

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

Schema description coverage is 0% and the description mentions none of the five parameters (type, model, account, modelId, workflowId), including the required workflowId. The only parameter-adjacent content concerns reference fields returned in the schema, not the inputs the agent must 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 states concretely that this returns the settings schema of a single model (mode, duration, resolution, aspect_ratio, reference fields) and labels it 'ШАГ 0', which separates it from list-style siblings like neurover_models. The verb is implicit ('return/show schema') rather than explicit, keeping it just 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?

It gives ordering guidance (step 0, i.e. call this before configuring a model) and an explicit 'do not' rule: file_array fields must be supplied via references with the matching field, not via settings. It does not name alternatives such as neurover_models or neurover_api_catalog, so the routing is implied rather than spelled out.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered without the description. The description adds nothing beyond that: it says nothing about what happens to partial results, whether the call is idempotent, or what occurs if no generation is running.

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 or repetition. It is efficient, though the brevity edges into under-specification rather than being genuinely tight.

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 state-changing operation with no output schema, zero schema description coverage, and no annotation detail about side effects, one short sentence is not enough. An agent lacks what it needs to know about preconditions and post-call state.

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

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

Schema description coverage is 0% across three parameters (workflowId, nodeId, account), so the description must carry the explanatory burden. It only loosely implies node scope via 'плитка' and never explains the required workflowId or the optional account parameter, leaving most parameter meaning undocumented.

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

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

The description names a specific verb ('Отменить' / cancel) and a specific resource (a generation currently running in a tile/node), so the operation is identifiable. It does not, however, distinguish this from lookalike siblings such as neurover_cleanup_cancel or neurover_reset_context, and 'плитка' (tile) never explicitly maps to the required nodeId.

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

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

There is no explicit when-to-use or when-not-to-use guidance and no mention of alternatives. An agent must infer from the word 'идущую' (in progress) that this only applies to a currently executing generation, and must guess what to do if the node is idle.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the description's 'Меняет полотно' (modifies the canvas) is consistent but adds only the gating policy on top. It does not say where the duplicate is placed, whether node settings/connections are copied, or what the response contains — with openWorldHint=true that leaves real behavioral gaps.

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

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

Three short sentences, front-loaded with the action, then the safety constraint, then the alternative. Nothing is padded and no sentence repeats the tool name.

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 routing guidance is complete and the mutation is disclosed, but for a 3-parameter write operation with 0% schema coverage and no output schema, the definition leaves the parameters and the result of the duplication unspecified. Adequate to select the tool, thin for invoking it confidently.

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

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

Schema description coverage is 0%, so the schema documents nothing about workflowId, nodeId, or the optional account parameter, and the description does not compensate at all — no parameter is even named. An agent must guess whether account is required for multi-account setups and how nodeId relates to the 'tile' being duplicated.

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: 'Дублировать плитку' (duplicate a tile), and explicitly names the sibling tool this is not for normal generation (prepare_generation). The only friction is terminology: the tool name says 'node_duplicate' while the description says 'плитка' (tile), which an agent must infer are the same 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?

It gives an explicit precondition for calling ('only on a direct user request about tiles or the canvas') and names the correct alternative plus its access path for the common case ('prepare_generation (via canvas chat)'). This is exactly the when/when-not/alternative structure that prevents misrouting.

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

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

The description reinforces the annotation profile by stating 'Меняет полотно' (it mutates the canvas), consistent with readOnlyHint=false, and adds the operational caution about not calling it uninstructed. It does not say what happens to existing node content, whether the restore is reversible, or anything about permissions, so it adds context but stops short of real behavioral depth.

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, mutation scope first, then the usage restriction, then the redirect to the alternative. No filler and nothing buried.

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 three-parameter mutating tool with no output schema, the description covers purpose and routing well but leaves the parameter contract and any return/canvas-state effects unexplained. Adequate to select the tool, insufficient to invoke it confidently.

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

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

Schema description coverage is 0%, so the description must carry the load for workflowId, nodeId and account. It only loosely implies node ('плитка') and canvas ('полотно') meaning, and never mentions the account parameter or the ID types/constraints, leaving the required parameters essentially undocumented.

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

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

States a specific verb+resource: restoring a tile's (node's) last successful result, and explicitly separates that from ordinary generation. The agent can distinguish it from prepare_generation, though the 'tile/canvas' vocabulary is domain shorthand that requires the sibling context to fully decode.

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?

Gives an explicit gating condition ('call only on a direct user request about tiles or canvas') and names the correct alternative for the normal case (prepare_generation via the canvas chat). This is exactly the when/when-not/alternative structure an agent needs.

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

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

Annotations declare readOnlyHint=false with destructiveHint=false, and the description is consistent with that by disclosing that markRead=true mutates state by marking ALL notifications read (the 'all' scope is genuinely useful extra context). However, it does not say whether the returned notification list reflects the pre- or post-mutation state, how many items come back, or whether marking read is reversible.

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 the primary read behavior front-loaded and the flag semantics attached. No filler. It is arguably over-compressed given the 0% schema coverage, but nothing in it is wasted.

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?

No output schema exists, and the description still states the return shape (notifications plus unread count), which is exactly what an agent needs to know before calling. The open-world annotation is unaddressed and the 'account' parameter is unexplained, but for a 2-parameter optional-input tool this is close to sufficient.

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

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

Schema description coverage is 0%, so the description must carry the burden, and it only partly does: it explains markRead's effect ('отметить все прочитанными'), which the bare boolean name would not convey. The 'account' parameter is never mentioned, so half the parameters remain undocumented in both schema and description.

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

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

The description names a concrete resource and result ('Уведомления сайта и число непрочитанных') and describes the secondary action ('markRead=true — отметить все прочитанными'). Neither the name alone nor the sibling list makes the read-vs-mark-read duality obvious, so this adds real value. It stops short of naming any sibling, but none of the listed siblings are plausibly confusable with notifications.

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 only implied: the default behavior is fetching notifications plus unread count, and the flag switches to a mark-all-read action. There is no explicit statement of when to prefer this tool over e.g. neurover_account_overview or neurover_statistics, nor any caution about when not to set markRead. An agent can infer the two modes but must infer them.

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?

Adds substantial behavior beyond annotations: no credits are spent, unsupported settings are silently dropped with a warning, and the MCP rewrites @ref_N into @image_N in order. Against that, annotations already flag a non-read-only, open-world mutation, and the description never says what artifact is created or that workflow context/auth is needed.

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?

Front-loaded with the step and the no-charge guarantee, then reference mechanics, then prompt placeholders — a sensible information hierarchy with almost no filler. The Midjourney/Seedance asides are useful but make the block denser than it needs to be.

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?

Compensates for the missing output schema by telling the agent to inspect finalPrompt, the references table and warnings in the response, which is valuable. Still, with 14 parameters, nested reference objects and an unexplained required workflowId, an agent cannot fill this call in confidently from the definition alone.

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

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

With 0% schema description coverage the description has to carry everything, and it does well for references (ordering, optional field/role, file-field targeting) and prompt placeholders. But workflowId (required), type, model, modelId, account, quality, resolution, outputFormat and durationSeconds get no explanation at all, so roughly half the surface stays 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?

States a precise action pair: assemble the generation request and obtain its price, explicitly framed as 'ШАГ 1 основного процесса'. The clause 'кредиты НЕ списываются' cleanly separates it from neurover_submit_generation, so an agent knows this is the non-committal prepare stage without opening a schema.

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

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

The step-1 framing plus 'Перед оплатой проверь...' establishes the ordering relative to a later paid submit call, which is real when-to-use guidance. It never names an alternative tool explicitly (submit_generation, prepare_run) or states when not to use it, so it stops short of full routing guidance.

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

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

The description adds the key behavioral fact that nothing is launched and points to submit_generation for execution. However, annotations declare readOnlyHint=false and openWorldHint=true, and the description does not explain what state 'prepare' does create, whether the quote is cached or expires, or whether it has side effects — context that would resolve the apparent read-only tension.

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, front-loaded with the purpose and followed by the alternative-tool routing. No filler at all.

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 core intent is clear and the alternative is named, but for a call that presumably costs or reserves something with no output schema, the description never says what comes back (price, currency, availability) or which workflow/node context is required. Adequate minimum, clear 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?

Schema description coverage is 0% across three parameters, so the description must compensate and largely does not: workflowId and account are never mentioned, and nodeId is only obliquely implied by 'плитки'. No format, scoping, or default information is added.

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

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

States a specific verb and resource: retrieve the price of a paid prompt enhancement for a tile/node, explicitly 'without launching'. It names the sibling that performs the actual run (submit_generation), so the agent can separate quoting from executing. Deduction only because 'плитки' is domain jargon that maps loosely onto the nodeId parameter.

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

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

Explicitly gives both the when ('узнать цену ... без запуска') and the when-not plus alternative ('Запуск — submit_generation'). This is the exact routing information an agent needs between this tool and its sibling.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds the crucial non-obvious trait: despite being a price lookup, it mutates the canvas, which explains the readOnly=false hint and warns the agent it is not a side-effect-free query. It stops short of saying what exactly is modified on the canvas, so it is strong but not exhaustive.

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?

Four short sentences, front-loaded with the purpose before the sibling routing and the mutation warning. Every clause carries information, with only mild density from the chained cross-references to submit_generation and prepare_generation.

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 no output schema, the description covers purpose, expected return (a price), the mutation side effect, and sibling routing. Remaining gaps are the identity of nodeId/account and the exact nature of the canvas change, which matter for correct invocation but are secondary to the routing guidance provided.

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

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

Schema description coverage is 0%, so the description must carry the burden. It does gloss the scope enum in prose (target tile / its dependencies / whole canvas, matching target/dependencies/all), which is genuinely useful, but nodeId, account and workflowId get no explanation at all, leaving half the parameters 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 states a concrete verb+resource: find out the price of running a tile, its dependencies, or the whole canvas, explicitly 'without running'. It clearly separates itself from submit_generation (actual run) and prepare_generation (normal generation), so an agent can distinguish it from its closest siblings without opening any schema.

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

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

It names the decision condition explicitly: call only on a direct user request about tiles or the canvas, otherwise use prepare_generation via the canvas chat, and use submit_generation to actually run. Both the when-to-use and the exclusions are spelled out.

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

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

Annotations already declare readOnlyHint=true, destructiveHint=false, and openWorldHint=true, so safety is covered. The description contributes nothing beyond them — no indication of what the 'page' contains, what the returned data looks like, or what openWorld access implies.

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?

It is short, but this is under-specification rather than conciseness: a single fragment with no verb and no front-loaded actionable information. Length is not the problem; absence of content is.

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?

Two undocumented parameters, no output schema, and no annotations explaining behavior leave the agent with essentially no usable information. For a tool with pagination and account scoping, the definition is wholly inadequate.

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?

Both parameters (page, account) have 0% schema description coverage, so the description carries the full burden and it explains neither. There is no hint about pagination semantics, what 'page' indexes, or what form 'account' takes.

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?

"Страница профиля пользователя" only restates the tool name (profile) and adds the word "page"; it never says whether the tool fetches, renders, or returns profile data. An agent cannot tell from this how it differs from siblings such as neurover_account_overview or neurover_account_settings.

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

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

There is no when-to-use guidance, no conditions, and no mention of any alternative among the many account-related siblings. The agent has nothing to route on beyond the bare word 'profile'.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the mutation profile is known. The description adds the side effect ("Меняет полотно") and a discipline rule about only acting on explicit user requests, but says nothing about reversibility, name-constraint rules, or failure modes such as a missing nodeId.

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, front-loaded with the action, zero filler. Marginal redundancy in "Меняет полотно" given readOnlyHint=false, but nothing is wasted or buried.

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 four parameters, zero schema descriptions and no output schema, the description does not explain any parameter, the expected result, or errors. It is adequate as a routing hint but insufficient as a calling guide.

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

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

Schema description coverage is 0% across four parameters (workflowId, nodeId, name, account), so the description carries the full explanatory burden. It only implies that a new name is supplied via the verb, and leaves the meaning and preconditions of workflowId, nodeId and account entirely undocumented.

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

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

"Переименовать плитку" gives a specific verb (rename) and resource (tile/node), which is separable from siblings like neurover_rename_workflow or neurover_update_node. It does not spell out the 'плитка' -> node terminology mapping, so an agent must infer that a tile is a graph node, but the intent is unambiguous.

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