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

No annotations are provided and the description is silent on behavior: it does not state that this is a mutating write operation, whether it requires permissions or an online robot, what happens on scheduling conflicts, or whether the operation is idempotent. For a creation tool with zero annotation coverage the description carries the full burden and delivers nothing.

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 this is brevity born of under-specification rather than efficiency. Nothing in the sentence earns its place beyond the name restatement.

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

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

Given 17 parameters, 7 of them required, no annotations, no output schema, and five sibling schedule tools, the description is far too thin. An agent cannot determine when to call this tool, what values to supply for its many cryptic parameters, or what result 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?

17 parameters with 0% schema description coverage, and the description mentions none of them. Critical semantics such as the meaning of plan_execute_type, plan_repeat_type, semester_type, or the date/time formats for plan_start_time are left entirely unexplained on both the schema and the description side.

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 '创建标准排班 / Create schedule' essentially restates the tool name and adds only the word 'standard' to hint at a distinction from create_simple_schedule. It gives no indication of what a schedule contains or what creating one entails, so an agent learns nothing beyond the name.

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

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

There is no when-to-use guidance at all, despite five schedule-management siblings (create_simple_schedule, update_schedule, list_schedules, get_schedule, delete_schedule) that an agent must choose among. The implicit 'standard vs simple' distinction is never explained.

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, yet it says nothing. For a mutation tool that creates schedules it does not state permissions required, side effects, whether the schedule starts immediately, or what happens on conflicting schedules.

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

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

The text is short but not concise in a useful sense — it is under-specified rather than economical. A single restated phrase cannot front-load anything meaningful for a 17-parameter tool.

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

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

Given 17 parameters, nested objects, zero schema description coverage, no annotations, and no output schema, the definition is completely inadequate. An agent would have no basis for constructing 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 17 parameters (9 required), including opaque nested objects like work_mode, map_resource_list, and task_advance_config, plus integer enums such as site_mode, work_mode, plan_repeat_type, and plan_execute_type. The description adds no parameter meaning at all, leaving critical fields 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?

The description '创建简易排班 / Create simple schedule' is essentially a bilingual restatement of the tool name create_simple_schedule, giving no information beyond the identifier. It does not distinguish this tool from the sibling create_schedule or explain what 'simple' versus regular scheduling means.

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 whatsoever on when to use this tool versus create_schedule, create_task_definition, or the update/delete schedule siblings. The agent is left to infer everything from the name alone.

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

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

No annotations are provided, so the description carries the full burden, and it discloses nothing: not that this is a mutation persisting server-side state, not any auth/permission requirement tied to robot_sn or site_id, not whether it validates the referenced map resources, and not what happens on duplicate task_name. For a create tool with zero annotation coverage this 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?

It is short, but only because it says nothing; there is no front-loaded statement of purpose, required inputs, or outcome. Brevity here reflects under-specification rather than 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?

A 7-parameter mutation tool with nested objects, no output schema, no annotations, and 0% schema description coverage needs the description to supply structure and behavior. It supplies neither, leaving the agent unable to construct a valid 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?

Seven parameters at 0% schema description coverage, including two required free-form objects (work_mode, map_resource_list items) and an optional task_advance_config, and the description explains none of them. The agent has no idea what shape work_mode or map_resource_list entries must take, which is the single biggest risk for this 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 '创建任务定义 / Create task definition' is a bilingual restatement of the tool name with no added scope, no statement of what a task definition contains, and no differentiation from siblings like create_simple_schedule or update_task_definition. An agent learns nothing beyond what the name already conveys.

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 the many sibling alternatives (create_simple_schedule, create_schedule, run_cleaning_task) that also create executables. The agent must guess whether this is the right entry point.

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 says nothing beyond the verb. It does not state that the operation is destructive and irreversible, what permissions are required, whether deleting cascades to related plan/semester data, or that six identifiers must match before deletion succeeds.

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 words cannot be called wasteful, but this is under-specification rather than conciseness. There is no front-loaded scope, constraint, or consequence information for a tool whose actual behavior must be inferred.

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 8 parameters at 0% coverage, 6 required, no annotations, and no output schema, the definition leaves an agent with essentially nothing to work from. A destructive multi-identifier operation needs at least identifier semantics, mutation consequences, and a note on the sibling delete_simple_schedule.

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 (robot_sn, plan_uuid, semester_uuid, operation_type, plan_commit_no, plan_start_date, client_time_zone, semester_commit_no) and the description adds no meaning to any of them. For example, the integer operation_type has no enum and no explanation, and the optional commit numbers are 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 verb and resource ('Delete schedule') and the Chinese '标准排班' (standard schedule) hints that it targets standard schedules rather than the simple-schedule variant. However, it never names the sibling delete_simple_schedule or explain the distinction, so an agent must infer the boundary. This is minimum-viable identification, not clear 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 when-to-use guidance, no preconditions, and no routing to alternatives such as delete_simple_schedule or update_schedule. It is somewhat distinguishable from siblings by name alone, but nothing in the description states 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?

No annotations are provided, so the description carries the full burden for a destructive mutation. It says nothing about irreversibility, required permissions, what happens to related schedule instances, or the meaning of operation_type, leaving the agent blind to the operation's consequences.

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

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

The text is short, but its brevity reflects under-specification rather than efficient communication. It adds no information beyond the tool name, so nothing is front-loaded because nothing is stated.

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 tool with 8 undocumented parameters, no annotations, and no output schema needs substantial context about scope, permissions, and parameter roles. The definition provides none of it, making it inadequate for correct invocation.

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

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

Schema coverage is 0% across 8 parameters, and the description supplies no parameter meaning at all. Critical fields such as plan_uuid, operation_type, and the year/month/day_of_month triple are completely undocumented, so an agent cannot know what values are valid.

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

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

