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

Annotations already declare readOnly, idempotent, and non-destructive behavior, so the bar is lower, yet the description adds a genuinely useful security guarantee not present in the structured data: no token is emitted in the response. It still does not say how an expired or missing token is surfaced (error vs. status field) or whether authentication is required to call it.

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

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

A single short sentence that front-loads the three things being checked and closes with the key scoping guarantee. Nothing is wasted.

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

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

An output schema exists, so return-shape explanation is not needed, and the annotations cover the safety profile. However, the entirely undocumented check_profile parameter leaves a real gap for a tool whose sole input controls response content.

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 check_profile has 0% schema description coverage and is never mentioned in the description. The phrase '账号资料' faintly hints that profile data can be included or skipped, but it never explains that check_profile toggles this behavior or that it defaults to true.

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

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

The description states a specific verb and resource: check token existence, expiry time, and account profile, and adds a scope limit ('does not output the token'). It is clear enough to distinguish from share_logout/login_start, though it does not explicitly distinguish itself from the sibling share_get_profile even though it overlaps on '账号资料'.

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

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

There is no guidance on when to call this versus share_get_profile, share_login_complete, or share_logout. The agent must infer that this is a pre-flight auth check; no preconditions or exclusions are given.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the write-but-non-destructive profile is covered. The description adds little beyond that: it does not clarify whether 'close' is a per-user mark-as-read or a global dismissal — a meaningful distinction given openWorldHint — nor whether the action is idempotent or reversible.

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

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

One short sentence with the action front-loaded and zero filler. It is efficient, though the terseness borders on under-specification rather than maximal 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 one required parameter, full schema coverage and an output schema, the mechanical requirements to call it are covered. The remaining gap is conceptual: the dual framing '关闭 / 标记已读' leaves the resulting state ambiguous, which matters for a non-destructive but state-changing call in an open-world context.

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

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

Schema coverage is 100% and banner_id is documented as a positive integer platform object ID, so the schema carries the load. The description adds no extra meaning about the parameter (e.g. where IDs come from), which is acceptable at baseline for a single-parameter tool.

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

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

States a specific verb pair (关闭/标记已读) and a specific resource (某条平台公告), so an agent can tell this mutates a single banner rather than listing them. It does not explicitly name share_list_banners as the discovery counterpart, but the singular '某条' plus an ID parameter makes the distinction clear.

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

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

There is no explicit when-to-use guidance, no mention of prerequisites (e.g. obtaining banner_id from share_list_banners), and no note on when to use this versus simply ignoring a banner. The usage is only inferrable from the verb and the required ID.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds real value beyond that: the fee is deducted from the amount for internal vs. charged on top for external, and execution is gated on confirm=true. It does not say what happens when confirm is false (preview, validation-only, or nothing), which is the main remaining 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?

Four short clauses, front-loaded with the action, then fee semantics, then the confirm rule. The '2–20' clause duplicates the schema's minimum/maximum and is the one piece that does not earn its place.

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

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

An output schema exists, so return values need not be described. However, for a destructive, irreversible points transfer, the description omits what confirm=false actually does, whether the transfer can be undone, and what the address refers to, which an agent needs to invoke it 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 only 25%, so the description must carry the load. It does explain fee_mode's two enum values behaviorally and clarifies the confirm gate, but 'address' (the recipient identifier) is completely undocumented in both schema and description, leaving one of four parameters blind.

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

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

The description opens with a specific verb+resource ('发起积分转账' — initiate a points transfer), which contrasts clearly with sibling reads such as share_list_point_transfer_records and share_get_point_transfer_quota. It never names a sibling or states which it is not, so it stops short of a 5.

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

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

'confirm=true 执行' gives one concrete execution precondition, which is useful, but there is no guidance on when to pick internal vs external fee_mode or how this differs from share_handle_point_transfer. Usage is only implied from the description.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false, and the description adds the useful 'own comment' authorization boundary plus the confirm=true execution gate. However it does not disclose irreversibility, whether replies cascade, or what happens without confirm, which a destructive tool warrants.

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

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

Two short sentences, front-loaded with the action and resource. Efficient, though the terseness is close to under-specification for a destructive tool.

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

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

The output schema and 100% parameter coverage reduce the description's burden, and annotations carry the safety profile. Still, a destructive deletion tool benefits from noting irreversibility or cascade behavior, which is 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 coverage is 100%, with both comment_id and confirm fully described in-schema, so the baseline is 3. The description reinforces the confirm gate but adds nothing about comment_id semantics beyond the schema.

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

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

Names a specific verb (删除) and resource (自己的评论), clearly distinguishing it from share_delete_material and the read-oriented share_list_comments siblings. The 'own' scope qualifier is a useful differentiator, though no sibling is explicitly named.

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

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

