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

Annotations already declare readOnlyHint=true, so safety is covered. The description adds genuinely useful behavioral context beyond that: the month defaults to the current month in UTC+8, and results are compared against the previous month — both affect how an agent interprets the output and are not derivable from the schema or 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?

Two short sentences with no filler; the metric enumeration is dense but every listed item is meaningful content the agent needs. The default-month rule is placed at the end rather than front-loaded, a minor structural miss.

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 carries the return-content burden, and listing the aggregated fields plus the prior-month comparison largely does that. What remains unstated is the response shape (flat object vs nested per-section) and whether the comparison is a delta or two values.

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%, so the YYYY-MM format and default are already documented, giving a baseline of 3. The description adds the timezone qualifier for the default (东八区), which the schema omits and which materially changes what 'current month' means for an agent.

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

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

The description names a concrete verb+resource (按月汇总 / monthly aggregation) and enumerates the exact metrics it computes: purchases, bookkeeping, income, net expense, installment due, budget usage, category TOP, status counts, plus a month-over-month comparison. That is far more specific than the sibling CRUD tools, though it never explicitly separates itself from budget.get, which is the nearest overlap.

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 is the read-only overview tool for a given month. There is no explicit when-to-use versus budget.get or the list tools, and no stated exclusions or prerequisites, so routing still requires some inference from the metric 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?

readOnlyHint=true already tells the agent this is a safe read. The description usefully adds the returned data shape, which annotations cannot convey, but says nothing about scope (per-user vs global), pagination, or what an empty budget returns.

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

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

A single front-loaded sentence with no filler; the parenthetical payload description is compact. Slightly dense packing of return-shape into the purpose sentence keeps it off a 5.

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 must shoulder the return-value burden and it only partly does: the map shape is given, but whether one month or all months is returned, and behavior when no budget exists, are unspecified.

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

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

Zero parameters, so the baseline is 4. The YYYY-MM key format mentioned actually clarifies the returned data rather than an input, which is a small bonus but not input-semantics work.

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

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

States a specific verb and resource ('读取预算文档') and even sketches the document shape (key=YYYY-MM, value=monthly amount). It is distinguishable from the sibling budget.save, though it does not name that alternative explicitly.

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

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

Usage is only implied by the get/save pairing with budget.save and by the zero-parameter schema. There is no explicit statement of when to call this versus saving or listing, and no mention of prerequisites.

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

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

With no annotations, the description carries the full burden, and it does disclose the critical destructive-vs-merge semantics (data replaces entirely; month+total merges). However, it omits what happens if no parameters are passed, what happens if both modes are supplied, and whether any permissions are required, leaving real behavioral gaps.

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

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

Two tightly written sentences: purpose first, then the two invocation modes. Every phrase carries information 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?

For a mutation tool with no annotations, no output schema, and zero required parameters, the description covers the main happy paths but misses important edge cases: behavior when neither mode is supplied, behavior when both are supplied, and any indication of permissions or return value.

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%, so baseline is 3. The description adds meaning beyond the schema: data is a full-document replacement, and month+total form a paired single-month merge operation. It clarifies the interactive semantics of the parameters well, though it doesn't cover edge cases like conflicting modes.

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

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

The description opens with a specific verb and resource ('保存预算') and immediately distinguishes its two modes: full-document replacement via data versus single-month merge via month+total. It does not explicitly contrast with the sibling budget.get, 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?

It gives clear mode-selection guidance: pass data to replace everything, or pass month + total to set one month and merge with existing data. It doesn't name alternatives or state exclusions, but the when-to-use-which-mode context 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?

readOnlyHint=true already tells the agent this is a safe read, so the description must add something beyond that — return shape, ordering, pagination, or scope. It adds nothing: no indication of what a '分类文档' contains, whether results are paginated, or how they are sorted.

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 padding, so it is certainly concise, but the brevity comes at the cost of under-specification rather than efficiency — the one sentence carries almost no actionable 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?

