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

Annotations already declare destructiveHint=true, non-idempotent, and openWorld, so the safety profile is partially covered. The description usefully adds a beta instability warning and the auto-sync prerequisite, but it never explains what the 'destructive' aspect actually means or how this affects existing study data/records.

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

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

Very short and front-loaded: purpose first, then the beta caveat. Minimal waste, though the HTML-wrapped beta notice is slightly heavier than necessary for a title-less 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 no output schema, a fully described input schema, and annotations carrying the safety hints, the description covers the basics plus the beta warning. It stops short of explaining the effect on the user's study list/progress, which matters for a mutation tool flagged destructive.

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 the nested words array (max 1000, ID sourced via the query API) and advance/confirm are fully documented in the schema. The description adds nothing about parameters, 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 states a specific verb+resource ('添加单词' / add words), which an agent can map to a write operation on vocabulary. However, it does not distinguish this from sibling tools like maimemo_list_vocabulary, maimemo_get_vocabulary, or maimemo_advance_study, leaving the agent to infer the boundary.

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 only contextual constraint given is a prerequisite ('需要在 App 中开启自动同步'), not when-to-use or when-not-to-use guidance. No alternatives are named, and there is no statement about when adding words is appropriate versus other vocabulary 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 flag destructiveHint=true, idempotentHint=false, and openWorldHint=true, and the description adds context beyond them: the feature is in beta, availability is not guaranteed, behavior may change, and two concrete preconditions (level 10, App auto-sync). It still does not spell out the scheduling consequences of advancing words or what a failure looks like, so not 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?

Three short lines, front-loaded with the operation name and effect, followed by prerequisites and caveats. The embedded <b> HTML tags and parenthetical '(公测)' add minor noise but 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?

For a destructive, non-idempotent beta mutation with a nested body object and no output schema, the description covers the effect, the unlock prerequisite, sync requirement, and instability warning. What remains thin is the voc_ids input and what a successful advance does to the study schedule long-term.

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 reported at 100% and 'confirm' carries its own description ('用户已明确授权本次写入。须为 true。'). The description adds nothing about voc_ids (max 1000, empty sub-description) or the confirm gate, so the baseline 3 for schema-documented parameters 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: moving words forward for immediate review ('将单词提前到当下马上复习'), which is clearly actionable and distinct from bulk-import siblings like maimemo_add_words or read-only ones like maimemo_get_today_items. It does not explicitly name a sibling to contrast with, 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?

Gives real prerequisites (must be level 10 to unlock, auto-sync must be enabled in the App), which is meaningful when-to-use context. However, it never states when to prefer this over alternatives such as maimemo_get_today_items or maimemo_add_words, and no exclusions are given, so guidance is only partial.

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 cover readOnlyHint and openWorldHint=false, so the safety profile is set. The description adds genuinely useful behavioral context beyond them: the token is never displayed and remote validity is not verified, which prevents misinterpretation of the 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?

A single compact sentence leads with the core action and appends two scoping caveats. Nothing is redundant and every clause carries information.

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

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

With no output schema and zero parameters, the description supplies the essential scope of the check. It could briefly indicate what the result conveys (configured vs not), but for a trivial connectivity check it is nearly 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?

Parameter count is 0, so there is nothing to document and the baseline of 4 applies. Schema coverage is trivially 100% and no enum or nested objects exist to explain.

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: it checks whether the local token is configured. It also scopes the check by denying two things (no token display, no remote validation), which cleanly separates it from the data-operation siblings. It falls short of 5 only because no sibling alternative is named, though none is really needed here.

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

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

Usage is implied rather than stated: an agent can infer this belongs in a diagnostic/prerequisite step before making authenticated calls. There is no explicit 'use this when...' or mention of alternatives, but the negative scoping ('does not validate remote') gives some decision context.

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

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

Annotations already disclose destructiveHint=true, idempotentHint=false, and openWorldHint=true, but the description adds no behavioral context of its own — nothing about write authorization, side effects on existing interpretations, or what the confirm flag implies behaviorally. It does not contradict the annotations, but it contributes nothing beyond them.

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 characters is technically brief, but this is under-specification rather than conciseness — there is no front-loaded structure or useful information to be concise about. A single label is not a structured description.

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

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

For a mutating tool with a required confirm authorization flag and nested object parameters, the description omits the write-authorization requirement, the meaning of the required nested interpretation payload, and any return-value expectation (no output schema exists). Rich schema coverage partially compensates, but the description itself is inadequate.

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

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