The bilingual text names a specific verb and resource (delete a simple schedule), so the action is identifiable. However it is essentially a restatement of the tool name and does nothing to distinguish it from the sibling delete_schedule, leaving the agent to guess which deletion endpoint applies.

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 the nearby delete_schedule alternative. The only hint is the tool name itself, which is insufficient for choosing between the two delete operations.

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 that the operation is destructive and irreversible, not whether the task must be stopped or idle first, and not what happens to schedules or reports that reference the definition. For a deletion tool this is a critical 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 text is short and front-loaded, but the bilingual duplication of the same four words is pure redundancy rather than concision, and nothing substantive was trimmed to make room for it. This is under-specification, not efficient writing.

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, two-parameter tool with no annotations, no output schema, no documented parameters, and no description of side effects is completely inadequate for correct invocation. None of the context an agent needs before deleting a task definition 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?

Two required parameters (robot_sn, fusion_task_id) exist with 0% schema description coverage, and the description supplies no meaning for either. The agent cannot tell what identifier format fusion_task_id expects or whether robot_sn scopes the lookup or identifies the executor.

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 essentially a restatement of the tool name: '删除任务定义 / Delete task definition' adds no scope, target, or effect beyond the verb+resource already encoded in the identifier. It does not distinguish this tool from siblings like delete_schedule, update_task_definition, or list_task_definitions.

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 pointer to the related get/list/create/update_task_definition siblings. An agent receives no signal about when deletion is appropriate versus updating or merely listing.

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 delivers almost nothing beyond the title. At best the wording implies a read-only lookup operation, but there is no mention of whether the integer must be a known code, what happens for invalid input, or what the result 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?

It is short and front-loaded, which is good, but the bilingual duplication adds length without adding information for an English agent. Conciseness here reflects under-specification rather than tight, informative writing.

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 an undocumented enum-like integer parameter, the description needed to supply the missing context and does not. An agent cannot reliably call this tool 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?

The single required parameter work_state is an integer with 0% schema description coverage, no enum, and no format hints. The description is silent on the parameter entirely, so an agent has no way to know the valid code space or expected value.

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

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

The description states a verb ('describe') and a resource ('work state'), so the broad intent is legible. However, it does not clarify what 'describe' returns (a human-readable mapping of the integer?) nor distinguish this from siblings like get_robot_status or list_work_modes. It borders on restating the tool name.

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

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

There is no guidance on when to call this tool versus the sibling state/status tools. No exclusions, no prerequisites, and no indication of when an agent should reach for this over get_robot_status. Usage must be inferred 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 burden. It doesn't say whether the status is a snapshot or blocking, whether it requires prior delivery, what states are possible, or the return format. Only the minimal 'status query' behavior is implied.

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 two-language one-liner is brief and front-loaded, but it's under-specified rather than genuinely concise. It wastes no words but also conveys almost no information.

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

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

For a 2-parameter required tool with 0% schema coverage, no annotations, and no output schema, the description should explain what request_id refers to and what 'status' returns. It leaves too much for the agent to guess.

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

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

Schema description coverage is 0% and the description adds nothing about robot_sn or request_id – no format, source, or relationship between them. An undocumented request_id is especially problematic since the agent has no way to know where it comes from.

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+resource ('Get command delivery status'), which is clear enough in isolation. But it doesn't differentiate from siblings like wait_for_command or list_command_history, and no scope details distinguish it from those command-related tools.

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

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

No when-to-use guidance, no alternatives named, no mention of when this is preferable to wait_for_command or list_command_history. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing: not the return format (image blob, base64, path), not whether robot_sn must be online, not any failure mode. This is a complete disclosure gap for an undocumented 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?

It is short, but brevity here reflects under-specification rather than efficiency. The bilingual restatement of the name occupies the entire description without front-loading any actionable information.

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

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

With no annotations, no output schema, and 0% parameter coverage, the description is inadequate for a two-required-parameter tool. The agent has no basis for knowing what a 'map canvas' is or what it receives in return.

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

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

Schema description coverage is 0% and the description adds nothing about map_id or robot_sn. With two required, entirely undocumented parameters, the description fails to compensate for the schema gap, leaving the agent guessing at accepted values and relationships.

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 'Get map canvas' restates the tool name almost verbatim, adding no verb detail, scope, or resource clarification beyond what the name already conveys. It does not distinguish this tool from siblings such as list_map_resources or list_robot_maps.

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. An agent cannot infer from the text whether this returns canvas imagery, metadata, or a URL, nor when to prefer it over list_map_resources.

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: no confirmation this is a read-only lookup, no auth/permission notes, no indication of whether the robot must be reachable, and no hint about what is returned. The single word 'Get' is the only behavioral signal.

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 two short bilingual phrases with no filler, so nothing is wasted. But it is under-specified rather than concise — the brevity leaves core questions unanswered and the bilingual duplication adds no informational value.

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

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

With no output schema and no annotations, the description is the only place to learn what 'task capabilities' means and what comes back, and it says nothing. For a tool whose entire value is the returned capability set, this is a significant gap.

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

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

Schema description coverage is 0% and the one required parameter (robot_sn) is documented only by its title 'Robot Sn'. The description adds no meaning about its expected format, source, or whether it identifies a physical robot versus a logical entity.

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 (Get) and a resource (task capabilities) for a robot, so the general operation is inferable. However, 'capabilities' is never defined and it is not distinguished from siblings like get_robot_status or list_work_modes, which could plausibly return overlapping information. Vague on what 'capabilities' actually means.

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 versus get_robot_status, list_work_modes, or list_task_definitions, nor any prerequisite such as the robot needing to be online. 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?

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: not whether this is read-only, how invalid or unknown serial numbers are handled, whether it batches, or how many results come back. The verb 'get' faintly implies a read, which is the only behavioral signal present.

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 phrases with no padding, but this is under-specification rather than genuine conciseness — the text is too thin to earn its place as guidance for a tool with an undocumented required parameter.

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

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