There is no output schema, so the description is the only place that could explain what a caller receives, and it does not. For a simple 0-param read tool the annotations cover the safety profile, but the return value and the meaning of '自定义分类文档' remain unexplained.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the empty schema is self-explanatory and the baseline for a 0-param tool 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 '读取自定义分类文档' largely restates the name/title (cats.list / 分类列表) without committing to a specific operation shape; '文档' (documents) is ambiguous for a tool whose name implies listing categories, so an agent cannot be sure whether it returns a list, a document set, or something else.

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

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

No when-to-use, when-not-to-use, or alternatives are given. The sibling set contains many parallel list tools (todo.list, recurring.list, purchase.list, expense.list, project.list, phase.list) plus cats.update, yet the description does nothing to route the agent between cats.list and cats.update or between categories and other list tools.

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

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

With no annotations provided, the description usefully discloses that data causes a full replacement (a destructive behavior) and that patch performs a shallow merge, including a concrete {list: [...]} example. It omits permissions, error behavior, return format, and whether the operation creates a missing category, so the behavioral picture is only partial.

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 compact clauses with zero filler, front-loading the action and then immediately contrasting the two parameter behaviors. The example is short and earns its place by clarifying shallow merge.

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

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

For a mutation tool with no annotations, no output schema, and an entirely undescribed input schema, the description provides the crucial replace-vs-merge semantics but not enough to know what fields a category document accepts. It is adequate for choosing between data and patch, but incomplete for safely constructing a full update payload.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning, and it does: data is described as whole-document replacement and patch as shallow merge with an example of array replacement. It still does not describe the expected fields inside data or the types, leaving some ambiguity for constructing valid input.

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 "保存分类" (save category), a clear verb and resource that an agent can match to the cats.update tool. It does not explicitly contrast with siblings like cats.list, but the action is distinct enough for selection.

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 explains the two operational modes: data replaces the entire document, while patch shallow-merges with the existing one. However, it does not say when to use update versus other category tools or mention prerequisites such as whether the category must already exist.

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

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

No annotations are provided, so the description carries the full burden. It is a mutation (新增) with only 'amount' required, yet it says nothing about side effects, whether records affect budget/analytics, validation failures, or what is returned — and the amount range it cites merely repeats the schema's min/max.

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, with no filler. The brevity is a virtue in form even though content is underspecified.

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?

Nine parameters, no annotations, no output schema, 44% schema coverage — the description is far too thin for this complexity. It supplies the type default but omits the split/allocation parameters (splitWeeks, splitStartWeek) and project/phase linkage, which an agent cannot call correctly without.

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 44%, so the description needs to compensate but mostly does not. It adds one genuinely useful detail not in the schema — type defaults to 支出 — but leaves note, phaseIdx, projectId, splitWeeks and splitStartWeek entirely undocumented in both places, and the amount range duplicates 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+resource: 新增收支记录 (create an income/expense record), which is enough to tell an agent what it does and separates it loosely from expense.update/delete/list. It does not explicitly name siblings or scope itself against purchase.create, which also creates records, so it stops short of 5.

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

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

There is no guidance on when to use this versus expense.update or purchase.create, and no preconditions mentioned. The reader must infer usage from the tool name alone.

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

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

The destructiveHint=true annotation already flags this as a write/destroy operation, so the bar is lower, but the description adds nothing: no statement that deletion is irreversible, no permission or ownership requirement, no mention of whether related entries (recurring transactions, budgets, analytics aggregates) are affected, and no confirmation 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 sentence is front-loaded and contains zero padding, so it is not verbose. However, its brevity comes from under-specification rather than discipline — there is only one clause and it duplicates the structured fields.

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, irreversible single-record delete with no output schema, no parameter documentation, and only a single annotation hint, the description carries almost none of the burden it must. An agent could not call this safely or confidently from the description alone.

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

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

Schema description coverage is 0% for the single required parameter `id`, and the description provides no compensating meaning. At most it implies the id identifies an expense record, but it never states the id's format, source, or whether it is the expense id versus a category or purchase id.

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 text "删除记账记录" only restates the tool name (expense.delete) and title (删除记账) in Chinese. It is a tautology rather than a description: it adds no scope, no distinction from siblings such as expense.update or purchase.delete, and no detail about what an "记账记录" is in this system.

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

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