Schema description coverage is 100%, with the nested interpretation object, voc_id, status enum, and the required confirm flag all documented in the schema itself. Per the baseline rule, a 3 is appropriate since the description adds no parameter meaning of its own but the schema carries the load.

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

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

The description is '创建释义' — essentially a Chinese restatement of the tool name maimemo_create_interpretation, with no additional specificity. It conveys a verb+resource but adds nothing an agent couldn't infer from the name, and offers no differentiation from siblings like maimemo_update_interpretation or maimemo_delete_interpretation.

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

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

There is no guidance whatsoever on when to use this tool versus maimemo_update_interpretation, maimemo_add_words, or other creation siblings. No prerequisites, no context, no exclusions are stated.

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

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

Annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true, so the safety profile is covered structurally. The description adds nothing on top: it does not mention that writes require the confirm=true authorization flag, does not explain the destructive impact, and does not note any idempotency 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?

It is a single short line with no waste, but its brevity stems from under-specification rather than disciplined conciseness. There is nothing front-loaded because there is almost nothing at all.

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

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

For a destructive mutation tool with nested objects and no output schema, the description is far too thin. It omits the confirm-gate requirement, the nested body.note structure, and the vocabulary-linking semantics, leaving the agent reliant entirely on structured fields.

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

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

Schema description coverage is 100% and all fields (voc_id, note_type, note, confirm) are documented in the schema, so baseline is 3. The description adds no meaning beyond the schema, which is acceptable here but not value-adding.

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

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

The description '创建助记' states a verb plus resource and is distinguishable from siblings like maimemo_create_interpretation or maimemo_create_notepad by the resource '助记'. However, it is bare-bones and gives no scope detail (e.g. that it attaches a mnemonic to a vocabulary id) beyond the name itself.

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

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

There is no guidance on when to use this tool versus maimemo_update_note or the create_* interpretation/phrase siblings. The only implicit usage signal is the verb 'create', with no prerequisites or exclusions stated.

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

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

The annotations already declare readOnlyHint=false, destructiveHint=true, openWorldHint=true and idempotentHint=false, so the safety profile is covered structurally. The description adds nothing beyond that: it never mentions the mandatory user-authorization gate (confirm must be true), that retries are not idempotent, or what the write does. With annotations carrying the burden, the description earns only minimal credit for adding no new context.

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

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

The single line is not wasteful, but this is under-specification rather than conciseness. For a tool with a nested object payload and a write-authorization parameter, one sentence is far too thin to be considered appropriately sized.

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

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

The tool has a nested object schema, two required parameters, a destructive write annotation and no output schema. The critical behavioral fact that the agent must have explicit user authorization before setting confirm=true is nowhere in the description; it appears only inside the schema's field description, making the definition incomplete for a destructive operation.

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

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

Schema description coverage is 100%, so the baseline is 3: title, brief, content, tags and the status enum are all documented in the schema itself. The description contributes no additional meaning about the nested body structure or the confirm flag, but it does not need to.

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 (创建云词本 / create cloud notepad), which is unambiguous on its own and lets an agent distinguish it from maimemo_update_notepad, delete_notepad, get_notepad and list_notepads. It does not explicitly name any sibling or clarify scope, which is what separates a 4 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?

There is no when-to-use guidance, no statement of prerequisites, and no mention of how this differs from maimemo_update_notepad or maimemo_create_note. The agent must infer entirely from the name that this is for brand-new notepads.

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, openWorldHint=true, and idempotentHint=false, so safety behavior is partly covered. The description adds no behavioral context such as required confirmation, side effects, overwrite behavior, or error conditions. It does not contradict the annotations, but it also contributes nothing beyond them.

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

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

The description is extremely short and front-loads the core action, but it is under-specified rather than genuinely concise. For a destructive tool with nested required parameters and a confirmation flag, a four-character description does not earn its place as sufficient documentation.

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

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

Given the tool's complexity, nested required body object, required confirm flag, destructive annotation, and many CRUD siblings, the description is incomplete. The schema and annotations carry much of the burden, but the description does not explain when to use this tool, what it writes, or how confirm interacts with the call.

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

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

Schema description coverage is 100%, and the schema documents the nested phrase fields and the required confirm flag. The description adds no additional parameter meaning, syntax, or constraints. With high schema coverage, a baseline score 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: create an example sentence. It clearly distinguishes the operation from sibling actions like list, update, and delete. However, it does not explicitly differentiate itself from those siblings or explain scope beyond the basic purpose.

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

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