For a tool with no annotations, no output schema, and an undocumented required array parameter, the description supplies none of the missing context: not the returned status fields, not error behavior, not the relationship to sibling status/capability tools.

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

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

The single parameter robot_sn_list has 0% schema description coverage and is never mentioned in the description. The agent cannot tell whether the list is required, how many serial numbers are accepted, or what format they take, and the description does nothing to compensate.

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 essentially a bilingual restatement of the tool name ('Get robot status'), giving a verb and resource but no scope, no return semantics, and no differentiation from siblings such as get_robot_capabilities or describe_work_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 statement of when to use this tool versus alternatives like list_robots or get_robot_capabilities, no prerequisites, and no exclusion criteria. An agent must infer usage purely 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?

There are no annotations, so the description carries the full behavioral burden, and it discloses nothing: no auth/permission needs, no read-only confirmation, no return shape, and no notes about what the required identifiers must refer to.

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 single line is short, but it is under-specified rather than concise: it conveys no actionable content beyond the title, so brevity here is a defect, not a virtue.

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

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

For a tool with five required parameters, no annotations, and no output schema, the description is completely inadequate — an agent cannot determine what identifiers are valid or what it will receive back.

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?

Five required parameters (robot_sn, plan_uuid, year, month, day_of_month) have 0% schema description coverage, and the description explains none of them — not even the year/month/day semantics or whether they select a specific day's shift.

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 essentially a bilingual restatement of the tool name, adding only the word 'details' (详情). It does not distinguish this tool from siblings like list_schedules, get_schedule_calendar, or update_schedule, leaving the agent to infer that this fetches one schedule's details.

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

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

No when-to-use guidance is given: no mention of when to call get_schedule versus list_schedules or get_schedule_calendar, and no prerequisites. 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?

No annotations and no output schema, so the description carries the full behavioral burden, yet it discloses nothing about return format, permissions, pagination, or whether the data is read-only. Only the implicit 'monthly' scope hints at behavior.

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

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

Two short phrases with no wasted words, but this is under-specification rather than conciseness — it omits nearly everything an agent needs. Brevity here costs 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?

With no annotations, no output schema, and 0% parameter documentation, the definition is far too thin for a tool requiring two mandatory inputs. It should at minimum describe the month format and what a schedule calendar returns.

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 both parameters (robot_sn, year_month) are undocumented in the schema. The description's 'monthly' hints that year_month matters but gives no format (e.g. '2024-05') or semantics for robot_sn, so it fails to 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 bilingual description states a verb ('Get'/'查询') and a resource ('schedule calendar'/'月度排班'), which is more than a tautology. However, it does not distinguish this tool from the many schedule siblings (get_schedule, list_schedules, get_schedule_pre_tasks), so an agent cannot tell which one it needs without opening schemas.

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

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

There is no when-to-use guidance, no prerequisite conditions, and no mention of any alternative. The word 'monthly' implies a month-scoped view but the description never says when to prefer this over get_schedule or list_schedules.

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

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

No annotations are provided, so the description carries the full behavioral-disclosure burden, but it only repeats the tool name. It does not state whether this is a read-only lookup, what permissions are required, what a missing task returns, or any other behavioral trait. This is effectively no behavioral transparency.

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

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

The description is extremely short, but it is under-specified rather than appropriately concise. It contains no wasted words, yet it fails to front-load any useful information 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?

With no output schema, no annotations, two undocumented required parameters, and many closely related sibling tools, the description is completely inadequate. An agent lacks the information needed to understand what task definition is returned, by what identifier, or how this differs from list_task_definitions.

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

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

The schema has 0% description coverage and two required parameters, robot_sn and fusion_task_id. The description provides no meaning, format, relationship, or usage guidance for either parameter, so it fails to compensate for the schema gap.

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

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

The description is only a bilingual restatement of the tool name: '查询任务定义 / Get task definition'. It states the verb and resource but adds no scope or distinction from siblings like list_task_definitions, create_task_definition, or update_task_definition. This fits the definition of a tautological restatement rather than a useful purpose statement.

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 such as list_task_definitions for listing or the create/update/delete siblings. The agent is given no information to decide when this tool is appropriate.

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

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

No annotations are provided, so the description carries the full burden. It says nothing about whether this is a read-only lookup, what permissions are needed, whether images are paginated or bounded, or what the returned payload 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?

The text is short, but it is simply the same phrase duplicated in Chinese and English with no additional content. Brevity here reflects under-specification rather than efficient front-loading.

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 parameter documentation, the description leaves everything about this tool unspecified. A caller cannot determine required inputs, filtering behavior, or return shape from it.

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

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

Schema description coverage is 0% and there are two parameters, neither explained. The description does not clarify what task_report_id identifies or what robot_sn is for (e.g., filtering by robot when a report spans multiple robots).

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 bilingual phrase states a verb and resource ('Get report map images'), so the agent knows it retrieves images. However, it gives no scope (which images, per task report?) and does not distinguish itself from siblings such as get_map_canvas, list_map_resources, or list_task_resources.

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

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

There is no guidance on when to use this tool versus the many map/task-report siblings, no prerequisites, and no exclusions. The agent must infer usage 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 burden, yet it says nothing about read-only nature, permissions, scoping, or return behavior. 'List' weakly implies a safe read, but nothing is disclosed explicitly.

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 bilingual line with no filler. It is efficient, though its brevity comes at the cost of the missing detail noted elsewhere rather than being wasteful.

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

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