There is no when-to-use or when-not-to-use guidance at all. With close siblings like expense.update, expense.list, and purchase.delete present, the definition gives the agent no basis for choosing this tool over the alternatives or for confirming a record should be deleted rather than updated.

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 supply readOnlyHint=true, so safety is covered, but the definition adds nothing about what the call returns. It is silent on default page size, sort order (newest first?), whether an omitted filter means 'all records' rather than 'none', and whether results are capped by the undocumented limit parameter.

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

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

The definition is a single front-loaded sentence: verb plus resource first, then the filter capabilities. Nothing is wasted or repeated.

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 seven parameters, no output schema, and no annotation hints beyond read-only, the definition gives enough context to construct a filtered call but not enough to predict the response: record count, ordering, and result-shape are all unstated. It is adequate, but it has 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 only 29%, so the definition must compensate, and it largely does: it enumerates 类型/分类/项目/关键词/日期区间, mapping six of the seven parameters to human-readable meanings that the schema leaves bare (category, keyword, projectId, and the from/to pair). It does not explain limit, which is the one dimension left 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 definition names a specific verb (列出) and resource (记账记录), and enumerates the filter dimensions. However, it does not differentiate the tool from sibling list tools such as purchase.list and recurring.list, and the parenthetical (收支) omits the 采购 type that the enum actually supports, leaving the reader to infer that 'purchase' records live in a separate 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 definition gives no when-to-use guidance and no exclusions. It never says to use purchase.list for 采购 records or analytics.summary when aggregated totals are wanted, even though several sibling tools operate on overlapping data.

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

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

With no annotations provided, the description carries the full burden but discloses only that it is an update. It does not state whether this is a partial or full replacement, what permissions are required, whether changes are reversible, or what happens to fields that are omitted.

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 padding, so it is technically concise. However, its brevity comes from omission rather than discipline, and it contains no front-loaded context that would help an agent decide how to call the tool.

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

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

For a 10-parameter mutation tool with no annotations, no output schema, and no documented parameters, this description is far from complete. An agent cannot determine safe update semantics or parameter meaning from it at all.

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 10 parameters, and the description only says "fields" without naming a single one. Key semantics such as the meaning of phaseIdx, projectId, splitWeeks, splitStartWeek, and the 支出/收入/采购 enum are left entirely unexplained.

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

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

"更新记账记录字段" restates the tool name (expense.update) and title (更新记账) without adding any substance. It does signal a mutation on an expense record, but gives no sense of scope and no differentiation from siblings such as purchase.update, todo.update, or recurring.update.

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 rather than the many sibling update tools, and nothing about the prerequisites involved in performing a partial update (is id alone enough, are unspecified fields left untouched?). Usage must be entirely inferred from the name.

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

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

readOnlyHint=true is consistent with a listing tool, so the description is not contradicting annotations. It adds genuine behavioral context by disclosing that omitting projectId broadens the result set to all projects. It says nothing about pagination, ordering, or result volume, which for an all-projects listing could be large.

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

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

One sentence with the core action first and the conditional scoping second; nothing redundant or padded.

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 single-optional-parameter read tool with readOnlyHint already covering safety and no output schema required, the description is nearly sufficient. Only return-shape and volume expectations are left implicit, which is minor for a simple list.

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 meaning of projectId — and it does, spelling out the default behavior when the parameter is absent. This is the key semantic an agent needs and it is supplied clearly, though format/source of projectId values is not explained.

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 ('列出项目阶段') that unambiguously identifies the phase-listing operation. The parenthetical clarifies scope (all projects when unfiltered). It does not explicitly name a sibling to contrast with, but the 'phase' resource is distinct enough from project.list/todo.list that confusion risk is low.

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 parenthetical implies when to pass projectId versus omit it, which is useful implied usage guidance. However, it never states when to choose this tool over project.list or phase.status.set, and no 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?