The description gives no when-to-use guidance, no alternatives, and no prerequisites. An agent must infer usage from the tool name and sibling naming conventions alone. This is minimal, non-misleading but insufficient for a destructive write operation.

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, idempotentHint=false, and readOnlyHint=false, so the agent knows this is a destructive mutation. The description adds nothing beyond that – no warning about permanence, no note about the confirm requirement's authorization implications, no error behavior. With annotations carrying the safety profile, the description contributes no additional behavioral context.

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

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

The description is two words with no waste, but this is under-specification rather than conciseness – it lacks the substance a destructive tool needs. Brevity here is a deficit, not a virtue.

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

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

For a destructive delete tool with no output schema, the description should at minimum state what gets deleted and any irreversibility. Annotations cover the safety hints, but the description leaves the operation's scope and consequences entirely unstated.

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

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

Schema description coverage is 100%, so both parameters (id, confirm) are fully documented in the schema including the const:true authorization requirement. The description adds no parameter meaning, but the schema does the heavy lifting, making baseline 3 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 '删除释义' is essentially the tool name (delete interpretation) restated in Chinese, with no scope, target, or elaboration. An agent knows the verb and resource only because the name already says it. This is tautological rather than genuinely clarifying.

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

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

There is no when-to-use, when-not-to-use, or alternative mentioned. Siblings such as maimemo_update_interpretation and maimemo_delete_phrase exist, but nothing routes the agent between them. Nothing in the description helps decide when this tool applies.

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, idempotentHint=false, and readOnlyHint=false. The description adds no behavioral context such as permanence, confirmation requirements, side effects, or authorization needs beyond repeating the delete action.

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

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

The single short phrase is front-loaded and has no wasted words. However, it is extremely bare for a destructive operation, so conciseness is achieved at the cost of useful 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?

For a destructive write tool with no output schema, the description omits what exactly is deleted, what happens to related data, and why confirm is required. Annotations cover safety hints, but the description remains insufficiently complete for confident 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 100%, with both id and confirm documented directly in the schema, so the baseline is 3. The description adds no parameter meaning 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?

States a specific verb (删除) and resource (助记), distinguishing it from create/update/list siblings by action. However, it does not explicitly differentiate it from the other delete tools or clarify whether 助记 maps exactly to the note 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?

Provides no guidance on when to use deletion instead of alternatives such as update or list, and no prerequisites or cautions beyond what the annotations already imply. The agent receives no routing context from the description itself.

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

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

Annotations already declare destructiveHint=true, readOnlyHint=false, and idempotentHint=false, so the safety profile is fully covered by structured data. The description adds no further behavioral context such as permanence of deletion, absence of undo, or auth requirements, effectively only restating the purpose.

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

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

It is a single short phrase with no wasted words and the purpose is front-loaded, so it is maximally compact. However, the brevity verges on under-specification for a destructive operation rather than being a model of efficient 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?

The rich annotations (destructive, non-idempotent) plus a complete schema with a mandatory confirm flag cover most of what an agent needs before invoking. The description contributes nothing about irreversibility, scope of deletion, or recovery, leaving it minimally adequate rather than complete.

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

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

Schema description coverage is 100%; both 'id' (云词本 id) and the required 'confirm' flag are documented in the schema, including the authorization semantics of confirm. Per the baseline rule for high coverage, the description adds nothing beyond the schema and a 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 '删除云词本' (delete cloud notepad) gives a clear verb+resource pair that an agent can map directly to the tool's intent. It is unambiguous on its own but does not differentiate itself from related siblings such as maimemo_delete_phrase or maimemo_delete_note beyond naming the 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 when-to-use guidance, no mention of prerequisites, and no routing to alternatives (e.g., get_notepad to verify before deleting). A single phrase of purpose text leaves usage entirely to inference.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and readOnlyHint=false, so the safety profile is covered structurally. The description adds nothing beyond that—no note that deletion is permanent, no mention that the confirm flag is a required authorization, no side-effect context.

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

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

The description is a single terse fragment with no wasted words, which is structurally clean. However, its brevity reflects under-specification rather than disciplined conciseness, since no useful context is conveyed.

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

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