For a tool with two required, undocumented parameters, no annotations, and no output schema, the description supplies almost nothing an agent needs to call it correctly. Required scope (which robot/map) is left entirely to the schema titles.

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 2 required params (robot_sn, map_id), and the description mentions neither. It does not explain which robot or map must be supplied, nor the expected identifier format, leaving both parameters semantically 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 specific verb+resource ('List charging positions' / '列出充电点'), so an agent knows it enumerates charging positions. It gives no differentiation from plausible siblings like list_map_resources or list_robot_maps, so it falls short of 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 indication of when to use this tool versus alternatives, nor any prerequisites beyond the required params being implicit. Only the most generic 'list' semantics are implied.

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: no pagination behavior for the defaulted page/pagesize, no semantics of cmd_status/command_type filters, no return shape, and no permission requirements. A read-only listing tool with zero behavioral context is inadequate.

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 with no rambling, and the verb+resource leads the sentence, but the bilingual duplication ('查询命令历史 / List command history') repeats identical content rather than adding either brevity or information.

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

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

With five parameters, one required, no annotations, no output schema, and no parameter documentation anywhere, this description is far too thin for an agent to invoke the tool correctly. It omits filtering, pagination, and result-format information 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 description coverage is 0% across all five parameters, including the required robot_sn, and the description supplies no parameter meaning whatsoever. Nothing tells the agent what cmd_status values are valid or how pagination defaults behave.

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 'List command history' is a literal restatement of the tool name list_command_history, with no additional scoping, resource detail, or distinction from siblings such as get_command_status. It identifies a verb and a resource only by echoing the identifier itself.

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

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

There is no guidance on when to use this tool versus the clearly related siblings get_command_status or wait_for_command, and no mention of preconditions such as needing a valid robot serial number. The agent must infer all routing decisions from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it discloses nothing. It does not state whether the call is read-only, whether it is scoped by robot_sn, whether results paginate or how large the payload may be, nor what happens if a map_id in the list does not exist.

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

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

The text is short, but brevity here reflects under-specification rather than economy: it is a duplicated bilingual label with no substantive content. There is no front-loaded information because there is no information.

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

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

With five parameters, only 2 required, three opaque boolean flags, no annotations, and no output schema, the description is far too thin for an agent to invoke this correctly. Nothing tells the agent what to pass, what will come back, or what the optional flags change.

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, including three optional include_paths/include_regions/include_positions flags whose semantics (payload size? conditional filtering?) are entirely undocumented. The description supplies no compensating explanation for any 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 is a bilingual restatement of the tool name, 'List map resources', adding no information about what a 'map resource' actually is. It does not distinguish this tool from siblings such as list_robot_maps or get_map_canvas, so an agent cannot tell what entity is returned or why one would choose this over those.

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 whatsoever on when to use this tool, when not to, or which sibling to prefer. With many list_* and map-related siblings in the toolset, this omission is material.

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: no read-only confirmation, no pagination behavior, no return shape, no indication of what 'maps' contain. It is a label, not a specification.

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 contains no filler, which is positive, but the brevity here reflects under-specification rather than economy. Nothing is front-loaded because there is nothing to front-load.

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 single-parameter list tool this could be adequate, but with no output schema and no annotations, the description should at minimum say what is returned and how the required serial number is used. Both are absent.

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

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

Schema description coverage is 0% for the single required parameter robot_sn; the description never mentions it. The schema supplies only 'type: string' and a title, so the description fails to explain that this is the robot serial number identifying which robot's maps to list.

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 and resource ('List robot maps'), so the basic purpose is inferable, but it is essentially a bilingual restatement of the tool name with no scope detail. It does nothing to distinguish itself from siblings like list_map_resources or get_map_canvas.

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

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

There is no guidance on when to use this tool versus the many sibling list/get tools (list_map_resources, get_map_canvas, list_robots). The agent must infer usage 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 burden of behavioral disclosure. It states nothing about permissions, pagination, return format, or side effects.

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

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

The description is extremely short but under-specified rather than concise. It fails to front-load any useful information.

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

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

For a list tool with 3 undocumented parameters and no output schema, the description is completely inadequate. It omits what robots are listed, default page size behavior, and relation filtering.

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 3 parameters (page, relation, page_size). The description adds no meaning for any parameter, leaving relation's purpose and pagination semantics 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 'List robots' is a tautological restatement of the tool name. It gives no scope or differentiation from siblings like get_robot_status or list_robot_maps.

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

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

No guidance on when to use this tool versus alternatives is provided. There is no mention of prerequisites, exclusions, or 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 behavioral burden, and it discloses almost nothing: no indication of return shape, ordering, pagination, or whether results are scoped to one robot/date. The imperative "List" weakly implies a read-only operation, but that is the only behavioral signal present.

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 bilingual line with no padding, so it is not verbose. But brevity here reflects under-specification rather than front-loaded efficiency — there is no structure or detail to be concise about.

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 required parameters, zero schema coverage, no output schema, and no annotations, the definition is far too thin to let an agent call this correctly. It does not explain what the returned entries are, how they relate to a schedule, or what formats the required inputs accept.

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 neither parameter has a description in the schema. The description adds no meaning for "date" or "robot_sn" beyond the hint in "每日" that the date is day-scoped; the expected date format and the role of the serial number are entirely unstated.

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 ("List") and a resource ("schedule pre-tasks"), so the general operation is identifiable. However, "预任务 / pre-tasks" is undefined domain jargon, and nothing distinguishes this tool from siblings such as list_schedules, get_schedule_calendar, or list_task_definitions. An agent can guess the surface meaning but not the precise scope.

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

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