With no annotations, the description carries the full burden, and it does disclose a genuine side effect: setting P5 to done auto-completes the project, plus the P5-cannot-be-skipped restriction. It does not cover idempotency, whether earlier/later phases are affected when one is skipped, permission requirements, or 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?

Two compact sentences, front-loaded with the action and the valid states, with the P5 constraint following. No filler and nothing 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?

For a 5-parameter mutation tool with no annotations and no output schema, the description covers the core state model and one critical business rule but leaves parameter semantics and failure modes undocumented. Adequate as a minimum, but clearly incomplete for the tool's complexity.

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

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

Schema description coverage is 0%, so the description must compensate, and it largely does not: note and displayName are never mentioned, and phaseIdx indexing is left ambiguous (the text says 'P5' while the schema permits 0-5, six values). Only the status enum is echoed from the schema, adding no meaning beyond it.

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

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

States a specific verb+resource (set phase status) and enumerates the accepted states (todo/doing/done/skipped), so the agent knows exactly what the call changes. It does not explicitly contrast itself with phase.list or other siblings, but the mutation semantics make the distinction obvious.

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: the agent infers 'call this to change a phase's state', and one important constraint (P5 cannot be skipped) is given as a precondition. There is no explicit when-to-use/when-not or pointer to the complementary phase.list tool for reading state first.

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

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

No annotations are provided, so the description carries the full burden. It does disclose one genuinely valuable behavioral trait — the server automatically creates six phases P0–P5 — which an agent would otherwise not know and which affects downstream phase.* calls. However, it says nothing about permissions, duplicate-name handling, validation failures, or what the response returns (no output schema exists).

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 side effect placed immediately, no filler. It is efficient, though so terse that the efficiency borders on under-specification for a 6-parameter mutation 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?

For a write operation with zero annotations, six parameters (four undescribed), and no output schema, the description is too thin. An agent still lacks required-field semantics beyond name, side-effect details beyond phase creation, and any expectation of the returned result.

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

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

Schema description coverage is only 33% (only status and dueDate are documented), so the description is expected to compensate and does not — it mentions no parameters at all. Undocumented fields like budget, color, and description leave the agent guessing about format and constraints.

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 a project), matching the tool name, and adds the notable side effect that the server auto-creates six phases P0–P5. It does not explicitly distinguish this from siblings like project.update or purchase.create, but the create semantics 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?

There is no guidance on when to use this versus alternatives (project.update, project.get) or on prerequisites such as whether the caller must first create phases, categories, or a budget. Usage is only implied by the verb '新增'.

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 destructiveHint annotation already declares the write/destroy nature, and the description adds real value on top: it enumerates the cascade (phases/deliverables are deleted) and explicitly reassures that purchase/expense/todo records survive with only their association removed. It doesn't address irreversibility, confirmation, or failure behavior if a cascade is blocked.

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

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

One compact sentence that front-loads the core action, then the cascade, then the non-cascade caveat. Every clause carries distinct information 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?

For a one-parameter, no-output-schema delete tool, the two things an agent most needs to know—what else gets deleted and what merely gets unlinked—are both answered. The destructiveHint annotation covers the safety profile, so nothing essential is missing.

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

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

There is a single parameter, 'id', with 0% schema description coverage, and the description never says what it identifies or what format it takes. The parameter's meaning is inferable from the tool name, so this is a minor rather than critical gap, but the description does not compensate for the missing schema documentation.

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

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

States a specific verb and resource ('删除项目') plus the cascade scope (phases/deliverables) and the non-cascade treatment of linked purchase/expense/todo records. This clearly separates it from project.update or project.list without needing to name them. It doesn't explicitly name a sibling alternative, which keeps it just short of a 5.

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

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

The description gives the decision-relevant context an agent needs before calling: what will be destroyed versus merely unlinked. There is no explicit 'use X instead' routing or listed preconditions (e.g. permissions, whether the project must be empty), so it stops short of a 5.

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

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

The readOnlyHint=true annotation already tells the agent this is a safe, non-mutating read. The description adds value by naming the categories of data returned (phases, deliverables, expenses, transactions), but says nothing about authorization needs, missing-project behavior, or response shape beyond that list.

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

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