For an irreversible destructive delete tool with no output schema, the description omits any statement of irreversibility or authorization semantics. Although the parameters are fully documented in the schema and safety flags live in annotations, the description should at minimum signal that this permanently removes a phrase.

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%: 'id' is documented as the phrase id and 'confirm' is documented as the required write authorization. The description contributes no additional parameter meaning, so the baseline of 3 applies since 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 '删除例句' states a clear verb (删除) and resource (例句), but it essentially translates the tool name rather than adding distinct meaning. It does not differentiate this tool from sibling delete operations (delete_interpretation, delete_note, delete_notepad), so an agent gains little beyond the name itself.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no note about irreversibility. The agent must infer usage entirely from the tool name and the destructive annotation.

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, covering the safety profile. The description adds no further behavioral context such as what is returned, error behavior for a missing id, or remote-fetch semantics implied by openWorldHint.

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 terse fragment with no waste, but this is under-specification rather than conciseness. There is no structure to front-load because there is no substantive content.

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

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

For a read tool with no output schema, the description should at least indicate what a notepad record contains or what happens for an invalid id. Annotations cover the safety profile, but the description leaves the agent with only the parameter name to reason from.

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 a single 'id' parameter documented as the cloud notepad id. The description adds nothing beyond the schema, 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 '获取云词本' is essentially the tool name (maimemo_get_notepad) restated in Chinese, so it is a tautology rather than an independent statement of purpose. It gives no indication of how it differs from siblings like maimemo_list_notepads or maimemo_get_vocabulary.

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

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

There is no when-to-use guidance, no mention of prerequisites, and no reference to the alternative maimemo_list_notepads for enumerating notepads. Nothing misleading, but nothing helpful either.

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/openWorld, so the safety profile is covered. The description adds genuinely new behavioral context: it is a public beta with no availability guarantee subject to change, and accurate totals require same-day App initialization plus enabled auto-sync. These are real operational caveats beyond the structured fields.

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?