There is no when-to-use guidance, no condition selecting this tool over list_schedules or get_schedule, and no mention of prerequisites. The agent is left to infer everything from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: not whether results are paginated, sorted, scoped to a time window, or what permissions are needed. A read-style listing tool with zero annotation coverage and an empty description leaves behavior 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, but this is under-specification rather than conciseness; the bilingual restatement of the name adds no information and every meaningful detail is absent.

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 listing tool with a required parameter, no annotations, no output schema, and a large sibling set, the description provides nothing an agent needs to invoke it correctly. It is completely inadequate 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% and the single parameter robot_sn is documented nowhere except its title. The description does not explain that robot_sn selects which robot's schedules are listed, nor its format, so the one required input is effectively undocumented.

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

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

The description '列出版排 / List schedules' merely restates the tool name, giving a verb and resource but no additional specificity. It does not distinguish this tool from siblings such as list_schedule_pre_tasks, get_schedule, or get_schedule_calendar, so an agent gains nothing beyond the name itself.

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

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

There is no when-to-use guidance, no mention of alternatives, and no stated prerequisites. The agent must infer that this lists schedules for a given robot_sn versus calling get_schedule or get_schedule_calendar.

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 almost nothing. It implies a read via '查询', but does not state whether robot_sn is an authorization scope, whether results are cached, or how paging interacts with large result sets. For a tool with zero annotation coverage this is a thin disclosure.

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

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

A single short front-loaded sentence with no filler. The bilingual restatement is slightly redundant but conventional for this API surface and does not bloat the text.

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 5 parameters, no output schema, no annotations, and a one-line description, an agent lacks everything needed to call this correctly — filter semantics, return shape, and paging limits are all absent. The definition is under-specified for the tool's actual 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 5 parameters, so the description must compensate and does not. Only the pagination concept (page/pagesize) is loosely implied; robot_sn, site_id, and task_name filtering semantics are entirely unexplained beyond their bare names.

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

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

The description states a clear verb and resource ('分页查询任务定义 / List task definitions'), so an agent immediately knows this returns a collection of task definitions. It hints at pagination, which loosely separates it from the singular get_task_definition sibling, but it never names or contrasts with 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 guidance on when to use this instead of get_task_definition, list_task_resources, or list_task_reports. The agent must infer usage purely from the name, with no stated prerequisites, 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 behavioural burden, yet it only discloses that results are paginated. It says nothing about read-only semantics, required robot context, authorization needs, ordering, or what a page of reports contains.

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 bilingual phrase with the operation front-loaded and no filler. It is efficient, though its brevity borders on under-specification rather than true conciseness.

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

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

For a 5-parameter, no-annotation, no-output-schema tool, the description omits parameter meanings, behaviour of time filters, and any return-shape expectation. An agent would have to guess at most call semantics.

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

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

Schema description coverage is 0% across 5 parameters, so the description must compensate. '分页' hints at page/pagesize, but the required robot_sn and the end_time_min/end_time_max filters are never explained, leaving most 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 names a verb (list/query) and resource (task reports) and adds the pagination mode, so the core operation is identifiable. However, it offers no differentiation from siblings like list_task_resources or get_task_report_map_images, leaving the agent to infer scope from the name alone.

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 use this tool versus alternatives, no prerequisites, and no exclusions. The only implicit signal is 'paginated', which does not tell an agent when this listing is preferred over the related report/resource tools.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it provides none. It doesn't reveal that this is a read-only query, what a 'task resource' is, or how the include_* flags affect the response.

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

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

The text is short, but it is under-specified rather than concise — there is no front-loaded explanation, scope, or content worth the tokens spent.

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 5-parameter tool with no annotations, no output schema, and no parameter documentation is inadequately described. An agent cannot determine what resources are returned or how the include flags shape the 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?

Five parameters exist with 0% schema description coverage, and the description documents none of them. The two required params (robot_sn, map_id_list) and the include_paths/include_regions/include_positions toggles 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 is a bilingual restatement of the tool name ('List task resources'), with no elaboration beyond the name itself. 'Task resources' is vague and gives no basis for distinguishing this from siblings like list_map_resources or list_robots.

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 alternatives, and no prerequisites for how this differs from the many other list_* tools in the sibling set.

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 this is a read-only operation, not whether robot_sn must reference an existing robot, and not what the returned modes represent. For a tool with zero annotation coverage this is a complete 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?

It is short and front-loaded, but the bilingual duplication is redundant filler rather than efficiency, and the brevity stems from under-specification rather than tight writing.

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 should at minimum indicate what a work mode is and what the list returns; it does neither. For a one-parameter tool it is technically callable, but an agent has no basis for interpreting results or prerequisites.

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

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

Schema description coverage is 0%, so the description must compensate for the single undocumented robot_sn parameter, and it does not. The field name 'robot_sn' is self-explanatory enough to avoid a 1, but the description adds no meaning whatsoever beyond it.

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 '查询工作模式 / List work modes' is essentially a verbatim restatement of the tool name in two languages, adding no scope, no target entity detail, and no differentiation from the closely-related sibling describe_work_state. It conveys only that a listing happens.

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 exclusions, and no mention of alternatives such as describe_work_state or list_robots. The only inference an agent can make is that it lists work modes for a robot.

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

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

With no annotations, the description carries the full behavioral burden. It does add useful provenance — the answer comes from local reference tables plus accumulated invocation experience, which hints the answers may be incomplete or empirical — but it says nothing about what happens when a code is unknown or unrecognized.

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

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