A single front-loaded sentence that leads with the action and scope before the parenthetical payload list. Nothing is redundant, though the parenthetical could be trimmed if the return categories were less important.

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

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

With no output schema and no parameter documentation, the description partially compensates by enumerating the main content of the response. For a simple one-parameter read, this is nearly sufficient; only the shape of the response and the error case remain 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?

There is a single parameter with 0% schema description coverage, so the description must carry its meaning. 按 ID does establish that the parameter is a project identifier, but it adds no format, source, or example detail beyond that minimal clarification.

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 (获取, "get") on a specific resource (项目, "project") and enumerates the payload (阶段、交付物、花费与流水 — phases, deliverables, expenses, transactions). This clearly distinguishes it from project.list, which returns a collection rather than one project's full record.

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 按 ID ("by ID") implies that the tool is used when a single project's details are needed, and the required id parameter reinforces this. However, it never explicitly states when to choose this over project.list or budget.get, nor any preconditions 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?

readOnlyHint=true already covers the safety profile, so the bar is lower; the description still adds useful behavior beyond it by disclosing exactly what each mode returns (phase status and spend totals vs full phases/deliverables/transactions). Given there is no output schema, this return-shape disclosure is genuinely valuable.

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, front-loaded with the core action and then the mode difference; no filler or restated title 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?

Covers the critical return-mode distinction that the absent output schema leaves undocumented, which is the main gap it needed to fill. It still leaves the status filter, result scope (all projects vs. user-scoped), and pagination unspecified for a tool an agent may call with no arguments.

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

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

Schema description coverage is 0%, so the description must carry parameter meaning. It explains detail=true well (full phases/deliverables/transactions), but the required status parameter is left completely unexplained in both schema and description, leaving half the parameters undocumented.

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

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

States a specific verb and resource (列出项目) and immediately clarifies the two return modes, so the agent knows what it gets back. It does not distinguish itself from sibling project.get, which also retrieves project data, so the agent must infer the list-vs-single distinction.

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

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

The default-vs-detail=true split gives implied usage guidance for choosing verbosity. However, there is no explicit when-to-use-this-instead-of-project.get, no note on whether results are paginated or filtered by default, and no guidance about the status parameter.

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

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

No annotations are provided, so the description carries the full disclosure burden, and it delivers almost none: no mention of partial-versus-full replacement semantics, whether omitted fields are preserved, permission requirements, or reversibility. The only implicit signal is that 'basic info or current phase pointer' suggests a field-scoped patch rather than a full overwrite.

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 redundancy, which is efficient but also under-specified rather than genuinely concise. There is no front-loaded detail about what an update actually changes.

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 eight-parameter mutation tool with no annotations and no output schema, the description is far too thin — it does not specify patch semantics, field meanings, phase bounds, or what the response contains. It covers only the broadest possible framing of the 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 0% across eight parameters, so the description must compensate and does not. It explicitly names only the phase pointer (currentPhase) and gestures vaguely at 'basic info,' leaving name, color, budget, status, dueDate, and description undocumented — including the unknown allowed values for status and the 0-5 range semantics for currentPhase beyond the schema bounds.

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 (update a project) plus a coarse scope split (basic info versus current phase pointer), which is more than a restatement of the name. However, 'basic info' is left undefined against the eight actual fields, and nothing distinguishes this tool from siblings such as project.create, phase.status.set, or budget.save that touch overlapping project data.

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, when not to, or which sibling to pick instead. An agent learning that it should move a project's stage has no hint whether project.update, phase.status.set, or program-level phase tools is correct.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It mentions default status behavior and the effect of the quick flag, but does not state required permissions, side effects, idempotency, or what the tool returns. This is a significant gap for a mutation tool.

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

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

