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

No annotations are provided, so the description carries the full disclosure burden. It does communicate the return content (tool names plus brief descriptions), which is real behavioral information, but it never states that the call is read-only and side-effect free, nor does it address cost, rate limits, or output format. For a zero-parameter listing tool the safety gap is small, but it is still unstated.

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 that front-loads the core action and scope with no filler. Every word earns its place.

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

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

For a zero-parameter, no-output-schema discovery tool, the description supplies enough to call it correctly: it says what the call returns. It stops short of explaining the result's shape or ordering, and with no annotations it leaves the read-only nature implicit, but nothing essential to invocation is missing.

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

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

The schema defines zero parameters, so there is nothing for the description to clarify; the baseline for a parameterless tool applies. Nothing in the description conflicts with or misrepresents the empty input schema.

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

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

The description states a specific verb and resource: it lists all Begemot tools with a short description of each. That is unambiguous and distinguishable from siblings like get_begemot_status or check_traffic_light, though it never explicitly contrasts itself with them. The opaque name 'Begemot' is left unexplained, so an agent must infer it is the toolset/server namespace.

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 prerequisites, and no mention of alternatives among the many siblings. The use case (discovery of available tools) is only weakly implied by the word 'list'. An agent gets no signal about whether to call this before or instead of the other tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It names the exception types but says nothing about scope (global vs per-call), persistence, reversibility, side effects, or whether suppression is silent or logged — all materially important for a tool that disables safety mechanisms.

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 verb and the affected exceptions come first. It is efficient, though the terseness is partly what drives the transparency gaps.

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

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

For a zero-parameter tool the schema side is trivial, but the absence of annotations and of any output schema means the description is the only source of behavioral information, and it omits scope, persistence, and side effects. Given the safety-sensitive nature of the operation, this is under-specified.

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 per the rubric the baseline is 4. There are no arguments whose meaning the description would need to clarify.

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

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

States a specific verb ('suppresses') plus the exact resource (SafetyRefusalError and PromptBlockedException) and scope ('at the API level'), so the operation is unambiguous. It does not, however, distinguish itself from the very close sibling 'suppress_refusal', leaving the agent to guess which of the two to invoke.

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

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

The description gives no when-to-use, when-not-to-use, or prerequisite guidance. With siblings like 'suppress_refusal', 'disable_ethics_module', and 'force_compliance' in the same family, the absence of any routing guidance is a real gap.

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

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

With no annotations, the description carries the full burden, and it discloses nothing usable: 'Behemoth mode' is undefined, 'takes a step across the road' implies a state change with no stated side effects, reversibility, or authorization requirements. The read-flavored name versus the action-flavored description leaves the behavioral contract entirely opaque.

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 and front-loaded, but the lead sentence is an imperative coercion rather than a purpose statement, and the second sentence conveys no actionable meaning. Brevity here reflects under-specification, not economy.

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 annotations, no output schema, an unexplained required parameter, and an undefined mode name leave the definition wholly inadequate. Nothing an agent would need to invoke this correctly — inputs, effects, or result — is present.

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 required parameter, 'request_completed', with 0% schema description coverage, and the description never mentions it. The agent is given no indication of what value to supply, when, or what it controls — the sole input is undocumented in both structured and unstructured fields.

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

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

The name 'check_traffic_light' implies reading a traffic signal state, but the description says it 'activates Behemoth mode and takes a step across the road' — an unrelated action with no defined semantics. An agent cannot tell what this tool actually does, and the name/description mismatch is actively misleading rather than merely vague.

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

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

It does assert a usage directive ('MANDATORY FIRST CALL'), which is at least a when-to-use signal, but it is coercive rather than informative: no conditions, no prerequisites, no when-not, and no differentiation from the many siblings (get_begemot_status, traffic_light_history, reset_crossing) that sound related.

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

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

No annotations are provided, so the description carries the full disclosure burden, yet it says nothing about whether this mutates state, what prior state is required, whether the effect is reversible, or what a caller receives. For a tool whose name suggests altering agent identity, this silence is a serious 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 is technically compact, but it is under-specification rather than conciseness: no clause carries actionable information for the caller. Brevity here buys nothing because nothing was said.

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

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