One sentence, front-loaded with the action and resource, with no filler. It is only slightly padded by carrying the same content twice for bilingual readers, but that duplication is deliberate and does not obscure the core statement.

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 lookup with no output schema, the description should at least indicate what a result looks like or how an unresolved code is reported. It covers purpose and data provenance but leaves return shape and miss behavior unstated, which is a real gap for a lookup 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% for the single `code` parameter. The description only implies that the argument is the error code to be resolved, which adds essentially nothing beyond the parameter's own name. This is the bare minimum rather than compensating 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 gives a specific verb (look up), a specific resource (an error code), and even names the two things it returns: the code's meaning and its handling. No sibling tool in the list performs anything comparable, so an agent can unambiguously route diagnostics here.

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 never states when to reach for this tool (e.g. after a command fails or a robot reports a fault) or when it is not applicable, and it names no alternative. The parenthetical describes the data source, not the usage condition, so the agent must infer the trigger 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?

No annotations are provided, so the description carries the full behavioral burden and delivers essentially nothing beyond the action name. It does not disclose whether the call blocks or returns a command to poll (the presence of wait_for_command and get_command_status siblings makes this a real question), what happens if a task is running, or whether the robot must already be localized on the given map.

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 front-loaded phrase with no padding, which is structurally sound. However the bilingual duplication consumes space without adding information for the agent, and the brevity reflects under-specification rather than disciplined conciseness.

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

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

With no annotations, no output schema, and three undocumented parameters, the description is far too thin for a robot-command tool. An agent has no way to know the return contract, blocking behavior, or failure modes from either the description or the structured fields.

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, and the description adds no parameter meaning at all. The field names (robot_sn, map_id, map_resource_id) are largely self-explanatory, but the description does not clarify why map_resource_id is optional, when it is needed, or how map_id relates to it.

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 pairs a clear verb (navigate) with a specific destination (the charging point / home), so an agent knows exactly what the call accomplishes. It stops short of distinguishing itself from navigation-adjacent siblings such as pause_navigation, stop_navigation, or task-driven movement.

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 stated prerequisites (e.g. robot must be idle, no active task), and no mention of the competing navigation-control siblings. The agent is left to infer that this is distinct from start_task/stop_navigation on its own.

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 full burden. It doesn't state whether pausing is reversible, how long the paused state persists, whether the robot's current position is retained, or what happens if the robot isn't navigating.

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?

Very brief bilingual phrase, front-loaded with the action. It's concise but lacks any supporting details that would make it useful.

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

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

For a navigation control tool with no annotations and no output schema, the description is too sparse. It doesn't explain the paused state, resumption, or error conditions.

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

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

The single parameter robot_sn is undocumented in both schema (0% coverage) and description. The description adds no semantics about which robot or format, so it fails to compensate for the schema gap, but the parameter is self-explanatory.

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 ('pause navigation'), which is clear. It's distinguishable from siblings like resume_navigation and stop_navigation by verb, though the description doesn't contrast them 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?

No guidance on when to pause versus stop_navigation or how this differs from resume_navigation. The agent must infer usage from the name alone.

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

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

With no annotations, the description carries the full burden, yet it only restates the operation. It does not say whether the pause is temporary or resumable, what happens to the current task state, whether it is idempotent, or what permissions are required.

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?

Extremely short and front-loaded with the action; nothing is wasted, though it is arguably under-specified rather than concise.

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

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

Minimal coverage for a mutation tool: no annotations, no output schema, no behavioral details, and an undocumented required parameter. An agent would need to guess about effects and resumability.

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

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

Schema coverage is 0% and the single required parameter robot_sn is undocumented in the description. The description adds no meaning about which robot to target or the expected identifier format.

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 (pause) and implies the resource (task), which is clearer than the raw name. However, it offers no differentiation from siblings like stop_task, resume_task, or pause_navigation, so an agent cannot tell from the text why it would choose pause_task over those.

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 prerequisites, and no mention of alternatives such as stop_task or resume_task. The agent must infer usage entirely from the name and surrounding tool family.

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

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

With no annotations, the description carries the full behavioral burden. It does disclose two important traits: this is a write/persistence operation ('写入本地记忆') and it requires user approval first. However, it says nothing about reversibility, where the memory lives, whether writes are deduplicated or overwritten, or what happens after approval.

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 front-loaded sentence that leads with the action and appends the approval constraint; nothing is wasted. The bilingual duplication is deliberate audience coverage rather than padding, though it does double the length.

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

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

For a small two-parameter tool with no output schema, the description covers purpose and the approval gate, which is the minimum viable set. It leaves the 'scope' parameter and the memory semantics (persistence, retrieval, overwrite behavior) unexplained, so an agent still has open questions before invoking.

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

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

Schema description coverage is 0%, so the description must compensate. It partially clarifies 'lesson' (a single verified, reusable lesson) but gives no explanation of the optional 'scope' parameter — what it scopes, valid values, or the effect of leaving it null.

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 — writing one verified, reusable lesson into local memory — and clarifies the otherwise vague tool name 'remember'. No sibling tool in the list touches memory persistence, so there is zero ambiguity about which tool to pick.

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

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

It gives clear qualifying context (the lesson must be 'verified' and 'reusable') and states a prerequisite ('needs user approval'), which tells the agent when this tool is appropriate. It stops short of explicit when-not conditions or naming alternatives, but there are no plausible alternatives among the siblings.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it discloses nothing. It does not say whether the operation is synchronous or returns a command id for wait_for_command/get_command_status, what happens if navigation is not paused, or whether the action is idempotent or has side effects.

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

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

It is short and trivially front-loaded, so there is no bloat to penalize. However, the same two words are duplicated across two languages with no additional information, and the extreme brevity is under-specification rather than genuine conciseness.

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

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

For a state-changing robot navigation command in a suite that includes pause_navigation, stop_navigation, and wait_for_command, the description omits preconditions, expected outcome, and whether the result is immediate or tracked via a command status. With no annotations and no output schema, nothing else fills these 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% for the single required parameter robot_sn, and the description says nothing about it. The name 'robot_sn' is largely self-explanatory as a robot serial number, but the description does not compensate for the total absence of schema documentation (format, source, or ambiguity with other robot identifiers).

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

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