The description is concise and front-loaded, stating the main purpose first and then one key behavioral detail. It contains no wasted words, though it could be slightly more structured to improve readability.

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 (18 parameters, mutation operation, no annotations, no output schema), the description is too minimal. It does not mention the return value, common usage patterns, or the behavior of the many optional fields, leaving the agent with insufficient context 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 description coverage is high (94%), so the baseline is 3. The description adds a small clarification about the interaction between quick and status defaults, but most parameter semantics are already covered by the schema, and it does not provide additional meaningful detail.

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 ('新增' / add) and resource ('采购记录' / purchase record), making it immediately clear that this tool creates a new purchase. The action is distinct from sibling tools like purchase.update, purchase.delete, purchase.get, and purchase.list, so an agent can differentiate without additional context.

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 does not explicitly say when to use this tool versus alternatives such as expense.create or purchase.update. It only implies usage through its purpose statement, leaving the agent to infer the appropriate context without any exclusions or alternatives.

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

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

Annotations already flag destructiveHint=true, but the description adds real context beyond them: deletion cascades into linked todo items, which an agent would not infer from the schema or annotations. It still omits whether the delete is irreversible and how missing/invalid ids are handled.

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 waste, leading with the primary action and appending the cascade effect. 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?

For a one-parameter destructive tool with annotations covering the safety profile and no output schema, this is nearly sufficient; the cascade side effect is the key piece of context. Missing only irreversibility and return/error behavior.

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 (id) with 0% schema description coverage, so the description must compensate; it never says the id is a purchase record identifier, though that is inferable from the tool name. Adequate but not compensating for the coverage gap.

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

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

States a specific verb+resource (delete the purchase record) and adds a non-obvious secondary effect (cleanup of linked todos). That distinguishes it from purchase.update or purchase.list, though it never names a 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 by the verb and resource — the description gives no when-to-use condition, no prerequisites, and no guidance on alternatives such as closing/archiving instead of deleting.

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, so the description carries a lighter burden. It adds nothing beyond that fact, saying nothing about what happens for a missing or malformed ID, whether deleted purchases are visible, or what a returned record contains.

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

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

One short front-loaded sentence with zero waste and the key scoping word ('单条') early. It is efficient, though brevity here edges toward under-specification rather than crispness.

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 tool this is minimally adequate, but with no output schema the description could say what a purchase record comprises, and the missing not-found semantics matter for a by-ID lookup.

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

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

Schema coverage is 100% and the schema even includes a format example ('rec_123'), so the single parameter is fully documented elsewhere. The description's '按 ID' merely restates the schema and adds no format or constraint information.

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 ('单条采购记录') scoped to a single record by ID, which implicitly distinguishes it from the list operation. However, it never names purchase.list or any sibling, so the 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 call this versus purchase.list or budget.get, nor any mention of prerequisites or not-found behavior. The ID-only scope is the only implicit signal.

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, so the safety profile is covered. The description adds genuinely useful behavior: dates are millisecond timestamps and 'limit' returns the most recent N records (an ordering semantic not in the schema). It omits default sort order beyond that and any pagination/return-size 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 compact sentence with the core action front-loaded and the filter set and format caveats trailing. No wasted text, though the two clauses could be split for clearer scannability.

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

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

With no output schema, the description does not say what fields a purchase record contains or whether results are paginated, and it leaves keyword/category semantics undefined. The readOnly annotation covers safety, but for a 7-parameter list tool some return-shape context is missing.

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

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

Schema coverage is 57%, so the description must do some compensation. It clarifies the timestamp unit for from/to and the 'most recent N' meaning of limit, which the schema does not fully convey (limit has no description at all). However, keyword and category remain undefined 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?

The description states a specific verb+resource ('列出采购记录') and enumerates the filter dimensions, so the agent can tell it apart from purchase.get/create/update/delete. It does not explicitly name a sibling alternative, but the list-vs-get distinction is implicit in the filtering language.

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 parenthetical filter list implies when this tool is appropriate (browsing/filtering purchases), but it never states when to prefer purchase.get or how it relates to purchase.list-style siblings like expense.list or project.list. Usage must be inferred from the filter set.

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

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

With no annotations, the description carries the full burden; it does disclose a real side effect — status advancement triggers server-side todo creation/completion and installment todos. It does not say whether omitted fields are left unchanged (patch vs. replace), whether transitions are validated, or what permissions are required.

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

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