Purpose is front-loaded and the text is short, but it carries HTML markup (<b> tags) and stray escape artifacts ('\ \') that add noise without meaning. A cleaner plain sentence would serve the agent better.

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

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

For a no-parameter read tool with no output schema, the description covers the accuracy caveat, the beta stability warning, and the sync prerequisite — enough for an agent to call it and interpret results sensibly. Only the exact return shape is unspecified, which is a minor gap here.

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 no parameter semantics to explain; baseline 4 applies. The description correctly spends no words on 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?

States a specific verb and resource ('获取今日学习进度' / get today's study progress), which an agent can distinguish from siblings like get_today_items or query_study_records. No explicit sibling differentiation or scope statement, but the purpose 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?

Provides precondition context ('当日未打开 App 进行初始化则无法准确计算总数', requires auto-sync enabled) which tells the agent when results are reliable. However, it never states when to use this tool versus alternatives such as get_today_items or query_study_records, leaving selection to inference.

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

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

Annotations already declare read-only, idempotent, open-world, non-destructive behavior, so the safety bar is lower. The description adds genuine extra context beyond that: the daily App-initialization dependency, beta-phase instability, and the auto-sync requirement. It stops short of describing return format, which keeps it from 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?

The core purpose is front-loaded, which is good, but the escaped newlines and bold-HTML beta disclaimer consume space with formatting noise rather than added substance. It is adequate but not tight.

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

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

For a read-only listing tool with full schema coverage and rich annotations, the description supplies the missing operational context (App initialization dependency, beta caveats, sync requirement). With no output schema, some return-shape information is absent, but the essentials for correct invocation are present.

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

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

Schema description coverage is 100%, so limit, is_new, voc_ids, spellings, and is_finished are already fully documented in the schema, including the mutual exclusivity of voc_ids and spellings. The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb and resource ('获取今日学习单词' – get today's study words) with scope ('今日'), so an agent immediately knows what is retrieved. However it does not distinguish itself from siblings like maimemo_query_study_records or maimemo_get_study_progress, leaving overlap ambiguity.

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 practical prerequisites: cannot retrieve if the App was not opened/initialized that day, and auto-sync must be enabled in the App. This is useful usage context, but it never names or contrasts an alternative sibling tool, so the agent must infer when to pick this over query_study_records.

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, so the safety profile is covered. The description adds no behavioral context of its own — nothing about lookup failure behavior (e.g., what happens when the word does not exist) or any auth/rate constraints.

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

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

The phrase is short but that brevity reflects under-specification rather than economy — it is too thin to be useful and contains no front-loaded scoping or purpose 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?

This is a simple one-parameter read tool with no output schema, so requirements are modest, but the description still fails to state what is returned (definitions, study state, translations) or how lookups behave for unknown words. The agent is left to infer the tool's contract entirely from the name and schema.

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

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

Schema description coverage is 100% and there is only one required parameter ('spelling', documented as '单词拼写'), so the schema fully carries parameter semantics. The description adds nothing beyond it, which meets the baseline of 3 for high-coverage schemas.

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

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

The description '获取单词' (get word) essentially restates the tool name maimemo_get_vocabulary without adding specificity. It does not distinguish this single-word lookup from the sibling maimemo_list_vocabulary, nor indicate what data about the word is retrieved.

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 maimemo_list_vocabulary or maimemo_get_notepad. No prerequisites, context, or exclusions 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, and destructiveHint=false, so the safety profile is covered. The description usefully discloses a behavioral filter — results are limited to the caller's own self-created interpretations rather than all definitions — but says nothing about ordering, result shape, or whether an empty result is possible.

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

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

Very short and front-loaded, with the scoping detail in the second line. The two lines partially restate each other (获取释义 / 获取单词下自己创建的释义), which is mild redundancy rather than bloat, so it stays efficient overall.

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

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

For a one-parameter read-only list tool with full annotation coverage and no output schema, the description supplies what an agent needs: the resource, the scoping word parameter, and the self-created filter. Remaining gaps (pagination/ordering) are minor given the tool's simplicity.

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

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

Schema description coverage is 100% and there is a single documented parameter (voc_id = 单词 id), so the baseline of 3 applies. The description's phrase 单词下 confirms that voc_id scopes to a vocabulary word but adds no format, ID-source, or constraint detail 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 gives a clear verb+resource (get interpretations / 释义) and adds a meaningful scope: only interpretations the user created under a given vocabulary word. This distinguishes it from create/update/delete interpretation siblings, though it never names them explicitly. The opening line alone is a near-tautology, but the second line carries the real specification.

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 it should call this to view its own interpretations for a word, and that mutation tools are the alternatives. There is no explicit statement of when to prefer this over maimemo_get_vocabulary or other list tools, and no prerequisites 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=true, idempotentHint=true, destructiveHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond that — no mention of pagination behavior, filtering semantics, or result ordering for a listing endpoint.

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

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

It is short, but this is under-specification rather than conciseness — a single fragment with no front-loaded scope, constraints, or usage cue. Nothing is wasted because almost nothing is said.

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

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

For a three-parameter listing tool with full schema coverage and annotations, the description still omits pagination expectations, default limits, and how it differs from get_notepad. An agent could call it, but with notable guesswork about result set shape and filtering.

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

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

Schema description coverage is 100%, with ids, limit, and offset each documented in the schema, so the baseline of 3 applies. The description contributes no additional meaning about how ids interact with limit/offset or what filtering is applied.

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 phrase '查询云词本' identifies a read/list operation on notepads, so the basic verb+resource is present. However, it says nothing to distinguish this from the sibling maimemo_get_notepad (single fetch) or maimemo_list_notes, leaving the agent to infer scope from the name alone.

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

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

There is no guidance on when to use this versus maimemo_get_notepad, maimemo_list_notes, or the create/update/delete notepad siblings. The only weak hint is that it is a list-style tool, which the name already conveys.

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 the meaningful scope detail that only notes created by the current user are returned. It does not describe return shape, pagination, or behavior when a word has no notes.

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 very short lines, with the resource front-loaded and the scope qualifier second. The second line largely restates the first with the 'self-created' qualifier, a minor redundancy, but there is 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?

For a simple read-only list tool with full schema coverage and rich annotations, this is nearly sufficient. The remaining gap is that no output schema exists and the description never hints at what a returned note contains or how results are ordered or limited.

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 the single parameter voc_id is documented in the schema as '单词 id'. The description corroborates this by tying retrieval to a word ('单词下'), but adds no format, ID-source, or validation detail beyond the schema. 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 gives a clear verb+resource: '获取' (retrieve) '助记' (notes/mnemonics), and adds the scope '单词下自己创建的' (created by yourself under a word). This lets an agent distinguish it from list_interpretations, which operates on a different resource. However, it never names or contrasts a sibling tool 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?

There is no statement of when to use this tool versus alternatives such as list_interpretations, create_note, or update_note. The phrase '自己创建的' implies a personal-scope filter, but no conditions, prerequisites, 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?

The annotations already declare readOnlyHint, idempotentHint, openWorldHint, and destructiveHint=false, so the safety profile is covered. The description adds useful scoping context that only user-created example sentences under a word are returned, but it does not describe return format, pagination, or other behavioral details.

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

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

The description is short and front-loaded, with the specific scoping detail in the second line. The first line is slightly generic and partly redundant with the second, but overall it is efficient.

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

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

For a simple read-only tool with one fully documented required parameter and annotations covering safety, the description is mostly complete. It lacks usage guidance against sibling tools, but no output schema is needed for the agent to invoke it correctly.

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

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

Schema description coverage is 100%, and the only parameter voc_id already has a clear schema description ('单词 id'). The tool description adds no additional syntax or semantic detail beyond what the schema provides, so baseline 3 is appropriate.

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

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

The description states a specific verb and resource: retrieve example sentences under a word, specifically those created by the user. It is clear what the tool returns, though it does not explicitly name sibling alternatives such as getting interpretations or vocabulary details.

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

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

The description only says what is retrieved; it gives no explicit guidance on when to use this tool versus alternatives like maimemo_list_interpretations or maimemo_get_vocabulary. There are no exclusions or conditions for selecting it.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true and destructiveHint=false, so the safety profile is fully covered by structured data. The description adds the mutual-exclusivity behavior of the filters, which is real added context, but says nothing about result size, pagination, or return shape.

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 lines, zero filler, with the core purpose front-loaded followed by the key constraint. It is efficient, though extremely terse for a tool with a nested body object.

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 read-only list tool with full annotation coverage and no output schema, the description covers the essential constraint but omits anything about volume/limits or the shape of returned entries. It is minimally adequate rather than complete.

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

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

Schema description coverage is 100%, so the baseline is 3 and the schema already documents ids and spellings (max 1000 each). The description adds material meaning beyond the schema by stating the two filters are mutually exclusive and only one will be honored, which the schema does not express.

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

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

The description states a clear verb and resource ("查询单词" / query words), which tells the agent this retrieves vocabulary entries. However, it provides no differentiation from siblings such as maimemo_get_vocabulary or maimemo_list_notes, leaving the agent to guess which lookup path applies.

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

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

"查询条件互斥，只能生效一个" gives a concrete invocation constraint (only one filter can take effect), which is useful. But there is no guidance on when to choose this tool over maimemo_get_vocabulary or other listing siblings, so usage is only partially covered.

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 establish readOnlyHint, idempotentHint and non-destructive behavior, so the safety profile is covered. The description adds non-annotation value by disclosing beta status, no availability guarantee, possible changes, and the prerequisite that auto-sync must be enabled in the App.

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?

Purpose is front-loaded and the examples are dense and useful, but the trailing beta warning carries stray formatting (backslash, <b> tags) that adds noise without adding information beyond the warning itself.

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

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

With no output schema, the description's examples implicitly communicate the two return shapes (aggregate count vs. record list) and the beta caveat warns about reliability, which is enough for an agent to call and interpret it. Pagination/limit behavior is left entirely to the schema.

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

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

Schema description coverage is 100%, so the baseline is 3, but the worked examples show how parameters combine in practice (as_count with next_study_date.end to return a count vs. omitting as_count to return the list), which is meaning the schema alone does not convey. It does not explain limit or tag 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?

The opening line '查询学习记录' states a clear verb+resource, and the three scenario examples sharpen what 'study records' actually covers (planning totals, upcoming study counts, upcoming word lists). It does not explicitly contrast itself with the nearby sibling maimemo_get_study_progress, 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 conveyed through three concrete call scenarios rather than prose when/when-not rules: use as_count=true for totals, next_study_date.end for future-day counts or lists. That gives an agent clear selection context, but no exclusion or alternative-tool guidance 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 already declare destructiveHint=true, readOnlyHint=false, idempotentHint=false and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing beyond the name — it does not mention that this is a destructive write requiring authorization, what gets overwritten, or the mandatory confirm flag.

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 technically brief, but it is under-specified rather than concise — a bare restatement of the tool's action with no front-loaded context or structure. Brevity here reflects missing information, not efficiency.

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

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

For a destructive, non-idempotent write tool with a nested body object and a mandatory confirm=true authorization parameter, the description is wholly inadequate. Nothing about the write semantics, the confirmation requirement, or the nested update payload is 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?

Schema description coverage is 100%, so the schema already documents id, the nested body.interpretation fields, and the confirm authorization flag. The description contributes no additional parameter meaning, which is the baseline 3 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 phrase '更新释义' names a specific verb (更新/update) and resource (释义/interpretation), so the basic action is identifiable. However, it offers no differentiation from siblings like maimemo_create_interpretation or maimemo_delete_interpretation beyond the verb, and adds no scope or field detail.

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

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

There is no guidance whatsoever on when to use this tool versus the create/delete/list interpretation siblings. No prerequisites, no exclusions, no 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 the full safety profile (readOnlyHint=false, destructiveHint=true, idempotentHint=false, openWorldHint=true), and "更新" is consistent with them, so there is no contradiction. However, the description adds nothing beyond the annotations — no note that this overwrites existing mnemonic content, and no mention of the explicit user-authorization requirement encoded in confirm.

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?

At four characters this is under-specification rather than conciseness. There is no wasted padding, but there is also no front-loaded context an agent can act on.

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

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

For a destructive, non-idempotent mutation tool with nested objects, a required authorization flag, and no output schema, a bare "更新助记" leaves the agent without any of the context needed to invoke it responsibly.

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

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

Schema description coverage is 100%, so the baseline of 3 applies even though the description contributes no parameter detail. The nested body/note descriptions are largely mechanical (one even says "暂无文档"), but the structured schema does the explaining.

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?

"更新助记" (update mnemonic) simply restates the tool name maimemo_update_note in Chinese, giving no additional specificity about what is being updated or how it differs from maimemo_create_note / maimemo_delete_note. It is a tautology of the identifier rather than a clarifying statement of purpose.

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

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

There is no guidance whatsoever on when to use this tool versus its siblings (create_note, delete_note, update_interpretation, etc.), nor any mention of prerequisites. The only implicit cue is the required confirm parameter from the schema, which the description itself never references.

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, idempotentHint=false, and openWorldHint=true, but the description adds nothing on top of them. It never mentions that the schema allows status=DELETED (a destructive semantic), that 'confirm' must be explicitly true, or that the operation is non-idempotent, so a mutation tool ships with essentially no behavioral context.

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

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

It is a single short phrase with no filler, so there is no wasted text. But the sentence is so minimal that it barely earns its place and reads as under-specification rather than disciplined brevity.

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

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

For a destructive, non-idempotent write with a required confirmation flag and a nested object containing a DELETE-capable status enum and no output schema, the description is far too thin. An agent gets no warning about the DELETED semantics or the authorization requirement, which are the highest-risk aspects of this call.

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

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

Schema description coverage is 100%, with all three parameters and the nested notepad object fully annotated in the schema, so the baseline of 3 applies. The description contributes no additional parameter meaning beyond what the structured fields already provide.

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

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

The description names a verb (更新) and a resource (云词本), so the basic operation is identifiable. However it offers no scope detail and no differentiation from near-identical siblings such as maimemo_update_note, maimemo_create_notepad, or maimemo_delete_notepad, so an agent must infer the boundary 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 when-to-use, when-not-to-use, or alternative-tool guidance. Nothing tells the agent how this differs from maimemo_update_note or why one would choose it over create/delete_notepad, leaving routing entirely to inference.

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

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

Annotations already declare destructiveHint=true, idempotentHint=false, and openWorldHint=true, so the safety profile is covered structurally. The description adds nothing about what is overwritten, whether the nested body replaces or merges existing fields, or the required authorization semantics.

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

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

It is short, but this is under-specification rather than conciseness; there is no front-loaded explanation of scope, constraints, or the nested phrase payload an agent must construct.

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

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

For a destructive mutation tool with a required nested object and a mandatory confirm flag, the description omits everything an agent needs beyond the safety hints: what the update affects, how body nesting works, and when this tool is the right choice over its siblings.

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

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

Schema description coverage is 100%, so the parameters (id, body, confirm) are documented in the schema itself, establishing the baseline of 3. The description contributes no additional meaning, and notably the nested body object carries only "暂无文档" in the schema, which the description does not compensate for.

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 (例句), so an agent knows the operation type. However, it gives no scope or detail and does nothing to distinguish this tool from siblings like maimemo_update_interpretation or maimemo_update_note, which follow the same pattern.

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

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

There is no guidance whatsoever about when to use this tool versus the create/list/delete phrase siblings, nor any prerequisite or context. The entire description is a four-character label.

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