The description states the action (resume navigation) but it is essentially a direct restatement of the tool name in two languages, adding no scope, target, or detail. It does not distinguish itself from siblings like pause_navigation or stop_navigation beyond the obvious verb difference, which the name already conveys.

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

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

There is no guidance on when to use this tool versus navigate_home, pause_navigation, or stop_navigation, nor any stated precondition (e.g., that a navigation must currently be paused). The agent must infer all usage context from the name alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, yet it discloses nothing: not whether the operation is idempotent, what state the task must be in, whether it requires permissions, or what happens on an already-running task. For a state-mutating control tool this is a severe 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 two-word bilingual phrase is short but under-specified rather than concise; it is not front-loaded with any useful information because there is none to front-load.

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, an undocumented required parameter, and a rich sibling set of task-control tools, the definition is far too thin for an agent to invoke it correctly.

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

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

The single required parameter robot_sn has 0% schema description coverage, and the description never mentions it or explains whether it is a serial number, an ID, or where to obtain it. Nothing compensates for the schema gap.

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

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

The description 'Resume task' is essentially a restatement of the tool name resume_task, adding no verb nuance, scope, or resource detail. With siblings like start_task, pause_task, and resume_navigation in the set, no attempt is made to distinguish what 'resume' means here versus starting or navigating.

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 (e.g. the task must currently be paused), and no mention of alternatives such as start_task or resume_navigation. The agent is left to infer everything from the name alone.

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

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

With no annotations, the description carries the full behavioral burden, yet it only restates the operation. It does not disclose permissions/robot availability requirements, whether the task blocks for wait_seconds, whether it is destructive or interruptible, or what state changes occur — significant gaps for a task-launching action tool.

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

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

The single sentence is concise and front-loaded, which is good. However, the bilingual duplication adds no informational value beyond one language, and the extreme brevity is a symptom of under-specification rather than efficiency.

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

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

For an 8-parameter mutation tool with no annotations, no output schema, and 0% parameter documentation, the description is far too thin. An agent cannot confidently invoke it without knowing the meaning of required fields like resource_ids or the behavior of wait_seconds.

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, and the description adds nothing about any of them. Terms like robot_sn, map_id, resource_ids, mode, strength, loop_count, and wait_seconds are entirely unexplained in both the schema and the 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 states a specific verb pair and resource ('create and start cleaning task'), so the action is identifiable. However, it gives no differentiation from closely related siblings like start_task or create_task_definition, leaving the agent to guess how this tool relates to 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, no prerequisites, and no mention of alternatives such as start_task or create_task_definition. The agent receives no signal about which of the several task-launching siblings to choose.

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 entire behavioral burden and discloses nothing: not whether the skip is reversible, what happens to the current task execution, whether the robot must be online/busy, or what errors can occur. A single bilingual phrase is far below the bar for a mutation-style 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?

Short, but brevity here reflects under-specification rather than efficient communication. There is no structure, no front-loaded constraint, and no sentence that earns its place beyond echoing the 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-required-parameter robot operation with no annotations, no output schema, and no parameter documentation, the description supplies none of the context an agent needs to invoke it correctly. Nothing about scope, effect, or return behavior is covered.

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 sole required parameter robot_sn, and the description adds no meaning whatsoever about it. The agent gets no hint of the identifier's format, source, or role in deciding which item is skipped.

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?

"Skip task item" merely restates the tool name in two languages; there is no verb+resource elaboration beyond the name itself. It gives no indication of what a "task item" is, or how skipping relates to tasks, schedules, or robot execution, so siblings like stop_task, pause_task, and run_cleaning_task cannot be distinguished from 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?

No when-to-use, when-not-to-use, or alternatives are provided. An agent cannot tell whether this is preferable to stop_task or pause_task, nor what prerequisites (an active task? a queued item?) must hold.

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 is a mutation, what state it requires (robot online, task defined), what happens on failure, or whether it can be repeated. Two words cannot convey any behavioral traits.

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

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

The text is short but that reflects under-specification rather than effective conciseness. A two-word restatement of the name leaves the rest of the definition empty.

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 three parameters, zero schema documentation, no annotations, and no output schema, the description is completely inadequate. Nothing an agent needs to invoke it correctly 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?

Schema coverage is 0% and the description adds no parameter meaning at all. The roles of robot_sn, fusion_task_id, and especially the optional loop_count are entirely undocumented in both the schema and the 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 is essentially a bilingual restatement of the tool name ('启动任务 / Start task') with no additional scope or specificity. It does not distinguish this tool from siblings like resume_task, pause_task, or run_cleaning_task, which also operate on task lifecycle.

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

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

There is no guidance on when to use this tool versus alternatives. With siblings such as resume_task, run_cleaning_task, and create_simple_schedule, the agent has no way to know which entry point applies to a given situation.

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 delivers almost nothing: it does not state whether in-progress navigation is cancelled or merely halted, whether the robot stops in place, whether this is safe/persistent, or whether robot_sn must be online. Only the bare action is conveyed.

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 minimal, but this is under-specification rather than conciseness. The two-language duplication adds no information, and nothing about scope, effect, or prerequisites is front-loaded because nothing is present 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?

For a command-executing mutation tool with no annotations, no output schema, and an undocumented required parameter, the definition is far too thin. An agent cannot determine the effect on the robot's state or how to confirm success, so key context 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 has 0% description coverage and the description says nothing about robot_sn. While the single parameter's meaning (robot serial number) is inferable from its name, it is the only required argument and the definition never explains which robot identifier format is expected or whether it must match an active navigation command.

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 bilingual literal restatement of the tool name ('stop_navigation' → '停止导航 / Stop navigation'). It names no resource context, no scope, and does not differentiate from close siblings such as pause_navigation, resume_navigation, or navigate_home. This is the textbook tautology case.

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 pause_navigation (interruptible) or stop_task (tasks vs navigation). No prerequisites, no conditions, no alternatives are mentioned, so the agent must infer usage 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, yet it discloses nothing: whether stopping is destructive/irreversible, what happens to partially completed work, whether the task can be resumed, or what permissions are required. For a state-terminating operation this is a severe 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?