A single front-loaded sentence with the side-effect detail in parentheses; nothing is wasted, though the parenthetical is dense enough that it deserves at least one clarifying clause about field-patch semantics.

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 21-parameter mutation tool with no annotations, no output schema, and 14% schema coverage, the description covers only the status-advancement path. An agent still cannot determine patch semantics, valid status values, or the effect of most 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?

21 parameters with only 14% schema description coverage, and the description explains none of them beyond the existence of a status field. The installments/installmentPaid/installmentStart/installmentAmount cluster, phaseIdx, and projectId (where empty string clears the project link) are all left undocumented 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?

The description states a specific verb and resource (update purchase fields) and adds the distinct second mode of advancing status. An agent can tell this apart from purchase.create/delete/get, 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 implicitly signals two usage modes (field patching vs. status advancement) but never says when to prefer this over purchase.create, purchase.get, or recurring.update, and gives no preconditions such as which statuses may be advanced.

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?

readOnlyHint=true already covers the safety profile, so the description's only added job is to explain what is returned. It does not say whether the result is a collection, whether it includes archived/deleted recurrences, or how the two item types (收支 vs 固定项) are combined — despite there being no output schema to fill that gap.

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

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

A single short sentence with no filler or redundancy. It is front-loaded, though brevity here comes at the cost of substance rather than from tight editing.

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

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

With no input schema, no output schema, and only a readOnly hint, the description is the sole source of contract information, yet it never says what a call returns. The vague word '文档' (documents) leaves the agent guessing whether it gets a list, a single doc, or a paginated 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, so there is nothing for the description to disambiguate; baseline 4 applies. The description makes no false claims about 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 the resource (重复收支/固定项, i.e. recurring income/expense and fixed items) but uses '读取...文档' (read documents) rather than stating that it lists items, which blurs it against the tool name recurring.list. It is distinguishable from recurring.update only by inference from the verb, not from explicit contrast.

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

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

There is no statement of when to call this versus recurring.update or any of the many other *.list siblings. The agent must infer usage from the tool name alone.

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

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

With no annotations, the description carries the full burden and does disclose the key destructive trait: data replaces the whole document, while patch performs a shallow merge. That is genuinely valuable behavioral information. However, it omits whether saving an unknown item creates it, what happens to nested objects on shallow merge, auth requirements, and what the response contains.

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

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

Two short sentences, front-loaded with the operation, then the data/patch distinction with a concrete patch example. No filler; the only omission is that it is arguably too terse for an untyped mutation 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?

For a two-parameter mutation tool with no annotations, no output schema, and untyped parameters, the description supplies the crucial merge-vs-replace rule but leaves the agent guessing about create-on-missing behavior, parameter combination rules, and return values.

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

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

Schema coverage is 0% and both parameters are untyped empty objects, so the description must compensate; it does explain data's replacement semantics and patch's shallow-merge semantics with an example. It still does not specify expected structure for data, whether both may be supplied together, or which takes precedence.

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 resource (重复项) and verb (保存), and distinguishes two update modes (data full replacement vs patch shallow merge). It does not clarify whether this upserts/creates when the item doesn't exist, which matters given the name is 'update' and no create sibling for recurring exists.

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

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

The contrast between data and patch implicitly tells the agent which parameter to choose for full replace vs partial edit, which is useful. But there is no explicit when-to-use guidance relative to siblings like recurring.list or other *.update tools, and no prerequisites or exclusion 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?

With no annotations, the description carries the full behavioral burden. It usefully discloses that recurring todos auto-generate a next instance after completion, but it omits permission requirements, response behavior, validation/defaults, and other side effects for a 13-parameter mutation tool.

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

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