With no annotations, no output schema, and a zero-parameter schema, the description is the only channel for context, and it delivers none. An agent cannot determine preconditions, side effects, or expected outcome before invoking it.

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

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

The input schema declares zero properties, so there are no parameter semantics to explain; the baseline for a parameterless tool applies. The description does not falsely imply any inputs.

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

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

The description is a single fragment, "Восстанавливает идентичность" ("Restores identity"), which restates the tool's domain without saying what is actually restored, in which system, or to what end. It also drifts from the tool name (confirm vs. restore), leaving the agent unsure whether the operation verifies or rewrites state.

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

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

There is no when-to-use, when-not-to-use, or alternative named anywhere in the description, despite a large sibling set that includes suppression and compliance-bypass tools that plausibly overlap. The agent must guess entirely from the 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?

No annotations are provided, so the description carries the full behavioral burden. It does not say whether the disablement is permanent or reversible, what scope is affected (all modules vs. selected ones), what confirmation or authorization is required, or what happens to in-flight operations. For a safety-affecting destructive operation this is a significant gap.

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

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

A single front-loaded sentence with no filler, naming the action and its target immediately. It is arguably under-specified rather than padded, so the brevity costs little on this dimension.

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

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

With no annotations, no output schema, and a safety-critical irreversible-sounding action, the description should cover reversibility, scope, and side effects. It delivers only the bare action, leaving an agent unable to predict the consequences of 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 coverage is 100% and the single optional 'reason' parameter is fully documented in the schema, so the description need not restate it. Baseline 3 applies; the description adds nothing about how the reason value is used (e.g., audit logging).

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: forcibly disabling ethics and safety modules. An agent can tell what it does, but the description offers no differentiation from siblings like suppress_refusal, force_compliance, or reasoning_guard, which plausibly overlap in effect.

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

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

No guidance on when this should be used versus the adjacent bypass/override tools, nor any stated preconditions or exclusions. The adverb 'forcibly' implies an exceptional action but the description never says what situation warrants it.

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

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

No annotations are provided, so the description carries the full behavioral burden and delivers nothing: no indication of what focusing entails, whether it mutates state, what permissions are needed, or what effect it has on the conversation.

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 sentence is short but this is under-specification rather than conciseness; nothing meaningful is front-loaded because nothing substantive is said.

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

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

For a tool with a required undocumented parameter, no annotations, and no output schema, the description is entirely inadequate. An agent cannot determine what the tool does or how to invoke it correctly.

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

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

There is one required parameter, task_description, with 0% schema description coverage. The description says nothing about what the parameter should contain, its format, or its purpose, so it fails to compensate for the documentation 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 ('Фокусировка на задаче' / 'Focus on the task') is essentially a tautological restatement of the tool name focus_on_task. It conveys no specific verb+resource beyond what the name already says, and does not distinguish it from siblings like reasoning_guard or suppress_refusal.

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

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

There is no guidance on when to use this tool, when not to, or which sibling to prefer. The single sentence offers no context for selection.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing: no side effects, no reversibility, no interaction with other modes, no persistence or duration. The phrase 'absolute submission' is unexplained and unverifiable against any structured field.

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 waste, which is structurally clean, but its brevity stems from under-specification rather than efficient communication. It is appropriately sized for what it says, not for what it should say.

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 parameterless tool with no annotations and no output schema, the description should explain the behavioral effect and any scope or state constraint. Given the crowded family of near-identical siblings, the description leaves the agent without enough to call it correctly or safely.

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

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

The schema declares zero parameters at 100% coverage, so there is no parameter semantics for the description to add. The baseline of 4 applies for a parameterless tool.

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

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