'confirm=true 执行' tells the agent how the call must be made but not when to choose deletion over an alternative (e.g., report_comment for someone else's content). Usage context is implied from the scope word 'own', leaving the when-not scenario unstated.

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

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

Annotations already flag destructiveHint=true and readOnlyHint=false, and the description adds the consequential detail that deletion may be irreversible (可能无法恢复) plus the two-step confirm requirement. It stops short of stating permission requirements or whether the delete is soft or hard.

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

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

Two short sentences with zero filler; the scope and irreversibility warning come first and the confirm gate second, which is the right front-loading for a destructive operation.

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

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

An output schema exists and annotations carry the safety profile, so the description covers what remains: scope, irreversibility, and the confirm contract. Only minor gaps (what the response returns, whether the delete is recoverable by admin) keep it from a 5.

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

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

Schema description coverage is 100% and both params (confirm, material_id) are already documented in the schema. The description only reinforces that confirm=true triggers execution, adding no format or edge-case detail beyond the schema, so the baseline of 3 applies.

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

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

States a specific verb+resource (删除资料) and narrows scope to the caller's own uploads (自己上传的资料), which separates it from share_update_material or share_delete_comment. It does not name an alternative sibling explicitly, so it falls just short of a 5.

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

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

The scope restriction to self-uploaded materials and the confirm=true execution gate imply when the tool applies, but there is no explicit 'use X instead' or when-not-to-delete guidance. Usage is implied rather than spelled out.

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

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

Beyond the annotations, the description discloses that the download is streamed, writes to local storage, returns path/size/SHA-256, does not auto-redeem points, and auto-renames same-name files by default. These are concrete behavioral traits that help the agent predict side effects, though permissions and overwrite behavior are not fully explained.

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

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

The description is a single compact sentence with the core action front-loaded and no wasted clauses. Each semicolon-separated detail adds distinct value, including return values, redemption behavior, and filename handling.

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?

An output schema exists and the description mentions return values, while annotations cover the safety profile. However, the low parameter-description coverage and missing usage guidance around redemption alternatives leave notable gaps for an agent deciding how to call the tool correctly.

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

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

Schema description coverage is only 25%, with material_id being the only documented parameter. The description hints at filename-collision behavior with '默认同名文件自动改名', but it does not explain overwrite or output_dir semantics, leaving most parameters undocumented in both schema and description.

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

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

The description states a specific action and resource: stream-downloading a material to local storage, returning path, size, and SHA-256. It distinguishes itself implicitly from URL-only siblings like share_get_download_url by emphasizing local streaming, but it does not explicitly name alternatives.

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

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

No explicit guidance is given for when to use this tool versus share_get_download_url, share_purchase_material, or share_redeem_points. The note '不会自动兑换' is an important caveat, but it stops short of telling the agent what to do instead when redemption is required.

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

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

Annotations already declare readOnlyHint, idempotentHint, and non-destructive, so safety is covered. The description adds that results come as code-plus-label pairs, which is mildly useful, but says nothing about caching, localization, or ordering. With annotations carrying the behavioral load, this is adequate rather than rich.

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

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

A single short sentence with the resource front-loaded and zero filler. Every word earns its place; there is no padding or redundancy.

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

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

For a zero-parameter reference lookup with an output schema and read-only annotations already in place, this is nearly complete. The only gap is not tying the result to the downstream share_report_comment call that consumes these codes.

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

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

Zero parameters, so there is nothing for the description to disambiguate; baseline is 4. The sentence correctly signals that the tool takes no input and only returns reference data.

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

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

States a specific verb and resource: retrieve comment report reason codes and their display text. It is distinguishable from the sibling share_get_material_report_reasons by subject matter (comments vs. materials). It does not name that sibling explicitly, but the resource scope is clear.

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

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

Usage is only implied: an agent can infer this is a lookup table to consult before calling share_report_comment, but the description never says when to use it or points at the report tool. No exclusions or alternatives are stated.

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

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

Annotations already declare readOnly, idempotent, openWorld and non-destructive, so the safety profile is covered. The description adds useful scope information about what the response contains (details, intro, syllabus, category, optionally classes), but says nothing about failure behavior for an invalid course_id or any access restrictions.

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

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

A single compact sentence with the core resource listed first and the optional class listing trailing after the semicolon. Nothing is wasted, though the enumerations are dense and could be split for easier scanning.

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 two-parameter read tool with full annotations and an output schema, the definition covers what is needed to invoke it correctly; return values need not be described. The remaining gap is routing guidance against same-domain siblings that also read course or class data.

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 50%: course_id is documented in the schema, and include_classes has no schema description at all. The clause '可同时列教学班' effectively explains the effect of include_classes, but it never ties that meaning to the parameter name or states its default (false), so the compensation is only partial.

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 (读取) plus the resources returned: course details, intro, syllabus, and category, and notes that teaching classes can be included. That is clear enough to separate it from list-style siblings, though it never explicitly contrasts itself with share_list_course_classes, which also exposes class listings.

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

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

Usage is only implied: the tool is for fetching one course's detail, and the clause '可同时列教学班' hints when to set include_classes. There is no explicit when-to-use vs. when-not, and no mention of alternatives such as share_search_courses for discovery or share_list_course_classes for class-only 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true, and destructiveHint=false. The description adds useful behavior beyond that: results are grouped by teaching class, unarchived items are listed separately, and returns are capped per group. It does not explain whether the cap silently truncates results or how to fetch beyond the limit.

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

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

The description is a single front-loaded sentence: the primary action comes first, followed by the separate unarchived listing and the per-group limit. Every clause contributes information, though the compressed semicolon structure slightly reduces immediate 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?

An output schema exists, so return values need not be explained, and annotations cover the safety profile. The description is adequate for a two-parameter read tool but leaves a selection gap: it does not explain when to use this tree-oriented tool instead of sibling material listing/search 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?

Schema coverage is 50%: course_id has its own description, while max_materials_per_class does not. The phrase '限制每组返回数量' compensates by clarifying that max_materials_per_class controls the per-group return cap, but it adds no units, default behavior, or interpretation of 'group' beyond the schema's minimum/maximum/default.

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

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

The description states a specific action (读取课程资料树) and scope (按教学班), plus two distinguishing outputs: unarchived materials listed separately and a per-group return limit. The word '树' helps differentiate it from flat list siblings like share_list_course_materials, though no sibling is named explicitly.

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

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

It implies the use case: retrieving a course material tree organized by teaching class, with unarchived materials surfaced separately. However, it gives no explicit when-not guidance and does not contrast with share_list_course_materials, share_search_materials, or share_get_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?

The annotations already establish read-only, idempotent, non-destructive behavior. The description adds important security context beyond annotations: the returned link carries temporary permissions and should not be shared publicly. It does not contradict annotations.

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

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

The description is short and front-loaded: it states the action first, then the redemption prerequisite, then the sharing warning. Every clause carries useful information and there is no waste.

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

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

Given the output schema, rich annotations, and single well-documented parameter, the description is nearly complete. The remaining gap is that it does not route the agent between this tool and the sibling share_download_material tool.

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

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

There is only one parameter and schema description coverage is 100%; the schema already documents material_id as a positive integer platform object ID. The description does not add further semantic detail about that parameter, so the baseline of 3 is appropriate.

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

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

The description states a specific verb and resource: 获取临时下载链接 (get a temporary download link). It is clear what the tool does, but it does not explicitly differentiate from the sibling share_download_material tool, so it misses the sibling-routing clarity of a 5.

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

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

The phrase 可能需要先兑换资料 (may need to redeem the material first) gives an implied prerequisite, which is useful. However, it does not say when to use this versus share_download_material or share_purchase_material, nor does it state exclusions, so usage guidance remains partly inferred.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is fully covered without the description. The description's field enumeration adds useful context about what it returns but doesn't disclose access requirements (for example, whether a material still needs purchasing or points), nor any error behavior for invalid IDs. With annotations carrying the burden, a 3 is right.

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

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

A single compact sentence with the action front-loaded and no filler. The field list is somewhat redundant with the output schema, but it is short enough to remain efficient.

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

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

The tool is simple: one integer parameter, rich annotations, and an output schema, so the description needn't explain return values. Listing the returned fields is enough for an agent to know what it gets. The only shortfall is the missing routing guidance to sibling list and search 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?

There is only one parameter, material_id, and the schema description coverage is 100%, with '平台对象 ID，正整数' already explaining it. The description adds no meaning beyond the schema for this parameter. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description names a specific verb (读取) and resource (资料) and enumerates the fields returned — details, description, file size, point price, uploader, redemption count, like status, and page link. This clearly separates it from list-style siblings such as share_search_materials or share_list_course_materials, which return many materials. It does not, however, name a sibling it is explicitly not, so the differentiation is implicit rather than explicit.

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

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

Usage is implied: it reads the detail of a single material, so it comes after a search/list step. But the description never says when to call this versus share_search_materials, share_get_course_materials, or share_list_course_materials, and it gives no prerequisite about where material_id comes from.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, openWorldHint=true and destructiveHint=false, and an output schema documents the returned codes and text, so the sentence adds essentially no behavioral context. Nothing is said about what happens with an unknown material_id, whether an item must exist or be visible to the caller, or about 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?

One compact sentence with no filler, and the resource scope (举报资料) is front-loaded. It is efficient, though its brevity edges toward under-specification rather than tight completeness.

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

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

For a simple lookup with rich annotations, a fully documented single parameter, and an output schema, the description covers the minimum needed to call it correctly. It still omits why an agent should call it (to feed a reason code into share_report_material) and any failure/edge-case context.

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

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

Schema description coverage is 100% for the single parameter (material_id, 平台对象 ID，正整数), so the schema fully documents it. The description contributes no extra meaning about the ID or its constraints, making the baseline 3 correct.

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 a specific resource (举报资料的可用 reason code 与文案), so an agent knows exactly what the call returns. It also implicitly separates itself from share_get_comment_report_reasons by scoping to 资料 (material), though it never names the 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?

Usage is only implied: an agent can infer this is the lookup to run before share_report_material to obtain valid reason codes. There is no explicit when-to-use/when-not statement, no mention of prerequisites, and no pointer to the sibling comment variant.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is fully covered. The description adds the useful behavioral detail that results span multiple sources (balance, quota, three partner sites), implying an aggregated cross-service read. It omits auth prerequisites and that partner-site figures may be fetched live (openWorld), so it adds some but not rich context.

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

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

A single short sentence that front-loads the action and lists the three aggregated values with no filler. Nothing redundant, nothing to trim.

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

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

With an output schema present, return-value explanations are unnecessary, and with zero parameters the schema burden is nil. What remains missing is the relationship to sibling points tools, which matters given a crowded points family. Otherwise the description is sufficient to call the tool correctly.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; per the baseline rule this scores 4. The description correctly implies the call needs no scoping inputs.

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

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

The description names a specific aggregation action and enumerates the three quantities it combines (points balance, monthly received transfer quota, redeemable points at partner sites). This is far more informative than a tautology. It stops short of 5 because it does not explicitly distinguish itself from the nearby share_get_point_transfer_quota, which covers overlapping subject matter.

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 alternatives. The sibling set contains several closely related points tools (share_get_point_transfer_quota, share_get_redeem_quota, share_list_my_point_logs), yet the description does not say whether this is a dashboard summary to call first or a redundant view. Usage is only inferable from the name and field list.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered structurally. The description's contribution beyond that is the fact that the returned value is meant to be shared with a transferring party — useful, but thin given an output schema already documents the return value.

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

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

A single short sentence with the resource front-loaded and zero filler; nothing to trim.

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 inputs, a full annotation set, and an output schema present, the definition covers what an agent needs in order to call it. Minor residual gap: it does not say whether the address is stable across calls or tied to the current session/account, which matters for a tool returning something you hand to a third party.

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

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

The tool takes zero parameters and the schema is empty, so there is nothing about inputs the description could or should explain. Baseline 4 applies.

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

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

States a specific verb (获取/get) and a specific resource (我的积分收款地址 / my points receiving address), which clearly separates it from sibling tools like share_create_point_transfer or share_get_points_overview. It does not explicitly name or contrast with a sibling, so it lands just short of a 5.

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

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

The clause "可交给转账方" implies the intended situation — you obtain the address in order to hand it to a counterparty who will send you points. That is an implied usage context rather than an explicit when-to-use/when-not-to-use rule or a named alternative.

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

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

Annotations already declare readOnly, idempotent, non-destructive and open-world, so the safety profile is covered. The description adds real behavioral context beyond that: the data is scoped to the current month and to received (incoming) transfers only, and it is broken into used, pending, reserved and remaining buckets — including a pending state an agent should know about.

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 sentence with zero filler, front-loading the verb and resource before the breakdown of returned fields. Nothing could be removed without losing 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?

An output schema exists, so return formatting need not be explained, and the zero-parameter schema needs no coverage. The remaining gap is minor: nothing says whether the buckets are per-currency or whether an empty result means no incoming transfer address exists yet.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The only implicit parameter-like choice, the time window, is fixed by the description to the current month.

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

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

States a specific verb (查看) and resource (本月接收转账额度) and enumerates the four buckets returned (已用/待处理/预留/剩余), so an agent knows exactly what data this yields. It does not explicitly contrast itself with the near-miss siblings such as share_get_redeem_quota or share_list_point_transfer_records, leaving differentiation to 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?

The '本月' scope implies this is a status check for incoming point transfers, which an agent can reasonably link to share_create_point_transfer/share_handle_point_transfer. However, there is no explicit when-to-use statement, no exclusion of alternatives, and no prerequisite (e.g. login) called out.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false, and openWorldHint, so the safety profile is covered. The description adds which fields come back, but says nothing about authentication requirements or whether a missing profile yields an error versus an empty result.

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 naming the actor and the fields, with no wasted words. Nothing is buried.

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

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

A zero-argument read with an output schema and full annotations needs little prose, and the description covers the field scope. The only gap is the implicit-auth assumption, which is minor for this shape of tool.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The field list loosely maps to what would otherwise be parameters, which adds a little context.

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?

Specific verb (读取) plus a specific resource (当前用户 profile) with an enumeration of the fields returned. It is clearly distinguishable from share_update_profile, though it does not explicitly call out the overlap with share_get_points_overview's points balance.

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

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

Usage is only implied: 'current user' signals this is the self-profile read with no arguments, and the sibling share_update_profile covers the write case. There is no explicit when-to-use statement or exclusion (e.g., when to call this versus share_get_points_overview for the balance).

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false and openWorldHint=true, so the safety profile is covered without prose. The description adds no further behavioral context (auth requirements, freshness of quota, failure modes), so it clears the lower bar set by annotations but does not exceed it.

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

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

A single compact line that front-loads the purpose and then enumerates the enum mapping. Every clause earns its place with no filler.

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

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

An output schema exists, so return values need not be explained, and the one ambiguous parameter is fully decoded. What's missing is the relationship to the redeem flow and to sibling quota tools, which matters given the large sibling set.

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

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

Schema description coverage is 0%, so the description must carry the parameter meaning — and it does, by decoding each enum value (shuiyuan=水源, sjtuplus=选课社区, sjtuwiki=交大 Wiki). Those codes are opaque in the schema alone, so this is genuine added value; only the format/validity of the returned quota per source is left 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?

States a specific verb (查看/view) and resource (合作站点可兑换积分 — partner-site redeemable points), so the agent knows exactly what is returned. It does not distinguish itself from close siblings such as share_get_point_transfer_quota or share_get_points_overview, so the agent must infer which 'quota' view it needs.

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

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

Usage is only implied: the agent can guess this is a pre-check before share_redeem_points, but no when-to-use, when-not-to-use, or explicit alternative is named. The description also doesn't say whether login/auth is required despite many auth-related 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?

Annotations already declare destructiveHint=true, openWorldHint=true and readOnlyHint=false, so the risk profile is largely carried by structured data. The description adds real value with the 'confirm=true 执行' gate and the action values, but omits consequences (e.g. points irreversibly moved on accept, whether reject is reversible).

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

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

Two short clauses, front-loaded with the action and followed by the execution gate; nothing is padded. Brevity is appropriate, though the terseness could arguably be at the expense of useful context.

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

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

An output schema exists so return values need not be explained, and annotations cover destructiveness. However, for a mutating, destructive transfer-handling tool with no mention of auth prerequisites or what accept/reject actually does to the balance, the description leaves gaps an agent would want filled.

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 67% and the action enum has no schema description, so the description usefully supplies 'action=accept/reject' and clarifies that confirm=true is the executing flag. transfer_id is left entirely to the schema, so it neither fully compensates nor adds nothing.

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 ('accept or reject') and resource ('待处理转账' / pending transfer), which cleanly separates it from the create_ and list_ point-transfer siblings. It does not name those siblings explicitly, so it stops short of a 5.

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

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

Usage is only implied: it operates on a 'pending transfer' with action=accept/reject, implying the transfer must already exist and be pending. No explicit when-to-use, when-not, or pointer to share_list_pending_point_transfers as the prerequisite step.

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

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

Annotations already flag openWorldHint=true and readOnlyHint=false, so the external-auth nature is partly covered. The description adds real workflow context the annotations cannot convey: the URL is lesson-sync specific, not general login, and the callback code feeds a subsequent sync-task creation. It omits whether a prior login is required, URL lifetime, and what a failure looks like.

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

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

Two compact sentences with the tool's distinguishing trait front-loaded. No filler, though the terseness is partly what leaves the parameter unexplained.

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

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

An output schema exists, so return values need no prose. However, for an OAuth-style initiation step in a multi-tool flow (share_lesson_sync_start / share_lesson_sync_status), the description lacks auth prerequisites, the redirect_uri contract, and where the callback code is consumed, leaving the flow underspecified.

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

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

The single optional parameter redirect_uri has 0% schema description coverage and is never mentioned in the description. The phrase '回调 code' hints at a redirect/callback flow but does not explain what value redirect_uri should take or what happens when it is omitted, leaving the agent to guess.

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+resource: fetch the lesson-sync-dedicated jAccount authorization URL, and explicitly contrasts it with normal site login. This lets an agent distinguish it from the generic share_login_start flow. It stops short of naming the sibling tool outright.

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?

'与普通站点登录不同' implicitly tells the agent to use this for course sync rather than the regular login path, and the second sentence supplies the follow-up step (use the callback code to create the sync task). It gives clear context but never explicitly names the alternative tool or states preconditions such as requiring an existing session.

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

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

The annotations already declare destructiveHint=true, openWorldHint=true and readOnlyHint=false, so the description does not need to explain the safety profile. The description adds the key behavior that this is an asynchronous background task and that nothing runs unless confirm=true; the schema default is false. These are real additions that shape how the agent calls the tool. It does not say what the destructive sync does to existing data, which is a remaining 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?

Three short clauses carry the action, the follow-up, and the confirm gate, with nothing wasted. The ordering is front-loaded correctly, starting with what the tool does before moving to caveats. The telegraphic style, with clauses separated by semicolons and periods, is slightly cryptic, but the content is effective.

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?

An output schema exists, so return values need no explanation, and the annotations carry the destructive and open-world warnings. However, the required redirect_uri is undocumented, and the description never says what the sync does to existing lesson data even though destructiveHint=true. For a destructive, async, auth-based operation, that leaves meaningful 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 coverage is only 33%: only confirm has a schema description, and code and redirect_uri are bare strings. The description identifies the code as a lesson sync authorization code and explains confirm, but redirect_uri is required and unexplained in both places. It therefore covers two of three parameters and leaves one important 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 uses a specific verb and object: create a background task using a lesson sync authorization code (用课程同步授权码创建后台任务). That is clearer than a restatement of the name. It also names share_lesson_sync_status, so an agent can distinguish this tool from the sibling that handles polling rather than creation.

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

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

The two-step sequence is explicit: first call this tool, then poll share_lesson_sync_status. The clause 'confirm=true 执行' tells the agent that the tool executes only when confirm is set to true. It gives working context but no explicit exclusion or prerequisite conditions beyond having a code.

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

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

Annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds useful context by saying it surfaces error information (i.e. failures are reported in-band rather than thrown). It omits polling semantics and whether status values are terminal, which matters for an async-task 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?

A single tight sentence with zero filler, front-loaded on the resource being queried. Appropriately sized, though it is so terse that it leaves obvious gaps rather than wasting words.

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

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

An output schema exists, so return values need not be spelled out, and the description still summarizes the three fields surfaced. However, for an async task-status tool, the missing link to the sibling start/login tools and the absence of any polling guidance leave a real gap for an agent orchestrating a sync.

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

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

One required parameter with 0% schema description coverage, so the description carries the full burden — but it never explains what task_id is or where to obtain it (presumably from share_lesson_sync_start). Format and provenance are left entirely to inference.

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?

Specific verb (查询) plus specific resource (课程同步任务) and it even enumerates what is returned: status, sync count, and error info. It does not differentiate itself from the sibling share_lesson_sync_start / share_lesson_sync_login_url, so an agent must infer that this is the polling step of that workflow.

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

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

Purely a purpose statement: there is no when-to-use, no note that it should be called after share_lesson_sync_start, no guidance on polling cadence or when to stop retrying. Usage is only implied by the tool name and the word 'task_id'.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint and destructiveHint=false, so the safety profile is fully covered elsewhere. The description adds only that returned content includes title, body and status, which is largely duplicative given an output schema exists; it discloses nothing about freshness, caching, or visibility of announcements.

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

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

A single short sentence with no filler, and the field list is front-loaded immediately after the verb. It is appropriately sized for a zero-parameter read tool, though it is so terse that it offers no structural signposting beyond the one clause.

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 zero parameters, a 100%-coverage schema, an output schema and rich annotations, most of the burden is already carried by structured fields, so the description is close to sufficient. The remaining gap is routing: an agent cannot tell from the description alone when to use this versus share_close_banner or other listing 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 tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description does not waste words inventing parameter semantics that do not exist.

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

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

The description gives a specific verb (读取) and a specific resource (平台公告) and enumerates the fields returned (标题、正文与状态), which lets an agent tell this read operation apart from the mutating sibling share_close_banner. It is clear, though it never names the resource with the same term as the tool name 'banners', requiring the agent to infer that 公告 == banner.

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

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

There is no explicit guidance on when to call this versus alternatives; the agent must infer from the name that share_close_banner is the write counterpart. No prerequisites, ordering, or exclusion conditions are stated.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds only that results are paginated, which is useful but largely duplicated in the schema; it says nothing about return shape, ordering behavior, or auth needs.

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

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

It is a single short sentence with the core action front-loaded and no wasted wording. It is arguably too terse for a five-parameter listing tool, but it is structurally clean.

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?

An output schema exists and annotations are rich, reducing the description's burden. However, for a five-parameter paginated listing tool, the description omits any mention of sorting, page-size limits, or how replies relate to the required comment_id and material_id, leaving noticeable 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 80%, so most parameters are already documented in the schema. The description adds no meaning beyond 'paginated' and does not explain the sort enum options or the comment/material relationship.

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

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

The description states a specific verb and resource: paginated reading of replies under a comment. It is clearly distinct in meaning from the sibling share_list_comments, but it does not explicitly name or contrast with that sibling, so it falls short of a 5.

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

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

There is no guidance on when to use this tool versus alternatives such as share_list_comments, nor any stated prerequisites. The intended use is only implied by the phrase 'replies under a comment'.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is covered. The description adds only that results are paginated; it says nothing about ordering defaults, empty-result behavior, or visibility/auth constraints that the annotations don't cover.

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

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

A single compact clause: pagination behavior first, then the sort vocabulary. Nothing is redundant with the schema and nothing is wasted.

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

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

With annotations covering safety, an output schema covering return values, and the sort enum now explained, the definition is nearly complete. It leaves a minor ambiguity about whether the listing includes reply comments (a sibling handles replies) but otherwise covers what an agent needs.

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 75%, and the one gap is the `sort` enum, which has no per-value description in the schema. The description fills exactly that gap by mapping old/new/like to 最早/最新/最热, adding real meaning beyond the structured fields.

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

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

The description gives a specific verb and resource ('分页读取资料评论'), making it clear this is a paginated read of a material's comments. It does not explicitly distinguish itself from the close sibling share_list_comment_replies, but the object (资料评论 vs replies) is implied well enough.

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

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

Usage is only implied — an agent can infer this is the tool for listing comments on a given material. There is no explicit when-to-use/when-not guidance, no mention of share_list_comment_replies as the alternative for reply threads, and no stated preconditions.

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

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

Annotations already declare readOnlyHint, idempotentHint, non-destructive behavior, and openWorldHint. The description adds useful context beyond the annotations by specifying what the response contains (classes, teachers, material counts) and the upload-related workflow it supports.

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 compact: one sentence with two clear clauses, front-loading what is listed and then the upload prerequisite. Every clause contributes 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 simple, fully specified read operation with an output schema and rich annotations, the description is complete enough to call correctly. It covers the resource, returned content, and the primary workflow reason to use 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?

There is only one parameter, course_id, and schema description coverage is 100%, so the schema already documents it as a positive integer platform object ID. The description implies a course context but adds no syntax or format details beyond the schema.

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

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

The description states a specific verb-resource pair: it lists a course's teaching classes, teachers, and material counts. It also adds the distinctive operational detail that the returned class_id is required for uploading, which separates it from siblings such as material-listing tools.

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

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

The description clearly identifies the key usage scenario: call this when a class_id is needed before an upload. It does not name alternatives or state when not to use the tool, so it falls short of explicit when/when-not guidance.

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

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

Annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds only the implicit hint that results are 'flattened', which is mildly useful context for the returned shape, but it omits pagination/limit behavior and scope beyond the filters listed.

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

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

One compact sentence with zero filler, and the core capability is front-loaded. It is slightly under-specified rather than verbose, which is the lesser problem here.

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

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

With an output schema and annotations present, the description needn't explain return values or safety, and it covers most filters. But for a 6-parameter, list-style tool with a max_results cap of 300 and no differentiation from sibling listing tools, an agent is left with meaningful gaps about scope and limits.

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

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

Schema description coverage is only 17%, so the description must carry the load: it explains that query filters by name/description and maps material type, free-only, and the four sort modes, which meaningfully compensates for the undocumented query parameter. It still leaves course_id and max_results (the 300 cap) undescribed.

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 resource (课程资料/course materials) and enumerates the supported filter and sort dimensions, so the operation is clear. However, it does not distinguish this listing tool from close siblings such as share_get_course_materials, share_search_materials, or share_list_my_uploads, and the term '展平' (flatten) is unexplained.

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

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

The description never states when to use this tool rather than the sibling material-listing or material-search tools. The filter/sort enumeration implies a browsing use case but leaves the agent to infer routing.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered. The description adds a useful caveat that type IDs are defined by the API response and should not be assumed, but it omits auth requirements, ordering, and pagination behavior.

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

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

The description is two short clauses with no filler. The purpose is front-loaded, followed by the important caveat about server-defined IDs.

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

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

For a zero-parameter read-only listing with an output schema, the description covers what is returned and warns that IDs come from the API. It could add a little more context about when these types are needed or whether authentication is required, so it is strong but not fully complete.

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

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

The tool has zero parameters and schema description coverage is 100%. Per the rubric, zero parameters gives a baseline of 4, and the description does not need to compensate for undocumented inputs.

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

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

The description names a specific verb (获取/get) and resource (资料类型及 ID/material types and IDs). The word 类型 (type) distinguishes this taxonomy lookup from sibling material tools such as share_get_material and share_list_course_materials.

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, prerequisites, exclusions, or alternatives are stated. The only implied use is retrieving type IDs, but nothing says whether this should be called before upload, search, filtering, or other material 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?

Annotations already state that the tool is read-only, idempotent, non-destructive, and open-world. The description adds useful scope by saying the result includes courses, teaching classes, and teachers, but it does not explain authentication requirements, pagination, or output behavior beyond what the annotations and output schema provide.

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

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

The description is two short sentences with no wasted text. The main action is front-loaded, and the semester caveat is appended efficiently.

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

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

The tool is a simple read-only list operation with annotations and an output schema, so the description does not need to explain return values. However, because both input parameters lack schema descriptions, the description should do more to explain the expected year format and semester constraints to be fully complete.

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

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

Schema description coverage is 0% for the two required parameters. The description partially clarifies semester by saying it is usually 1/2/3 and should follow the user's semester interface, but it gives no format or meaning for the year parameter and leaves year semantics largely undocumented.

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

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

The description states a specific verb and resource: listing the user's courses, teaching classes, and teachers by academic year and semester. It is clear enough to distinguish the tool from broader course search tools, but it does not explicitly name the sibling alternatives such as share_search_courses or share_list_course_classes.

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

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

Usage is implied by the name and description: call this when you need the user's own courses for a given year and semester. The description adds guidance about semester values, but it does not state when not to use this tool or point to an alternative sibling tool.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is fully covered. The description adds nothing beyond restating the filter/sort options that live in the schema — no pagination behavior, no auth requirement, no scope caveats.

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

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

A single dense clause with no padding, and the filter/sort capability is front-loaded. Only the missing verb keeps it from being ideal.

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?

An output schema exists, so return values need not be described. Pagination parameters are documented in the schema. What remains missing — when to choose this over sibling record listings — is a real gap for a 5-parameter listing 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 only 40%, but the description partially compensates by naming the type values (materials/redeem/bonus/transfer) and the sort fields (date/delta). It adds no meaning for order or for how type interacts with sorting, leaving a gap.

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

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

The description names the resource (积分流水 / point logs) and its filter and sort capabilities, but supplies no verb and does not distinguish it from overlapping siblings such as share_list_point_transfer_records or share_list_redeem_records, which an agent could easily mistake for this tool.

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

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

The description never states when to use this tool versus the nearby record-listing tools, nor any prerequisites (e.g., login state). The available filters are implied but there is no routing guidance.

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

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

The annotations already declare readOnlyHint, idempotentHint, and destructiveHint=false, so the safety profile is covered. The description adds only that the tool is paginated and returns redemption times, which is modest added value; it says nothing about ordering, page-size limits, or an empty-history result. With annotations carrying the safety burden, a 3 is appropriate.

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

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

It is a single short sentence with no filler, and the pagination scope is stated first. Nothing is wasted, but the brevity comes at the cost of routing detail rather than structure.

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?

An output schema exists, so return values needn't be explained, and both parameters are fully documented. The remaining gap is disambiguation from share_list_redeem_records and share_list_my_uploads, which the description does not address and which an agent would need in order to choose correctly.

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

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

Schema description coverage is 100%, with 'page' and 'page_size' fully documented, including defaults and the 100 maximum, so the schema bears the weight. The description adds only the word '分页', which the schema already conveys. Baseline 3 applies when the schema documents every 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 uses a clear verb-plus-resource ('分页列出我兑换的资料与兑换时间'), stating both the paginated list and the columns returned (materials and redemption times). However, it does not distinguish this from the very similar sibling share_list_redeem_records, leaving the agent to guess which one surfaces redeemed materials.

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

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

There is no explicit guidance on when to use this over alternatives and no exclusions or prerequisites. The 'my' scope implies user-scoped auth, but the description never states that callers reach it through an authenticated session, nor points to share_list_redeem_records or share_list_my_uploads as distinct routes.

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

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

Annotations already declare this as a safe read-only, idempotent, non-destructive operation. The description adds only the useful scope detail that results are '已同步' (synchronized), but it does not add further behavioral context such as ordering or scope limitations.

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

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

The description is a single front-loaded sentence with no wasted wording. It is appropriately sized for a parameterless list 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?

With zero parameters, an output schema, and annotations covering safety traits, the description is mostly complete. It could clarify how 'my terms' differs from general term listings, but the core operation is adequately conveyed.

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

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

The tool has zero parameters, so there are no parameter semantics to explain. The empty schema and full schema coverage make this baseline appropriate.

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

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

The description states a specific verb, '列出' (list), and specific resources, '学年 year' and '学期 semester', so the operation is clear. It does not explicitly differentiate this from sibling list tools or clarify the 'my' scope, which keeps it from being a 5.

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

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

The description only states what is listed. It gives no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions, so an agent must infer usage entirely.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so the safety profile is fully covered without the description. The description only adds that results are paginated, which is modest added context for a read-only listing tool; nothing about ordering or default page behavior beyond the schema.

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

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

A single short sentence with zero padding, front-loading the pagination aspect. It is efficient, though the terseness comes at the cost of any routing or behavioral 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?

An output schema exists and the annotations cover the safety profile, so return-value explanation is not needed. Still, for a listing tool sitting among ~50 siblings with overlapping material-listing capabilities, the definition gives the agent no way to confirm this is the right choice over the alternatives.

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

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

Schema description coverage is 100% and both parameters (page, page_size) carry their own Chinese descriptions with defaults and bounds. The description's mention of 分页 mirrors the schema without adding format, ordering, or max-page guidance, so the baseline 3 applies.

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

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

The description names a specific verb (列出/list) and resource (我上传的资料/my uploads) plus the pagination scope, so its domain is clear. It does not, however, distinguish itself from close siblings such as share_list_course_materials or share_search_materials, leaving the agent to infer the difference 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 the many other list/search/material tools in the sibling set, and no prerequisites or exclusions. The agent must infer usage purely from the tool name and the word 我上传的.

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

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

Annotations already declare readOnly, idempotent and non-destructive, so the safety profile is covered. The description adds the useful scoping fact that results are limited to transfers pending the caller's acceptance, but says nothing about pagination, result volume, or expiry of pending items.

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

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

One short sentence, front-loaded and free of filler. It is arguably too terse for a tool embedded in a 50-sibling ecosystem, but nothing in it is wasted.

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

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

An output schema exists so return-shape explanation is unnecessary, and with no parameters the surface is small. Still, an agent gets no signal about the follow-up action (share_handle_point_transfer) or how this list differs from share_list_point_transfer_records, leaving a real gap in a crowded sibling set.

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

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

The tool takes zero parameters, which is the baseline-4 case; there is nothing for the description to disambiguate. It does not, however, note that the result set is unscoped by any filter, which would have been the only added value available here.

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 (查看/list) and a clearly scoped resource: point transfers waiting for the caller to accept. The qualifier '等待我接受' distinguishes it from share_list_point_transfer_records (all records) and share_handle_point_transfer (acting on one), though it never names those siblings.

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

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

Usage is only implied by the scope phrase 'waiting for me to accept' – an agent can infer this is the inbox-style list before accepting. There is no explicit when-to-use, no exclusion, and no pointer to share_handle_point_transfer as the natural next step.

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

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

Annotations already declare readOnly=true, idempotent=true, destructive=false, so the safety profile is covered. The description adds that results are paginated, which is real behavioral context, but leaves the default direction=null behavior (both sent and received? neither?) and result ordering undisclosed.

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

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

A single compact sentence with the core action front-loaded and no filler. Every clause earns its place.

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

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

An output schema exists and annotations cover safety, so return values and side effects need not be described. Still, for a tool whose two filter parameters have no schema prose, the description should resolve what omitting direction/status does and how it relates to the pending-transfers sibling.

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 50% – page and page_size are documented in the schema, while status and direction carry only inline enums without prose. The description names direction=sent/received and the status filter, giving partial meaning to the undocumented parameters, but adds no syntax, defaults, or combination semantics.

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

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

States a specific verb and resource ('分页读取转账记录' – paginated read of transfer records) and names the two filter dimensions. It does not explicitly distinguish itself from the sibling share_list_pending_point_transfers, which overlaps via the status=pending filter, so an agent must infer the difference.

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

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

Usage is only implied: the pagination and filter phrasing suggests 'browse transfer history'. There is no explicit when-to-use, no when-not, and no routing to the clearly overlapping sibling share_list_pending_point_transfers or to share_list_my_point_logs.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint, so the safety profile is covered. The description adds nothing beyond that — no pagination, no whether results are scoped to the authenticated user, no indication of how records are ordered or how many are returned, despite openWorldHint implying external data.

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

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

A single short sentence with zero filler, and the scoping qualifier ('来源站点') is front-loaded before the resource. It is efficient, though the brevity is partly a symptom of under-specification rather than disciplined editing.

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

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

One required parameter, a rich annotation set, and an output schema mean the description needn't explain return values, so the baseline is met. Still missing is the one thing only the description can supply: what the three source values mean and whether the list is user-scoped or site-wide.

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

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

Schema coverage is 0%, so the description is the only place the single parameter's meaning is glossed, and it does add that the value denotes a '来源站点' (source site). It stops short of explaining what each enum value (shuiyuan, sjtuplus, sjtuwiki) refers to or whether multiple sources can be combined, leaving the required parameter only partially characterized.

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 ('列出' / list) and resource ('积分兑换记录' / point redemption records) scoped to a source site, which distinguishes it from personal-log siblings like share_list_my_point_logs. It does not, however, name or contrast with the nearby share_list_point_transfer_records or share_get_redeem_quota, so an agent must infer the boundary 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 instead of share_list_point_transfer_records, share_get_redeem_quota, or share_list_my_point_logs, all of which sit in the same redemption/points cluster. The sentence asserts what the tool does but offers no conditions, prerequisites, or exclusions.

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

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

Annotations already declare readOnlyHint=false, openWorldHint=true, destructiveHint=false. The description adds genuinely new context — credentials are persisted only to local private config — which is useful for a login tool, but it omits session establishment behavior, idempotency, and failure modes.

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

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

A single compact sentence with the input modes front-loaded and the credential-storage note trailing. No wasted 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?

An output schema exists so return values need not be explained, and the annotations cover the safety/open-world profile. The remaining gap is flow positioning (post-share_login_start) and which parameter combination is valid, given zero required parameters.

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

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

Schema coverage is 0% (bare titles 'Code', 'State', 'Callback Url'), so the description must compensate; it does partially by revealing that callback_url and code+state are alternative input paths. However it says nothing about the role of state, URL parsing expectations, or what happens when all three are 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 states a specific verb+resource: 「完成登录」(complete a login) and names the two accepted input modes (完整回调 URL or code+state). It implicitly complements share_login_start without naming it, so an agent can infer the pairing but gets no explicit differentiation.

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

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

The two input modes imply this is the second step of a login flow started elsewhere, but there is no explicit statement of when to call it versus share_login_start, no prerequisites, and no guidance on which mode to choose or whether it can be re-invoked.

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?

Beyond the annotations (readOnlyHint=false, openWorldHint=true, destructiveHint=false), the description adds genuinely useful context: this tool does not itself authenticate, and a human browser step plus a callback URL is required before share_login_complete can be used. It stops short of describing URL lifetime, whether state is stored, or what happens on failure.

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

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

A single compact sentence front-loads the action and then gives the follow-up in the second clause; nothing is redundant.

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

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

With an output schema present, return values need not be explained, and the human-in-the-loop handoff to share_login_complete is covered. The remaining gap is the undefined redirect_uri, the one input the caller must reason about.

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 never mentions redirect_uri at all, so the single optional parameter is undocumented everywhere. An agent cannot tell whether redirect_uri is its own callback target, must match a registered value, or can be omitted safely.

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

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

The description uses a specific verb + resource ("生成 jAccount 登录 URL") and explicitly names share_login_complete as the continuation, so the agent can distinguish this initiation step from the completion step. It does not differentiate itself from other URL-generating siblings such as share_lesson_sync_login_url, which keeps it from a 5.

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

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

The description lays out the operational sequence: generate the URL, the user logs in through a browser, then the callback URL is copied and handed to share_login_complete. This makes the usage context clear, though it states no explicit exclusions or preconditions (e.g. already being logged in).

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

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

Annotations already declare destructiveHint=true and readOnlyHint=false, so the deletion semantics are known. The description adds real value beyond that by scoping exactly what gets destroyed (the local token only) and warning that env-var tokens survive and must be cleared in host configuration. It does not say whether any server-side session is revoked, which is the one remaining 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?

Two short clauses, front-loaded with the primary action, with the caveat second. Nothing is wasted and nothing important is buried.

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

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

With zero parameters, an output schema, and annotations covering safety, the definition needs only to explain scope — which it does. The only missing element is whether the remote session is invalidated, which matters for a logout tool but is partially implied by 'local token'.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; baseline 4 applies. The description correctly implies no input is needed.

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

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

States a specific verb+resource: delete the locally stored token. It also disambiguates the tricky case of environment-variable-supplied tokens, which cannot be cleared by this tool. It does not name a sibling (e.g. share_auth_status or share_login_start) as the alternative, but the operation is unambiguous.

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

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

Gives clear when-to-use context: call it to clear a persisted local token, and the second clause tells the agent this call is the wrong tool for env-var-based credentials, which must be removed in host config. That is effectively a when-not condition, though no named alternative tool is offered.

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

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

Annotations declare this is a write (readOnlyHint=false, destructiveHint=false). The description adds valuable behavior beyond the schema: a 1000-character limit and the confirm=true execution gate (a two-step authorization pattern). The confirm semantics are partly duplicated in the schema, capping it below 5.

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

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

Two compact, front-loaded clauses with no filler; the post/reply distinction and the confirm gate are stated efficiently. Slightly dense but every element earns its place.

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

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

An output schema exists, so return values need not be described. With annotations covering the safety profile, the description completes the picture by explaining reply threading, the length cap, and the confirmation requirement — enough 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 50%, so description must compensate. It does: 'parent_id 指向被回复评论' explains the otherwise-undocumented parent_id, and '最多 1000 字' plus 'confirm=true 执行' clarify content limit and the confirm gate. This adds real meaning beyond the bare schema.

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

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

States a specific verb+resource: 发表资料评论或回复 (post material comment or reply). It also clarifies the comment-vs-reply distinction via parent_id. It doesn't explicitly differentiate itself from siblings like share_list_comments or share_delete_comment, but the creation intent is unambiguous.

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

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

Usage is implied: set parent_id to reply to an existing comment, leave it null for a top-level comment, and set confirm=true to execute. There is no explicit when-to-use vs alternatives guidance or stated prerequisites beyond the confirm gate.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=true, so the mutation profile is known. The description adds real value by warning that points may be deducted ("可能扣除积分"), but it does not say whether deductions are reversible, what happens if confirmation is withheld or the balance is insufficient, or how the cost is determined.

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

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

Three compact clauses with the action front-loaded and the cost warning plus confirmation gate following immediately; nothing is redundant. The telegraphic semicolon style is slightly terse but wastes no words.

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

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

With annotations covering the destructive profile, an output schema present, and full parameter coverage, the description supplies the remaining essentials: purpose, point cost, and the read-then-confirm flow. Only failure/refund semantics are missing, which is a minor gap for this complexity level.

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

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

Schema description coverage is 100%, so both confirm and material_id are fully documented in the schema. The description's mention of "confirm=true" merely restates the schema's confirm parameter without adding format or edge-case meaning, so the baseline 3 applies.

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

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

The description names a specific action on a specific resource ("兑换资料" = redeem/purchase a material), which is unambiguous on its own. It does not, however, distinguish itself from nearby siblings such as share_redeem_points, share_download_material, or share_get_material, so the agent gets no explicit routing help.

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

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

"请先读取详情确认价格" gives a concrete prerequisite workflow (read the material detail first to check price) and "confirm=true 执行" states the execution gate. It lacks explicit when-not conditions or named alternatives, but the sequencing guidance is clear.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=false and openWorldHint=true, so the safety profile is covered. The description adds one genuinely useful behavior: setting liked=false removes an existing rating. It says nothing about idempotency, whether re-rating overwrites, or any 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?

Two short clauses, zero filler, with the core action front-loaded. It is efficient, though the extreme terseness leaves the schema to carry details that a slightly fuller sentence could have disambiguated.

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?

Output schema and annotations relieve the description of return-value and safety explanation, so the bar is lower. Still, the rating/liked interaction is left unexplained and there is no cue about what a successful rating change does or how to switch from like to hate.

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 only 33%, but the two gaps are partly self-documenting (rating is an enum like/hate; comment_id has a schema description). The description does explain the undocumented `liked` flag's cancel semantics, which is real added value. However, the interaction between `rating` and `liked` remains ambiguous — e.g. what liked=false means when rating='hate' — and is left unresolved.

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

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

States a specific verb and resource: like/dislike a comment, which distinguishes it from share_rate_material (materials) and share_report_comment (reporting). The `liked=false` undo clause is included, but the description never explicitly names its siblings or clarifies how this differs from report/delete on the same resource.

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 rather than share_rate_material, share_report_comment, or share_delete_comment. The only usage-like hint is the embedded 'liked=false cancels' note, which is really parameter behavior, not selection guidance.

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

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

Annotations already declare this as a non-read-only, non-destructive, open-world mutation. The description adds genuinely useful behavior beyond that: it discloses the tri-state semantics where liked=false retracts a prior rating, which an agent could not infer from the schema alone. It does not mention idempotency or auth requirements, so it stops short of a 5.

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

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

A single compact sentence that front-loads the action and then the parameter semantics. Nothing extraneous and nothing buried.

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

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

For a simple 3-parameter mutation with an output schema and annotations covering safety, the description supplies the key behavioral detail (cancellation) and the enum meaning. Only the relationship to sibling tools and any auth prerequisites are left implicit.

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 only 33%, with material_id the sole documented parameter, so the description carries real weight. It explains both the rating enum values (like/hate) and the otherwise-undocumented liked flag as a cancellation switch, compensating well for the coverage gap, though it omits the default-true behavior of liked.

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

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

The description states a specific verb plus resource ('点赞/点踩资料' – like/dislike a material), which clearly separates it from siblings like share_rate_comment or share_report_material. It does not explicitly name an alternative, but the action and target are unambiguous.

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

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

Usage is implied: call this to like or dislike a material, and set liked=false to withdraw the rating. However, the description never says when to prefer this over related siblings (share_report_material for abuse, share_purchase_material, etc.) or what prerequisites exist.

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

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

Annotations already flag destructive=true and openWorld=true; the description adds real value by disclosing the two-step confirm gate ('confirm=true 执行') and that credited amounts are uncertain ('到账以平台为准'). It doesn't state reversibility or failure handling, but the confirm mechanism is the key behavioral fact.

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

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

Two compact clauses with no filler; the exchange semantics and the confirm requirement are both front-loaded. Slightly dense punctuation-separated clauses rather than full sentences, but nothing 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 destructive, open-world mutation with an output schema available, the description covers the essential facts an agent needs: it spends external points, the credited amount is platform-determined, and confirmation is required. The unexplained source enum is the only notable gap.

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

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

Schema coverage is 33% – only confirm is documented in the schema. The description compensates for amount by defining it as the source-points quantity and clarifies that confirm=true triggers execution, but the source enum values (shuiyuan/sjtuplus/sjtuwiki) and their meaning are never explained in prose.

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

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

States a specific verb and resource: consuming partner-site points to exchange for platform (inheritance) points. An agent can distinguish it from read-only siblings like share_get_redeem_quota or share_list_redeem_records, though it doesn't name 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?

Usage is implied by '消耗…换…' (consume to exchange) and the confirm=true gate, but the description never says when to prefer this over the quota/records siblings or what preconditions (e.g., sufficient balance, quota check first) apply.

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

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

Annotations already declare destructiveHint=true and openWorldHint=true, so the safety profile is covered. The description adds the non-obvious gating behavior that nothing happens unless confirm=true, which is exactly the kind of extra context that matters for a destructive call. It stops short of saying what a report actually does (removal vs. moderation queue) or whether it is reversible.

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

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

Three short clauses, zero filler, with the action front-loaded and the execution gate last. It is telegraphic rather than explanatory, but every clause carries information the agent needs.

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

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

An output schema exists so return values need not be described, and annotations cover safety, leaving the description to explain invocation — which it mostly does. The remaining gap is consequence: for a destructive report action, an agent still cannot tell what happens to the comment after a successful call, and one of four parameters has no documentation anywhere.

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

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

With only 50% schema coverage, the description compensates for the biggest gap: the `reason` parameter is undocumented in the schema, and the description explains that it must be a code returned by the report-reasons endpoint. `confirm` and `comment_id` are already covered by the schema, but the `description` parameter remains undocumented in both places.

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

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

States a specific verb and resource ("举报评论" / report a comment), which is immediately distinguishable from siblings like share_report_material or share_delete_comment. It does not name the sibling, but the reference to "举报原因接口" implicitly points to share_get_comment_report_reasons.

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 implies a two-step workflow — get a valid code from the report-reasons endpoint, then pass confirm=true to actually execute — which is real usage guidance. However, it never explains when to report versus delete/rate/block a comment, and the prerequisite is left implicit rather than stated as a call ordering.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and openWorldHint=true. The description adds the important execution gate, 'confirm=true 执行', implying default confirm=false does not execute, but it does not describe the actual consequence of reporting or what confirm=false does beyond implication.

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

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

The description is two short clauses, front-loads the action, and contains no filler. Every phrase carries operational meaning.

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

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

It covers the core action, the reason-code prerequisite, and confirm gating, and an output schema exists for return values. However, for a destructive action it does not explain side effects, whether confirm=false is a dry run, or the purpose of the description parameter.

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 50%, with confirm and material_id documented in the schema. The description adds essential meaning for the required reason parameter by tying it to codes returned by the report reasons interface, but it leaves the description parameter unexplained and does not clarify the reason code 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?

The description names a specific verb and resource, '举报资料' (report material), which clearly separates it from the sibling share_report_comment. It does not explicitly mention sibling alternatives, but the resource distinction is unambiguous.

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

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

It gives concrete procedural context: fetch the reason code from the material report reasons interface, and set confirm=true to execute. This is clear guidance on prerequisites and execution gating, though it does not state explicit when-not-to-use conditions.

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

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

Annotations already declare readOnlyHint, idempotentHint and openWorldHint, so the safety and repeatability profile is covered. The description adds a list of returned fields, but that information duplicates the output schema and does not disclose anything behavioral beyond the annotations.

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

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

The description is a single efficient sentence with the core operation front-loaded. The trailing enumeration of return fields is somewhat redundant given the output schema, but the overall length is appropriate.

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

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

For a two-parameter read-only search tool with full annotations and an output schema, this is close to usable, but the absence of any hint about the 'limit' parameter and the lack of sibling differentiation leave clear gaps.

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

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

Schema description coverage is 0%, so the description must carry the parameter semantics, but it only implies that 'keyword' is a course keyword and never mentions the 'limit' parameter, its default of 20, or its maximum of 50. It leaves half the parameters undocumented in either place.

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 (search) and resource (courses) scoped to a keyword lookup, making the core operation unambiguous. It does not, however, contrast itself with close siblings like share_suggest_courses or share_get_course, so an agent gets no help distinguishing between them.

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

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

There is no explicit when-to-use or when-not-to-use guidance, and no mention of the alternative share_suggest_courses. Usage is only implied by the word 'search', leaving the agent to infer when this tool is preferable.

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

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

Annotations already declare readOnlyHint=true, openWorldHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds useful behavioral context by explaining the two-stage course-first/material-ranking approach and the lack of a site-wide material search API. It does not discuss rate limits or authentication, but with annotations this is a meaningful addition.

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

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

The description is short, dense, and front-loads the core cross-course retrieval concept. It avoids filler, though the second clause combines a limitation statement and a parameter hint in a way that is slightly telegraphic.

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?

An output schema exists and annotations cover the safety profile, so the description does not need to explain return values or read-only behavior. It still leaves three of four parameter meanings undocumented and gives only a high-level workflow, making it adequate but not complete for a search tool with 0% schema description coverage.

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 four parameters. It only explains course_keyword, and even that is brief; query, max_results, and course_limit are left to their names and schema defaults. This leaves important search-scope semantics undocumented in 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 cross-course search workflow: search courses first, then rank relevant course materials. It also clarifies that there is no site-wide material search API, which helps distinguish it from a generic material search. It does not explicitly name sibling alternatives, and the exact return shape is left to the output schema.

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

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

Usage is implied by the cross-course material-search workflow, and the description gives one concrete condition: use course_keyword for mixed keywords to specify a course name. However, it does not explicitly say when to use this tool versus siblings like share_search_courses or share_get_course_materials, nor does it give 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?

The annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered elsewhere. The description adds nothing behavioral beyond annotations: no mention of how many candidates come back, whether there is rate limiting or auth, or what the response 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?

A single short sentence with the resource front-loaded and no filler. It is efficient, though it borders on under-specification rather than compactness.

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?

An output schema exists, so return values needn't be explained, and the sibling list makes the search alternative discoverable. Still, at 0% schema coverage, the description doesn't mention the `limit` parameter at all, so it isn't fully complete for a two-parameter tool.

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

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

Schema description coverage is 0%, so neither parameter is documented in the schema. The description only implicitly maps to `keyword` (关键词) and only hints at the existence of a result cap (候选); the `limit` parameter, its default of 10, and its 1-20 range are never mentioned.

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

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

The description states a specific function (课程关键词自动补全, course keyword autocomplete) on a specific resource (course names), which is clearly distinguishable from the sibling share_search_courses full-search tool. It never names that sibling, however, so an agent must infer the boundary 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?

"适合名称不完整时获取候选" gives one usage condition: use it when the course name is incomplete. It doesn't say when to prefer share_search_courses or share_get_course instead, nor does it exclude any case, so the guidance is implied rather than explicit.

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

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

Annotations already flag destructiveHint=true and openWorldHint=true, so the safety burden is partly carried. The description adds meaningful context beyond that: it is a scoped partial update that leaves unspecified fields untouched, it only applies to the caller's own uploads, and it requires confirm=true before executing. It still doesn't say what happens on confirm=false (dry run vs error) or how failures behave.

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

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

Two compact clauses plus a short execution note, with no redundancy. The mutable-field list comes first and the confirm requirement last, so the most important scoping information is front-loaded.

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

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

For a destructive partial-update tool with an output schema present, the description covers the essential facts: scope, editable fields, preservation of unspecified fields, and the confirm gate. It omits edge behavior such as ownership violations or confirm=false semantics, which keeps it from a 5.

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 only 29%, so the description must compensate, and it does: it maps name, description, material_type_id, points and anonymous to concrete editable fields, and repeats the confirm gate. material_id is undocumented in the description but the schema describes it as a positive integer ID, so no important parameter is left obscure.

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 (修改/modify) and resource (自己上传的资料, i.e. materials the caller uploaded) and enumerates the editable fields (name, description, type, price, anonymous status). This is much clearer than siblings like share_upload_material or share_delete_material, but it never names or routes to those siblings, so it stops short of a 5.

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

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

The ownership constraint ('自己上传资料') and the confirm gate imply when the tool applies, and '未指定字段保持原值' tells the agent partial updates are allowed. However there is no explicit when-to-use versus alternatives (e.g., delete_material for removal, upload_material for creation) and no when-not guidance.

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

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

Annotations already declare readOnlyHint=false and destructiveHint=false, so the write safety profile is covered. The description adds concrete behavioral constraints absent from structured fields: the 16-character nickname limit, the 5 MB local-image limit, and that 'restore default avatar' is an available state change. It still omits permission/error behavior.

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

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

A single, tightly written sentence that front-loads the operations and embeds the key constraints inline. Every clause earns its place with no redundancy.

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

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

Given an output schema exists (return values needn't be described), the description adequately covers the three nullable/default parameters and their limits. The remaining gap is the lack of explicit routing to share_get_profile for reading, which would make it complete.

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

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

With 0% schema description coverage, the description must carry parameter meaning and largely does: nickname maps to the 16-char limit, avatar upload maps to avatar_path with the 5 MB/local-file constraint, and 'restore default avatar' maps to delete_avatar. It adds real meaning beyond bare parameter names, though the exact semantics of delete_avatar vs avatar_path interplay aren't spelled out.

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

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

The description states a specific verb and resource (update profile) plus the exact operations: change nickname (max 16 chars), upload avatar (local image, max 5 MB), or restore the default avatar. It is unambiguous about what the tool does, though it does not explicitly name share_get_profile as the read counterpart it should not be confused with.

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

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

The three operations imply when the tool is appropriate (nickname edit, avatar upload, avatar reset), but there is no explicit guidance on prerequisites, when not to use it, or that reading the current profile is share_get_profile's job. Usage is inferable rather than stated.

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

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

Annotations already declare a non-read-only, open-world, destructive operation. The description adds useful behavioral context beyond that: the internal ticket/upload/metadata workflow, the 100 MB size cap, default anonymous and free behavior, and the confirm=true execution requirement.

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

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

The description is compact and front-loaded, packing the workflow, limits, defaults, and execution gate into a few dense clauses without wasted 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?

For a 9-parameter mutation with 5 required parameters and low schema description coverage, the description covers the high-level flow and safety gate but omits important context about how to choose the required course, class, and material type IDs. Output schema exists, so return values need not be explained.

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 only 44%, so the description must compensate. It does clarify file upload, points range, anonymous/free defaults, and confirm execution, but it leaves required parameters such as name, course_id, class_id, and material_type_id largely unexplained.

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

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

The description states a specific verb and resource: uploading a local file and creating a material, with the internal steps (ticket, object storage, metadata). It is clearly distinguishable from siblings like update_material or download_material, though it does not explicitly name alternatives.

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

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

Usage is implied by the upload/create framing and the confirm=true execution gate, but there is no explicit guidance on when to use this instead of related tools such as update_material, or on prerequisites like obtaining course/class/material_type IDs.

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