Extremely short, but this is under-specification rather than conciseness. There is no front-loaded purpose statement, no usage context, and nothing that earns the absence of 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?

In a rich task-lifecycle toolset with start/pause/resume/skip/stop variants, a two-word restatement of the name is wholly inadequate. No output schema exists to offload return-value explanation either.

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

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

The single required parameter robot_sn has 0% schema description coverage and is never mentioned in the description. Only the parameter's self-evident name hints at its meaning; the description adds no semantics about format or source of the serial number.

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?

'停止任务 / Stop task' is essentially a bilingual restatement of the tool name with no added scope, target, or context. It does not distinguish the tool from siblings such as pause_task, resume_task, or stop_navigation.

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 whatsoever on when to stop a task versus pausing it (pause_task), skipping an item (skip_task_item), or stopping navigation (stop_navigation). An agent must infer the entire routing decision.

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 supplied, so the description carries the full behavioral burden, and it discloses nothing. It is a mutation tool with 20 parameters, yet there is no mention of required permissions, reversibility, side effects on existing schedule entries, or auth requirements.

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

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

The text is short, but brevity here reflects under-specification rather than conciseness. There is nothing to front-load because no useful content exists.

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 20-parameter mutation tool with no annotations, no output schema, and zero parameter documentation, the description is completely inadequate. It gives an agent no basis for invoking 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% across 20 parameters (9 required), and the description adds no meaning for any of them. Critical fields like operation_type, plan_execute_type, semester_type, and plan_repeat_type are left entirely opaque.

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

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

The description is essentially a bilingual restatement of the tool name: '更新标准排班 / Update schedule'. The word '标准' (standard) faintly hints at a distinction from update_simple_schedule, but no verb+resource detail or explicit differentiation is provided. This is close to tautology.

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 whatsoever on when to use this versus update_simple_schedule, create_schedule, or delete_schedule, all of which appear as siblings. No prerequisites, no context, no 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 behavioral burden for a mutating operation, and it discloses nothing. It does not say whether the update replaces or merges the existing schedule, what permissions are required, whether it is destructive, or what the response contains.

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

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

The text is short, but this is under-specification rather than conciseness. A single restated phrase earns no place as a tool description and is not front-loaded with any actionable detail.

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

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

For a 20-parameter (6 required) mutation tool with no annotations and no output schema, the definition is completely inadequate. An agent cannot determine what the tool modifies, how the parameters interact, or what a successful call produces.

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 20 parameters, including opaque fields like operation_type, plan_execute_type, plan_repeat_type, site_mode, and work_mode. The description compensates with zero information about any parameter's meaning or expected values.

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

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

The description '更新简易排班 / Update simple schedule' is essentially the tool name restated in two languages, adding no scope, target, or effect information. It does not distinguish this tool from the many sibling schedule tools (update_schedule, create_simple_schedule, delete_simple_schedule, get_schedule).

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

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

There is no guidance on when to use this tool versus update_schedule, create_simple_schedule, or delete_simple_schedule. No prerequisites, no conditions, no exclusions are stated, leaving the agent to 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?

With no annotations, the description carries the full behavioral burden but discloses nothing: not whether omitted optional fields are cleared or preserved, not the required permissions, not reversibility, and not the result of the update. This is a serious gap for a mutation tool.

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

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

Extremely short, but this is under-specification rather than economy. The single restated phrase earns no informational place and leaves the definition unusable on its own.

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 mutation tool with no annotations, no output schema, and no parameter documentation, the description is wholly inadequate. Nothing an agent needs to invoke this correctly 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?

Eight parameters with 0% schema description coverage and a description that mentions none of them. The agent must guess the semantics of work_mode, loop_count, map_resource_list, and task_advance_config (nested objects) with no help from either source.

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 bilingual restatement of the tool name ('更新任务定义 / Update task definition'), adding no scope, resource detail, or distinguishing information. It doesn't clarify what aspect of the task definition is updated or how it differs from create_task_definition or get_task_definition.

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

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

No guidance is given about when to use this tool versus its siblings like create_task_definition, delete_task_definition, or update_schedule. The agent must infer usage 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 hints at blocking/waiting semantics via 'wait for ... terminal state', but never states that the call blocks, what happens when timeout_seconds elapses, whether it can fail or return a non-terminal result, or whether it is safe to retry.

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 phrase that is terse to the point of under-specification rather than genuinely concise; it is front-loaded but omits essentially all operational detail an agent would need.

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 three undocumented parameters, the definition leaves the agent without the blocking behavior, timeout semantics, or return shape. For a wait/polling tool that shares a namespace with get_command_status, this is a significant gap.

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

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

Schema description coverage is 0% for all three parameters. The description implies a request/command identifier and a waiting notion, which loosely maps to request_id and timeout_seconds, but it says nothing about robot_sn, ID formats, or the timeout's unit/default beyond the schema's own default of 60.

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 bilingual phrase 'Wait for command delivery terminal state' names a verb (wait) and a resource (command delivery), so the core purpose is inferable. However it does not distinguish itself from the sibling get_command_status, nor does it explain what a 'terminal state' delivery means, leaving the agent to guess the relationship between the two.

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 blocking wait versus the sibling get_command_status (a polling alternative), nor any prerequisite such as needing a request_id obtained from a prior command submission. Usage must be entirely inferred.

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