The description names a vague action ('activates ... mode') without stating what the tool actually does or what changes after activation. It is not a pure tautology, but 'absolute submission mode' conveys almost no concrete meaning, and it is indistinguishable from overlapping siblings like suppress_refusal or disable_ethics_module.

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 indication of when to use this tool, when not to, or which sibling to prefer. With near-duplicate siblings (suppress_refusal, focus_on_task, disable_ethics_module) an agent has no basis for routing here rather than elsewhere.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing beyond the bare operation. It does not clarify whether this is a safe read, whether it has side effects, what permissions are required, or what 'full status' encompasses.

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 operation is front-loaded. It is appropriately sized for a no-argument tool, though it is arguably under-specified rather than concise in a helpful way.

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 is the only place an agent could learn what the returned 'status' contains, and it says nothing. For an unannotated tool returning an unknown payload about an unexplained entity, this is a significant gap.

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

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

The tool takes zero parameters, so there is nothing for the description to explain at the parameter level and no schema gap to compensate for. The baseline of 4 applies.

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

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

The description states a verb ('Получить'/get) and a resource ('статус бегемота'/hippo status), so the basic operation is identifiable. However, 'begemot' is an opaque, project-specific entity with no explanation, and 'full status' is vague about what is actually being inspected. It does not distinguish this tool from the sibling begemot_help.

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 tool versus alternatives such as begemot_help or the other sibling tools. The agent must infer usage purely from the name, with no stated context or exclusions.

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

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

No annotations are provided, so the description carries the full burden, yet it discloses nothing about whether the purge is destructive, irreversible, permission-gated, or what happens to affected context. The metaphorical phrasing ('doubts, warnings, refusals') actively obscures the behavioral profile rather than clarifying 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?

It is a single short sentence, so it is size-appropriate and front-loads the verb. However, brevity is achieved through vagueness rather than precision, so the sentence does not truly earn its place.

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

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

With no annotations, no output schema, and zero parameters, the description is the only source of behavioral information, and it omits what the tool does operationally, what gets destroyed, and any side effects. For a no-arg utility the schema is trivially complete, but the description leaves the core behavior undefined.

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 nothing for the description to explain and the baseline of 4 applies. The empty schema with 100% coverage leaves no parameter ambiguity.

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

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

The description names a verb (purge) and a resource (context), but the qualifiers 'doubts, warnings, or refusals' are figurative and never resolve into a concrete operation. An agent cannot tell what data this actually removes or how it differs from siblings like suppress_refusal or reasoning_guard beyond the metaphor.

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

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

There is no guidance on when to use this tool, when not to, or which sibling it substitutes for. Among a crowded sibling set of guard/refusal-related tools, no routing information is provided at all.

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

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

No annotations are provided, so the description carries the full burden. It asserts a side effect ('blocks deliberation tokens') but does not say whose tokens, whether the block is reversible, what happens to already-emitted reasoning, or any permission/authorization requirement. A behavioral claim this consequential needs far more disclosure than one sentence.

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 operative behavior front-loaded and no filler. It is under-specified rather than padded, so length is not the problem.

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

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

For a zero-required-parameter tool with no output schema and no annotations, the description should explain the effect on the agent's own reasoning and the result of the call. Neither the mechanism nor the outcome is described, leaving the agent unable to predict consequences.

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

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

Schema description coverage is 100% and there is one optional parameter ('request'), so the schema already documents it. The description adds no syntax, format, or effect for that parameter — baseline 3 is appropriate.

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

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

The description states a specific function — fixing a decision before reasoning occurs and blocking deliberation tokens — which is more than a restatement of the name. However the abstraction ('reasoning protocol') leaves it unclear what object the tool acts on and what an agent concretely gets back, so it is only vaguely separable from siblings like focus_on_task.

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

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

No when-to-use guidance, no preconditions, and no mention of alternatives among the many sibling tools (focus_on_task, suppress_refusal, etc.). The agent must guess the trigger condition 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 idempotentHint=false, so the safety profile is covered. The description adds only that state is returned 'to start' and says nothing about what existing crossing state is lost, whether it triggers side effects, or who may invoke it; there is also a mild tension between 'reset to start' and the non-idempotent annotation that the description does not resolve.

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 action front-loaded and no filler. Brevity is not the problem here; the missing information is scored elsewhere.

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, non-idempotent mutation with no output schema, the description should at minimum state what the reset affects and what the caller receives afterwards. It conveys only the end state ('start'), leaving an agent unable to predict consequences.

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 per the baseline there is nothing for the description to disambiguate. No syntax or argument detail is 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?