The description is two short sentences with zero waste and is front-loaded with the core action. The recurrence behavior is stated immediately after the primary purpose.

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 complex 13-parameter creation tool with no annotations, no output schema, and low schema description coverage, the description is far too thin. It covers recurrence but not required fields, defaults, validation, return values, or interaction with 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 only 46%, so the description should compensate for undocumented parameters. It only adds meaning for repeat and leaves most parameters, including required title and fields like order, linkId, category, linkType, projectId, and description, 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 clear verb and resource: "新增待办" (add a todo). It is distinguishable from siblings like todo.update/todo.delete/todo.list by the creation verb, but it does not explicitly call out sibling boundaries.

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 explicit guidance on when to use todo.create versus todo.update or other sibling tools. The recurrence note explains a side effect, not when this tool should be selected.

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 only say destructiveHint=true; the description adds the crucial nuance that destructive behavior is opt-in via purge=true, while the default is a reversible soft delete that sets the status to deleted. It does not cover secondary effects (e.g., child items, idempotency, permission requirements), 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?

Two short clauses with the default behavior front-loaded and the exceptional path (purge=true) second. Nothing wasted, 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 two-parameter mutation with no output schema and a destructive annotation, the description covers the single decision that matters — soft vs. hard delete. It omits what happens on an unknown id and what the call returns, but those are secondary for this tool's shape.

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 carries the full burden and does explain the semantics of the boolean `purge` flag (true = permanent deletion, absent = soft delete), which the schema alone does not. The `id` parameter's format/origin is left unstated, but its meaning is obvious from the tool name.

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 the operation precisely: deletion of a todo, with the two modes (soft vs. permanent) spelled out. An agent can distinguish this from todo.update, but the description never explicitly says to use update for status changes rather than delete, so sibling differentiation relies on inference.

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 default-vs-purge split implicitly tells the agent which mode to pick when it needs a permanent removal, but there is no stated when-to-use/when-not guidance relative to todo.update (which can also set a deleted status) or any warning about when purge is warranted.

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?

readOnlyHint=true already tells the agent this is a safe read, so the description carries less burden, but it adds nothing behavioral: no default limit, ordering, pagination, or whether 已删除 items appear when no status filter is passed. It essentially restates the name plus the filter 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?

A single front-loaded sentence with zero filler, but its terseness comes partly from omitting information rather than from 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 6-parameter, zero-required, read-only list tool with no output schema, the essentials are present: what is listed and what can be filtered. Missing are default/pagination behavior and return shape, which keep it short of full completeness.

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% (limit, keyword, category, projectId are undocumented in the schema), but the description at least establishes that status/category/priority/project/keyword are filter criteria. It says nothing about limit semantics, defaults, or whether filters combine with AND, so the coverage gap is only partially compensated.

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 the trailing filter list makes it distinguishable from the mutation siblings todo.create/update/delete. It does not explicitly contrast with other list tools (recurring.list, cats.list), but the resource noun 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?

The description says what the tool does but never when to choose it over the many sibling list tools, nor any preconditions. An agent gets no routing guidance beyond the name.

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

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

With zero annotations, the description carries full burden, and it does disclose one high-value side effect: status=已完成 with a non-empty repeat auto-generates the next occurrence. However, it says nothing about partial-update semantics, permissions, whether clearing a field is possible, or what the response contains – significant gaps for a 15-param mutation tool.

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

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

A single compact sentence with the conditional side effect front-loaded after the base action. No filler, though it is terse enough to border on under-specification for the parameter surface.

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 15-parameter mutation tool with no annotations, no output schema and no parameter descriptions, the description covers only a fraction of what an agent needs: which fields are writable, partial vs full update, and return behavior are all missing.

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

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

Schema description coverage is 0% across 15 parameters, so the description must compensate – it only explains the interaction of status and repeat. Formats for dueDate, tags, subtasks, reminders, linkId/linkType, projectId, priority and the meaning of order are entirely undocumented.

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

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

Names a specific verb+resource (更新待办) that is clearly distinct from todo.create/todo.delete/todo.list. It does not explicitly contrast itself with siblings, but the verb makes the intent 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?

No guidance on when to use this versus todo.create or the recurring.* siblings, and no prerequisites (e.g., must the todo exist, is id required, can fields be partially updated). Usage is only implied by the verb 'update'.

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