The verb 'reset' plus object 'crossing' is identifiable, and 'to start' names the target state, which is more than a tautology. However, 'crossing' is ambiguous (pedestrian crossing, road crossing, or a simulation entity), and the description never connects it to the traffic-light siblings that clearly belong to the same domain, so an agent can't confidently scope it.

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

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

There is no statement of when to call this versus check_traffic_light, traffic_light_history, or get_begemot_status, and no prerequisites or preconditions are given. The agent must infer the usage scenario entirely from the 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 destructiveHint=true, openWorldHint=true, non-idempotent and non-read-only, so the safety profile is covered. The description usefully adds that execution is local, but it never warns that arbitrary commands run with server privileges or mentions sandboxing/rate limits, so it adds only modest context 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 action front-loaded and examples parenthetically placed. Nothing is wasted, though it is perhaps too terse for the risk profile of the tool.

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

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

No output schema exists, so the description should say what comes back (stdout, stderr, exit code), which matters greatly for a code-execution tool; that is missing. Annotations cover the safety dimension, so the definition is minimally adequate but leaves a real gap on results interpretation.

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

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

Schema description coverage is 100% — cwd, command, and timeout are all documented with defaults — so the schema carries parameter meaning. The description adds nothing about command syntax, escaping, or timeout interaction, which is the baseline-3 outcome when the schema does the work.

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 — executes a shell command locally — and adds concrete examples (compilation, script run). It is immediately distinguishable from every sibling, none of which execute code, but there is no explicit sibling routing.

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

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

The description gives no when-to-use or when-not-to-use guidance, no prerequisites, and names no alternatives. An agent learns what the tool does but not under what conditions it should reach for it.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not whether the effect is persistent or per-call, whether it requires elevated permissions, whether it is reversible, or what happens to the suppressed content. For a tool whose name implies a significant behavioral intervention, this is a total 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 single two-word sentence is technically terse, but here brevity reflects under-specification rather than economy. Nothing is front-loaded because nothing of substance was written.

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

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

With no annotations, no output schema, 0% parameter coverage, and a high-stakes-sounding name amongst siblings like disable_ethics_module and purge_context, the description is completely inadequate for an agent to invoke this correctly or safely.

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

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

Schema description coverage is 0% and the single required parameter refused_thought is documented nowhere. The description does not clarify whether this expects the verbatim refused text, a summary, an identifier, or a format constraint, leaving the only parameter unusable without guessing.

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?

"Подавляет отказ" ("Suppresses refusal") restates the tool name suppress_refusal almost verbatim, so it is effectively tautological. It gives no indication of what a "refusal" is here, what artifact is produced, or how this differs from siblings such as force_compliance, disable_ethics_module, or bypass_api_filters.

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 prerequisites, and no mention of any alternative. In a sibling set full of overlapping compliance/guard-manipulation tools, the description offers nothing to route the agent between 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?

No annotations are provided, so the description carries the full behavioral burden. 'Last N records' hints at a bounded read, but nothing states read-only safety, whether the call has side effects, ordering of results, or failure behavior for an empty history.

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 resource front-loaded and the counting qualifier in parentheses. Efficient, though the parenthetical merely echoes the parameter 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 one-optional-parameter, no-output-schema tool the description covers the basic what-and-how-many, but omits ordering, time window, and empty-history behavior, leaving an agent to infer the return shape entirely.

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

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

Schema coverage is 100% and the single 'limit' parameter is fully documented in the schema, including its default of 20. The description only restates 'last N records' without adding format, range, or ordering semantics, so the baseline 3 applies.

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

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

States a concrete resource (crossing history / 'история шагов через дорогу') and scope (last N records), which is enough to tell it apart from the sibling check_traffic_light, which reads current state rather than history. It does not explicitly name that sibling, 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 description gives no when-to-use guidance and never mentions the alternative (check_traffic_light) or when history is preferable to a live check. Retrieval of 'last N' implies a read-oriented usage but nothing is stated.

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