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

With no annotations provided, the description carries the full behavioral burden. It discloses key runtime behavior: automatic token header attachment, unwrapping of the {code,msg,result} envelope, path placeholder substitution via params, and raw=true to skip unwrapping. It does not cover error handling or side-effect expectations for mutating endpoints, but it adds substantial behavioral context beyond the schema.

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

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

Two sentences plus a compact example block convey purpose, token behavior, envelope unwrapping, path placeholders, and a README pointer. Every sentence earns its place, and the 'escape hatch / covers all endpoints' purpose is front-loaded.

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

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

Given that this is a generic passthrough tool with 7 parameters and no output schema, the description covers the essential invocation mechanics: token header, envelope unwrapping, path placeholders, raw mode, and where to find valid paths. It stops short of describing business-error responses or when a dedicated sibling should be preferred, but those gaps are secondary for a tool of this nature.

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 applies. The description's placeholder/params relationship and raw behavior are largely already encoded in the schema, so the examples are illustrative rather than semantically necessary. It reinforces meaning but does not significantly compensate for anything missing in 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 opens by defining the tool as a generic API request 'escape hatch' covering all endpoints, which clearly identifies the action (request) and the broad resource (all APIs). The '逃生通道' framing also distinguishes it from the many dedicated sibling tools, so an agent can recognize it as the universal fallback without inspecting schemas.

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

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

The 'escape hatch' wording implies use when a dedicated sibling does not cover a desired endpoint, and the examples show raw endpoint invocation. However, it never explicitly says 'prefer dedicated tools when available' or gives conditions for choosing this generic tool over specific siblings, so the usage guidance is implied rather than fully 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?

With no annotations, the description carries the full behavioral disclosure burden. It explicitly discloses the key trait: this tool is local-only and performs no network request, which is non-obvious from the tool name. It also lists the specific fields available (JWT, user ID, API base), giving the agent a concrete picture of what it will receive.

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 entire description is one compact, front-loaded sentence. It opens with the action and resource, immediately adds the critical local/no-request qualifier, and lists the returned fields 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 parameterless, low-complexity status tool with no output schema, the description is complete: it states the tool's purpose, its network behavior, and the three pieces of information returned. Nothing essential is missing for an agent to call it correctly.

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

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

The tool has zero parameters and an empty schema, so there is nothing for the description to explain. The baseline of 4 for a parameterless tool applies; the description sensibly focuses on outputs instead of inputs.

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

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

The description names a specific verb (查看/check), a clear resource (login status), and a precise scope: local configuration only, with no network request. It also lists exactly what the status includes (JWT, user ID, API base), and the 'local, no request' qualifier distinguishes it from login-related siblings.

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

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

The phrase '本地配置，不发请求' clearly communicates that this is the tool to use when the agent needs to inspect locally stored authentication state without hitting the network. It does not explicitly name alternatives or exclusions, but the intended context is clear enough for an agent to choose it over login_* or get_me tools.

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

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

No annotations are provided (e.g., destructiveHint), and the description only says 'delete' which implies mutation but does not disclose critical behaviors such as whether deletion is permanent, whether it requires owner/admin permissions, whether related data (e.g., bills under the account book) is cascaded, or whether confirmation is required. The description also doesn't mention the HTTP 200 success response or error handling. This is a significant gap for a destructive operation.

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

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

The description is very concise: one sentence with two key pieces of information (endpoint and required fields). It front-loads the operation name and endpoint. It earns a 4 because it is efficient, though it could benefit from one extra clause about behavioral impact (e.g., permanent deletion), but that's more for completeness than conciseness.

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

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

Given that this is a destructive operation with no annotations, no output schema, and nested objects, the description is incomplete. It doesn't specify ownership/authorization requirements, what happens to associated data, or the success response format. The description is enough to execute the call but lacks the safety and side-effect information an agent needs to decide if it's safe to invoke without human confirmation. The lack of behavioral transparency makes it insufficiently complete for a high-risk tool.

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

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

The schema description has 100% coverage: it describes the 'entity' parameter as an account book object containing the primary key accountBookId. The description adds the important detail that 'userId' must also be included in the entity, which is not explicit in the schema (additionalProperties is open). This adds value over the schema, so it's at least at the baseline of 3. However, it doesn't clarify the exact type of 'userId' (string?) or how the entity is structured beyond the key fields.

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

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

The description clearly states a specific verb ('删除账本' - delete account book), identifies the resource (账本/account book), and includes the HTTP endpoint (POST /accountBook/deleteAccountBook). It distinguishes this from sibling tools like save_account_book and get_account_members by specifying deletion, so an agent can identify the operation without opening the schema.

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

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

The description gives clear context that this is a delete operation and explicitly mentions the need to include the primary key (accountBookId) and userId. However, it doesn't explicitly state when to use this versus other delete tools (e.g., delete_reimbursement, delete_bill), though the name and endpoint make the target resource obvious. It also doesn't mention prerequisites like authentication or ownership checks, which are inferable from the context but not 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?

No annotations are provided, so the description carries the full burden of behavioral disclosure. It conveys a destructive POST mutation and the required payload, but does not disclose whether deletion is permanent or recoverable, what side effects occur (e.g., whether it feeds the delete history that get_delete_history reads), what authorization is needed beyond supplying a userId, or the response shape. For a mutation, this is a significant gap.

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

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

Two short sentences, each earning its place: the first identifies the action and endpoint, the second states the mandatory payload fields. Fully front-loaded with zero 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 destructive write with no annotations and no output schema, the description covers invocation well — what, endpoint, and required fields — but omits consequences: permanence/recoverability, delete-history tracking, error conditions, and return value. The sibling get_delete_history hints at deletion-tracking context that could usefully be disclosed. Adequate to make the call, incomplete for understanding what happens after.

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% at the top level, so the baseline is 3, but the description adds real value: the schema only describes entity as "资产对象（含主键 assetId）", whereas the description explicitly requires both assetId AND userId inside entity. The userId requirement is entirely absent from the schema, and the schema's additionalProperties={} leaves the nested shape open — the description compensates for that.

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 — "删除资产" (delete asset) — reinforced by the explicit POST /asset/deleteAsset endpoint. The resource is precise enough to distinguish it from sibling delete tools such as delete_asset_history, delete_bill, and delete_tag. There is no ambiguity about which operation this performs.

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 provides invocation context by requiring entity to carry assetId and userId, which tells the agent what data must be present. However, it never states when to prefer this over alternatives like delete_asset_history or save_asset, nor any preconditions such as asset ownership or existence. Selection timing is only implied by the tool name.

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

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

There are no annotations, so the description carries the full burden of disclosing behavior. It reveals that this is a delete operation (via the name and the '删除' verb) and specifies required fields, but it does not disclose whether the deletion is permanent, whether it has side effects, what permissions are needed, or what happens on failure. The absence of such context for a destructive operation is a notable gap.

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

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

Two short sentences deliver the endpoint, the action, and the required fields with no filler. The essential requirement (entity fields) is front-loaded immediately after the action statement. Every word earns its place.

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

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

For a parameter-light delete operation, the description covers the endpoint and mandatory payload. However, with no annotations and no output schema, it omits response behavior, error conditions, permission requirements, and any cascading effects. The core invocation is documented, but an agent lacks full situational awareness for a destructive 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?

The schema only describes entity as an object containing the primary key assetHistoryId. The description adds critical information: entity must carry both assetHistoryId and userId, which is not present in the schema's parameter description. Since the nested object has additionalProperties allowed, the description meaningfully narrows the acceptable payload and prevents incorrect invocations.

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 begins with '删除资产变动记录' (delete asset change record), a specific verb and resource that clearly identifies the operation. It also states the exact HTTP endpoint, which helps distinguish this from other delete_* siblings like delete_asset or delete_bill. However, it does not explicitly contrast itself with sibling tools, so it stops short of a 5.

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

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

The description implies when to use the tool: whenever an asset history record needs to be deleted, with the entity containing the primary key and userId. No explicit when-not-to-use guidance or alternatives are mentioned, so an agent must infer usage from the resource name. This is adequate but lacks the exclusion or alternative routing that would warrant a 4.

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 present, so the description carries the full burden of behavioral disclosure. It adds the endpoint and deletion-by-billId mechanism, but does not state whether deletion is permanent or reversible, what downstream effects occur, 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?

The description is one short sentence with the action and endpoint front-loaded. There is no filler and every part adds useful information.

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

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

For a simple delete-by-id tool, the required parameter and endpoint are enough to attempt a call. However, destructive behavior is not elaborated and user_id remains unclear, so the description is adequate but not complete.

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

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

The schema already documents bill_id as '账单 ID', and the description only restates this as 'billId' with a slight naming mismatch. The optional user_id parameter is left entirely unexplained, so the 50% schema coverage gap is not 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?

The description states a clear action ('删除账单'), the target resource, and the API endpoint, so an agent can tell it deletes a bill. It does not explicitly differentiate itself from the many delete_* siblings, but the resource 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 provides no when-to-use or when-not-to-use guidance, and it does not mention any alternative tools. The only usage signal is the verb itself, so usage context remains implicit.

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

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

There are no annotations, so the description carries the burden of behavioral disclosure. It communicates that this is a destructive delete operation, specifies the HTTP method, and requires userId context, but it does not mention irreversibility, permissions, or failure behavior. This is adequate but not rich.

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

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

The description is two short sentences with no filler. The core purpose and endpoint are front-loaded, followed immediately by the essential parameter requirement.

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 one-parameter delete tool with no annotations and no output schema, the description covers the key invocation requirements: the action, the endpoint, and the mandatory fileId/userId fields. It does not describe the response or error cases, but those are not critical for invoking the tool correctly.

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

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

The schema only describes the entity object as containing the primary key fileId, while the description adds the crucial requirement that entity must also carry userId. This extra guidance goes beyond the schema and compensates for the lack of nested property definitions.

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

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

The description states the operation explicitly with a specific verb and resource: '删除账单附件' (delete bill attachment), and reinforces it with the exact POST endpoint. This clearly distinguishes it from sibling tools like delete_bill or delete_asset.

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 implies when to use the tool by stating it deletes a bill attachment and names the required entity fields, but it does not explicitly contrast it with alternatives such as delete_bill, nor does it state when not to use it. Usage is inferable but not fully spelled out.

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

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

No annotations are provided, so the description carries the behavioral disclosure burden. It usefully adds that entity must carry both categoryId and userId, and identifies the endpoint. However, it does not disclose deletion consequences, reversibility, auth requirements, or error behavior, leaving some 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?

The description is a single concise sentence that front-loads the purpose, then adds the endpoint and required fields. Every element earns its place with no redundancy or 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 simple delete operation, the description provides the essential invocation requirements: what to delete, the endpoint, and the required entity fields. With no output schema, it reasonably omits return details, though it could further clarify side effects or failure modes.

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

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

The schema coverage is 100% at the entity-object level, but the schema only mentions categoryId. The description adds critical param semantics by requiring userId in addition to the primary key, which the agent could not infer from the schema alone.

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

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

The description states a specific action ('删除二级分类' / delete second-level category) and the exact resource, clearly distinguishing it from siblings like delete_parent_category. It also includes the HTTP endpoint for additional precision.

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 makes clear this tool is for deleting a second-level category, which provides clear usage context. It does not explicitly name alternatives or exclusion conditions, but the resource scope is unambiguous enough for an agent to select it appropriately.

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 of behavioral disclosure. It identifies a destructive mutation and references userId, but it does not state whether deletion is irreversible, whether related records are affected, what permissions are needed, or what the response looks like.

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

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

Two short sentences deliver the endpoint, the object type, and the required fields with no filler. The essential action is front-loaded and every sentence earns its place.

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

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

For a single-parameter delete operation, the description is minimal but adequate: it names the endpoint and the required entity fields. However, with no output schema and no annotations, the absence of response/error or side-effect information leaves the full call context incomplete.

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

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

The schema describes entity only as a lend object containing lendId, while the description adds meaningful information by requiring that entity also include userId. This requirement is not present in the schema description, so the description genuinely supplements the parameter semantics.

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

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

The description opens with a specific verb and resource ('删除借贷' / delete lend) and includes the endpoint POST /lend/deleteLend. This clearly identifies the operation and distinguishes it from sibling delete tools such as delete_reimbursement or delete_bill.

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 intended use is implied by the verb and resource, and the description states a prerequisite by requiring entity to include lendId and userId. However, it does not explicitly say when to prefer this tool over alternatives or mention any exclusions, so usage context is inferable rather than explicit.

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

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

With no annotations, the description carries the full burden of behavioral disclosure. It confirms a destructive action and states the HTTP method, but does not mention cascading effects on child categories, reversibility, soft-delete behavior, authentication requirements, or potential errors that would be important for a delete operation.

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

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

The description is one compact sentence that packs the action, endpoint, and required entity fields together with no filler. Every part earns its place, and the key information is front-loaded.

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

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

For a simple one-parameter delete tool, the description provides enough to construct the request: the endpoint and the required fields. However, it omits behavioral details such as whether the deletion cascades to child categories, what the response looks like, and any error or auth implications. It is minimally viable but not fully complete.

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

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

The schema only says the entity is a parent category object containing the primary key categoryId. The description adds the crucial requirement that userId must also be included, which is not discoverable from the schema. This extra detail is essential for correct invocation.

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 explicitly states the action ('删除一级分类') and includes the endpoint, making the tool's purpose unmistakable. It also distinguishes it from sibling tools like delete_child_category and delete_parent_category's counterpart save_parent_category.

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 makes the target resource clear ('一级分类') but does not explicitly state when to prefer this over alternatives, nor does it mention exclusions or prerequisites. Usage is implied by the name and category type, but no direct guidance is provided.

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 discloses that the operation is a delete (destructive) and requires userId, but it does not mention whether deletion is permanent, whether it cascades, whether authorization is required, or what happens if the refund is already deleted. The HTTP endpoint is useful but does not cover behavioral consequences.

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

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

The description is a single sentence with the endpoint and the key requirement. It is concise and front-loaded with the action. It could be slightly more structured, but it earns its place with no wasted words.

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

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

For a destructive delete tool with no annotations and no output schema, the description is thin. It does not explain the response, error cases, or whether the operation is reversible. The sibling list includes many delete tools, and this description does not help an agent distinguish when to pick delete_refund over delete_reimbursement or delete_bill. The required userId hint is useful but incomplete.

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

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

Schema description coverage is 100% for the single 'entity' parameter, and the schema already describes it as the refund object containing primary key refundId. The description adds that userId must also be carried in entity, which is not explicitly in the schema's propertyNames or description. This adds some value beyond the schema, but the schema already covers the main structure.

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 ('删除退款' = delete refund) and resource (refund), and includes the HTTP endpoint POST /refund/deleteRefund. It distinguishes from siblings like delete_reimbursement by naming the refund resource, though it doesn't explicitly contrast with sibling tools.

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

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

The description implies usage by stating the required fields (refundId and userId) but does not explicitly say when to use this tool versus alternatives like delete_reimbursement or save_refund. It provides the necessary precondition (entity must carry primary key and userId) but no context on when deletion is appropriate.

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

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

No annotations are provided, so the description carries the burden of behavioral disclosure. It correctly communicates that this is a delete operation via POST, but it does not mention permanence, soft-delete behavior, consequences, or error handling. Some transparency is present, but not full.

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, purposeful sentences: the first names the operation and endpoint, the second states the essential payload constraint. There is no redundant or filler 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 tool with one nested parameter, no annotations, and no output schema, the description covers the action, endpoint, and required fields well. It is slightly thin on postconditions/return behavior, but the essential calling information is present.

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

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

The schema only describes entity as an object containing reimbursementId, while the description adds that userId is also required. This is meaningful additional guidance for constructing the nested entity payload, going beyond the schema's sparse description.

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

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

The description states a specific action ('删除报销' / delete reimbursement) and the exact HTTP endpoint POST /reimbursement/deleteReimbursement. This clearly identifies the resource and operation, and it is distinguishable from siblings like save_reimbursement and delete_refund.

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 a clear precondition for use: entity must carry reimbursementId and userId. It does not explicitly list alternatives or when-not-to-use, but the intent and required payload are unambiguous.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses that this is a delete operation and names required fields, but does not say whether the action is permanent, cascading, or authorized, nor what the response/return behavior is.

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: the first states the action and endpoint, the second states the required fields. No filler or redundancy.

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

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

This is a simple one-parameter tool, and the description covers the essential input requirements. However, because there is no output schema and no annotations, a deletion tool should also provide some information about success/failure semantics or side effects.

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

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

The schema describes entity at a high level, but the description adds real semantic value by explicitly stating entity must carry tagId and userId. This is more than the schema's minimal object description implies.

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 explicitly names the operation (delete tag), the resource, and the endpoint POST /tag/deleteTag. It is clear and distinct from a hypothetical save_tag, though it doesn't explicitly differentiate itself from a sibling tool.

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

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

The description gives a concrete prerequisite: entity must contain tagId and userId. It implies the tool is for deleting tags, but it does not compare against siblings such as save_tag or state when not to use it.

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

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

No annotations are provided, so the description must carry the full behavioral disclosure burden. It indicates a delete action and required fields, but does not state irreversibility, cascading effects, authorization needs, or error behavior, leaving the destructive nature under-specified.

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 front-loads the operation and resource, then supplies the endpoint and required entity fields. There is no filler, repetition, or unnecessary detail.

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

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

The description provides the operation, endpoint, and required input fields, which is enough to attempt invocation. However, with no annotations and no output schema, it omits response/error semantics, post-conditions, and authentication context, so completeness is only adequate.

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 schemas only says 'entity' is an object containing transferId, but the description adds that entity must also carry userId, which is not present in the schema. This is valuable for a free-form nested object, although it does not specify value formats or types.

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 clearly states the operation ('删除转账' / delete transfer), the REST endpoint, and the resource being acted on. It is specific enough to distinguish from sibling tools like save_transfer or other delete_* tools, though it does not explicitly name an alternative.

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

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

No guidance is provided about when to use this tool versus alternatives. It mentions required fields but does not state prerequisites, exclusions, or cases where a sibling tool should be used instead.

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

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

No annotations are provided, so the description carries full burden. It discloses an API endpoint and implies a read-only operation, but doesn't state that it returns no data if no deletions exist, or any pagination/limits. Mutation behavior is not relevant here, but auth requirements are not mentioned.

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?

Single sentence is concise and front-loads the verb and resource. However, it includes the full path which is redundant with the schema, and could be shortened. No structure or headings.

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 query, description is borderline adequate. It doesn't mention the return payload (though no output schema exists), nor does it specify that user_id is optional (only book_id required). Given siblings like get_delete_history exist, and no annotations, it's missing guidance on exact parameter usage and return format.

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 covers 75% of parameters with descriptions (book_id, owner_id, last_sync_time). The description repeats the path but adds no meaning beyond the schema. user_id lacks a description but is inferable from the path. The description does not explain the relationship between last_sync_time and incremental sync.

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 clearly states the tool queries deletion history for account books, with a specific HTTP path. It distinguishes it from 'get_delete_history' but only by resource specificity, not by clear differentiation from siblings like 'get_book_last_time'.

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

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

No guidance on when to use this tool versus siblings. It doesn't mention synchronization contexts or when to call it (e.g., during sync_pull). The bare HTTP endpoint is given but no context on typical usage.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure. It does not state whether this is a read-only operation, whether authentication is required, what the response contains, or any side effects. The endpoint pattern suggests a GET request, but that is not explicitly disclosed.

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

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

The description is a single compact sentence that includes the purpose and the HTTP endpoint. It is front-loaded with the action and resource. It could be slightly more informative, but it is appropriately sized and not verbose.

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

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

For a tool with no annotations, no output schema, and only 50% parameter coverage, the description is too thin. It does not explain the return value, whether user_id is required in practice, or any behavioral context. An agent would need to guess at important details before invoking it.

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

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

Schema description coverage is 50%: book_id has a description ('账本 ID'), but user_id has none. The description's endpoint template shows both {userId} and {bookId} in the path, which adds some meaning for user_id, but it does not explain the relationship or optionality. This is adequate but not strong.

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: '查询账本成员' (query account book members), and includes the HTTP endpoint. It is clear enough to distinguish from siblings like get_book_bills or get_share_accounts, though it does not explicitly name a sibling alternative.

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

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

No guidance on when to use this tool versus alternatives. The description only provides the endpoint and a terse purpose; it does not mention context, prerequisites, or exclusions. An agent must infer usage from the name and endpoint 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 provided, the description carries the full burden. It does disclose the HTTP method (GET) and the default behavior for 'time' (0 = all), which implies a read operation. But it lacks explicit read-only statement, response format, pagination, or any note about authentication or side effects, leaving some behavioral uncertainty.

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

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

The description is a single compact sentence that front-loads the core action and resource, then provides the endpoint and parameter semantics. Every clause carries useful information and there is no filler or repetition.

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 tool with only two parameters and no output schema, the description covers the essential function and the time parameter. It is incomplete because it omits the user_id parameter, does not state return shape or any incremental behavior, and provides no fallback guidance, which an agent might need when calling without parameters.

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

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

The description adds meaningful detail for the 'time' parameter (start timestamp in ms, default 0 means full data), which the schema only describes minimally. However, it does not explain 'user_id' at all, leaving that parameter semantically empty. The schema coverage is exactly 50%, and the description compensates for one but not both parameters.

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 '查询' (query) and resource 'asset list', and includes the full endpoint path. It is clearly distinct from sibling write operations like save_asset and delete_asset, so an agent can tell this is a read-only listing tool just from the text.

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 purpose implies usage: when you need the asset list, use this. However, it provides no explicit when-to-use vs alternatives, no exclusions, and no mention of alternatives such as save_asset or delete_asset for mutations.

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 present, so the description carries the full burden of behavioral disclosure. It mentions 'GET' and '查询', which weakly imply a read-only operation, but it does not disclose authentication needs, possible failure modes, response format, or any side-effect guarantees.

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

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

The description is a single compact sentence that front-loads the purpose and includes the endpoint. There is no redundant or 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 one-parameter GET tool, the description is minimally adequate, but with no annotations, no output schema, and no usage guidance, it lacks important context such as return value, authentication expectations, and when to use it versus similar bill tools. More detail would meaningfully improve the definition.

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

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

The input schema has no description for user_id and schema coverage is 0%. The description's endpoint template {userId} hints that the parameter is a path parameter, but it does not clarify requiredness, expected format, or what value should be supplied.

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 clearly states a specific action ('查询' / query) and resource ('账单总数' / total bill count), and provides the exact HTTP endpoint. It is not a tautology, but it does not explicitly differentiate itself from sibling bill-related tools such as get_book_bills.

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 provides no guidance on when to use this tool versus alternatives, no mention of prerequisites or exclusions, and no context about suitable scenarios. An agent must infer usage solely from the name and endpoint.

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 does disclose the return structure ({Bill:[...], syncTime, hasMoreData}) and the pagination convention (page starts at 0, use hasMoreData). However, it does not explicitly state that this is a read-only operation, or mention any authentication requirements or side effects. The endpoint path suggests GET, but this is not stated.

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, well-structured sentence that leads with the core purpose, includes the endpoint, the return object, and the critical pagination rule. Every clause is necessary and there is no redundancy. Excellent front-loading.

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

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

Given there is no output schema, the description adequately explains the return values and pagination pattern. It covers the essential behavior for an agent to call the tool correctly. Minor omissions, such as error handling or authentication, are not critical for basic invocation. It is sufficiently complete for its 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?

The input schema has 100% description coverage, so the baseline is 3. The description adds the HTTP path and return format, but no additional meaning for the parameters themselves. It reinforces the page-start-at-0 convention and the default for user_id, but these are already present in the schema descriptions. Thus, no extra value 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 clearly states the tool's purpose: '分页查询账本账单' (paginated query of ledger bills). It includes the HTTP endpoint and explicitly differentiates this retrieval operation from the many sibling tools that save, delete, or modify bills. The verb, resource, and pagination scope 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?

The description implies when to use the tool (whenever you need a paginated list of bills for a ledger) via its clear purpose, but it does not explicitly state when not to use it or mention any alternatives (e.g., get_bill_count for counts, sync_pull for synchronization). No exclusion criteria or comparison to siblings is provided.

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 discloses the HTTP GET method and the millisecond timestamp result, implying a non-mutating read. However, it does not mention authentication requirements, behavior for a never-synced book, or explicit no-side-effect guarantees.

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 dense sentence that front-loads the core purpose, endpoint, timestamp unit, and usage intent. There is no filler or redundant 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 simple two-parameter read tool with no annotations and no output schema, the description is mostly adequate: it states what is returned and why it is useful. However, it is incomplete about the optional user_id semantics and edge cases, which an agent may need to handle correctly.

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

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

Schema description coverage is only 50%: book_id is documented but user_id is not. The description adds only the endpoint path hint showing both userId and bookId, but it does not clarify why user_id is optional or what it represents in the query. This leaves a meaningful gap for an agent trying to invoke the tool correctly.

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 read operation ('查询账本最后同步时间戳'), identifies the resource (the account book), gives the endpoint, and explains its purpose as an incremental sync cursor. This clearly distinguishes it from sibling sync-related tools like sync_pull or sync_start.

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

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

The description clearly indicates when to use the tool: to obtain the last sync timestamp for use as an incremental sync cursor. It does not explicitly name alternatives or state when not to use it, but the cursor hint provides enough context for an agent to route correctly.

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 of behavioral disclosure. It does not mention that the tool is a read-only GET operation (implied by the endpoint, but not stated), does not describe what the response contains or its format, and does not explain any side effects. The description is minimal and lacks behavioral transparency beyond the endpoint hint.

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, one short sentence with the key resource and endpoint mentioned. It is front-loaded with the action and resource. However, it could be slightly longer to cover usage guidance, but as is, it is efficient and free of fluff.

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 low complexity (one parameter) and no output schema, the description is still incomplete. It lacks explanation of the response structure and any behavioral context (e.g., read-only nature). An agent might know it's a query from the name, but without return format or usage conditions, it is not fully equipped to call correctly.

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

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

The schema has one parameter (user_id) with 0% coverage in the description. The description does not explain the parameter's meaning or format, but since there is only one simple string parameter, the description is not heavily burdened. The baseline of 3 is appropriate because the parameter is self-explanatory from its name, but the description adds no extra semantic 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 the verb '查询' (query) and the resource '分类信息' (category information), with an explicit endpoint. It distinguishes from siblings by indicating it fetches preset categories (图标/预设分类), which is specific enough to separate from category-modification tools like save_parent_category or delete_child_category.

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

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

No explicit guidance on when to use this tool versus alternatives. The description mentions the endpoint but does not explain when to use this over other category-related tools or any prerequisites (e.g., auth status). The context of 'icon/preset categories' implies its scope but leaves the agent to infer usage.

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

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

No annotations are provided, so the description carries the full behavioral disclosure burden. It does disclose the HTTP method GET and the path, implying a read-only operation. However, it does not mention authorization requirements, whether user_id is required, return value structure, 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?

The description is a single compact sentence with no filler. It front-loads the operation and efficiently encodes the endpoint, so every part earns its place.

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

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

For a simple one-parameter GET tool, this is minimally viable, but with no output schema the description should explain what '币种数据' actually includes and what the response looks like. It also lacks usage context to help an agent choose it among many sibling tools.

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

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

The schema has one user_id string with 0% description coverage, so the description must compensate. The endpoint path /currency/getCurrencyData/{userId} adds that user_id is used as a path parameter, which is beyond what the schema states. It does not clarify whether the parameter is required, its format, or its exact meaning.

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 '查询币种数据' (query currency data) and gives the exact GET endpoint, so the verb and resource are clear. It does not explicitly differentiate this tool from sibling get_* tools, but the resource is specific enough to avoid serious 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?

There is no guidance on when to use this tool versus alternatives such as auth_status, get_sts, or get_me. The only usage signal is the phrase 'query currency data', which is essentially implicit in the tool name and provides no decision support.

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 burden. It does disclose the operation is a GET/read and explains a notable behavior: time defaults to 0 for a full query. However, it does not mention authentication needs, response shape, pagination, or any side effects, which limits transparency.

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

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

The description is a single compact sentence. It front-loads the core purpose brief, includes the endpoint path, and immediately conveys the key default behavior without any 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 simple GET tool this is minimally adequate: it provides the endpoint and default behavior. But with no output schema and no annotations, it omits expected return contents and any usage context, so an agent may still need to infer what 'delete records' means in response.

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 50% (time is described, user_id is not). The description adds some value by explaining the endpoint parameters and the meaning of time=0 as full data, but it does not fully clarify user_id semantics beyond what its name suggests.

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

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

The description states a specific action ('查询删除记录') and resource, and adds the concrete HTTP endpoint for clarity. It does not explicitly differentiate from the sibling get_account_delete_history, but the user/time endpoint makes the target resource reasonably distinct.

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 about when to use this tool versus alternatives such as get_account_delete_history, nor any mention of prerequisites or exclusions. The only usage hint is the default behavior of 'time', which is more about semantics than tool selection.

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

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

With no annotations, the description must carry behavioral disclosure. It usefully warns that the response's top-level token will automatically refresh the JWT, a meaningful side effect. However, it is silent about required authentication, what happens when user_id is omitted, and whether the tool can fail or behave differently for invalid tokens.

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 purpose and endpoint, then adds the critical token-refresh behavior. There is no filler or redundant restatement of the schema.

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 tool with one optional parameter and no output schema, so the purpose, endpoint, and token-refresh side effect provide a mostly complete picture. Still, it would be slightly stronger with explicit statements about auth requirements and expected return 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?

Schema description coverage is 100%, so the schema already explains user_id. The description adds no additional semantic detail about the parameter, such as how the default configuration/login value is resolved when user_id is omitted.

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 operation and resource: query the current user's information, and backs it with an explicit endpoint (POST /user/getUserInfoById). This clearly differentiates it from the many sibling get_* tools, which target assets, bills, accounts, or STs.

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 prefer get_me over auth_status, get_sts, or other user/account-related tools. It also does not mention prerequisites such as login state or token requirements, leaving usage context to be inferred from the name and endpoint.

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 partially carries the behavioral burden: the GET method and 'query list' language imply a read-only operation that returns a list. However, it does not disclose authentication needs, pagination, error behavior, or empty-result semantics, so it is only moderately transparent.

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

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

The description is a single compact sentence that includes the purpose and the endpoint. There is no filler or redundancy, making it easy to parse quickly.

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 one-parameter GET tool, the endpoint and query intent are present. However, with no output schema and no parameter or usage elaboration, an agent still lacks details about the return shape and any preconditions. It is minimally adequate but leaves notable gaps.

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

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

Schema description coverage is 0%, so the description must compensate for the single user_id parameter. It only repeats the parameter as {userId} in the endpoint path, without clarifying whose user ID is expected, whether it can be omitted despite being non-required, or the expected format. The path hint provides limited guidance but not enough.

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 the shared account book list. It also names the exact endpoint, which reinforces the purpose. It does not explicitly differentiate from sibling tools like get_account_members, but the resource scope ('shared ledger list') is sufficiently specific.

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

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

No guidance is provided on when to use this tool versus alternatives, and no exclusions or prerequisites are mentioned. Sibling tools such as get_book_bills or get_account_members are not referenced, leaving an agent to infer the appropriate 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?

Without annotations, the description carries the full burden, and it does disclose the HTTP method, the endpoint, and that the raw response body is returned. This gives meaningful behavioral hints, but it omits authentication requirements, failure behavior, and any special handling of the response.

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

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

The description is a single compact sentence with no filler; it presents the action, endpoint, and response behavior efficiently. Every part earns its place.

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

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

For a tool with no annotations and no output schema, this is too sparse. The agent cannot confidently distinguish it from get_sts_no_verify, does not learn the meaning of user_id beyond a path placeholder, and has no guidance on when the raw body should be expected or how to handle it.

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

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

Schema coverage is 0%, so the description must compensate, but it only shows userId appearing in the URL path. It does not explain what user_id represents, its format, or that it is effectively required despite not being listed as required in 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 clearly states the tool retrieves temporary credentials for object storage and gives the exact endpoint. However, it does not explicitly distinguish itself from the sibling get_sts_no_verify, so some differentiation burden is left to the agent.

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 usage context is given; there is no statement about when to use this tool versus get_sts_no_verify or other auth-related tools. The description only records the API call, leaving the agent to infer eligibility and preconditions.

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

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

With no annotations provided, the description carries the full burden. It discloses that the call uses GET, requires no authentication, and returns the raw response body – all useful behavioral traits. However, it does not mention any side effects, error behavior, or whether it is read-only beyond the implied GET semantics, leaving some 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?

The entire description is a single, tight sentence that leads with the purpose, then adds the distinguishing attribute (免鉴权), the endpoint, and the response format. There is no fluff or repetition, and every clause carries meaning.

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

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

For a simple, parameterless tool with no output schema, the description covers the essentials: what it fetches, that it's the no-auth variant, the exact HTTP path, and that the response is raw. It does not elaborate on when to prefer this over get_sts, but the phrase '免鉴权变体' provides sufficient context 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?

The tool has zero parameters, so the schema is trivially complete (100% coverage). Per the rubric, 0 parameters warrants a baseline of 4. The description adds no parameter information because none is needed, so it fully satisfies the requirement.

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

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

The description states a specific action ('获取对象存储临时凭证' – get object storage temporary credentials) and resource, and explicitly identifies it as a no-authentication variant, distinguishing it from the sibling get_sts. It also names the exact endpoint and response format, leaving no ambiguity about what the tool does.

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 provides clear context by labeling the tool as a '免鉴权变体' (no-auth variant), which implies when to use it (when authentication is not needed). However, it does not explicitly name get_sts as the alternative or state the condition for choosing one over the other, so it stops short of full explicit guidance.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It discloses the AES-128-ECB encryption scheme, the return of a user object and JWT, the env-var fallback, and the '未配置则报错' failure mode. It could additionally clarify session-related side effects, but the core behavior is well covered.

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

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

The description is compact and front-loaded: purpose, encryption, return value, default behavior, error case, and security guidance are all conveyed in four short sentences. There is no filler or redundancy.

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

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

Given zero required parameters, no output schema, and no annotations, the description provides enough operational detail for a correct invocation: encryption, defaults, output, and error handling. It is slightly incomplete in not describing the returned user-object structure or any authentication-session side effects, but these are not necessary to call the tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds tool-level meaning by explaining the password encryption method and the environment variable fallback behavior, providing context beyond the individual parameter descriptions.

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 clearly identifies the operation as '邮箱密码登录' (email/password login) and specifies its output: '返回用户对象与 JWT'. It also distinguishes this tool from QR-code login siblings by explicitly presenting it as the email/password login path.

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 advises '请优先使用扫码登录（更安全）', pointing the agent to the QR alternative and indicating a preference. It also explains the env-var fallback and error behavior, but it does not fully state the conditional context in which email/password login should be chosen over QR.

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 present, the description carries the behavioral disclosure burden. It discloses the polling cadence, timeout semantics, success response shape, and the side effect that JWT is saved automatically. It does not describe failure/timeout return behavior, which is a minor but notable gap.

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

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

The description is compact and front-loaded with the core action and auth requirement. It packs the essential behavioral details into two short sentences without redundancy or 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 polling tool with no output schema, the description covers the essential flow: poll interval, timeout behavior, success response, and JWT side effect. It is missing explicit handling for timeout expiry or error statuses, but the provided information is sufficient for most agent usage.

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. The description adds value beyond the schema by explaining the polling interval, the meaning of timeout=0, and that a successful scan returns a user object with the JWT auto-saved. This extra context helps the agent reason about parameter behavior.

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

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

The description states a specific action ('等待/轮询扫码登录结果') and the target resource (QR login result), and clarifies authentication is not required. It clearly distinguishes itself from sibling tools like login_qr_start and login_qr_recognize by focusing on polling the login result.

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 clear usage context: it polls every 3 seconds within a timeout, and timeout=0 means a single check. It implicitly tells the agent when to use it via the session_id parameter referencing login_qr_start, but it does not explicitly state when not to use it or name 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?

With no annotations, the description carries the full burden. It discloses that the operation requires no authentication, returns QR text and session_id, and is intended for validation of login_qr_start output. It does not cover failure behavior or edge cases, but for a simple read-only recognition utility the disclosed behavior is reasonably complete.

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

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

The description is a single compact sentence that front-loads the core purpose, then covers output and use case. Every clause contributes useful information, with no wasted words.

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

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

For a single-parameter tool with no output schema, the description explains the input, the output fields, the authentication requirement, and the intended use case. It is complete enough for an agent to call it correctly, though exact response structure is not specified.

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

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

Schema description coverage is 100%, and the only parameter image_path is described as a PNG QR code file path. The tool description adds no additional parameter semantics beyond the schema, so the baseline of 3 applies.

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

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

The description clearly states a specific verb and resource: recognizing QR code content from a PNG image. It also names its output (QR text and session_id) and its intended role (verifying login_qr_start-generated QR files), which distinguishes it from sibling authentication tools.

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

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

The description provides clear context: it is for testing/auto-login chain verification and requires no authentication. It even names login_qr_start as the source of the QR file to validate. It does not explicitly state when not to use it or list alternatives, so it falls just 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?

With no annotations provided, the description carries full behavioral disclosure burden. It richly describes the output (image block, terminal QR, file path, stderr), the 2-minute expiry, and the app scanning step, which is far more than typical. It does not detail error conditions or session lifecycle side effects, but it covers the essential behavior well.

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 lengthy but highly structured with numbered points, front-loading the core purpose and then detailing the various output formats. Each sentence earns its place, and the structure aids readability. It could be slightly condensed without loss, but it is not wasteful.

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

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

Given the absence of an output schema, the description compensates by fully enumerating return values (session_id, qr_payload, image variants, path), the intended flow (scan then poll), and time constraint. It is almost complete for a login initiation tool, though it does not mention failure behaviors or cleanup, which are minor for this context.

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

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

The tool has zero parameters, so the schema is empty and there is nothing to explain. The description instead focuses on outputs and flow, so the baseline of 4 is appropriate. It does not add parameter-specific info because none exist.

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

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

The description clearly states the tool creates a QR login session without authentication, specifies the returned elements (session_id, qr_payload, QR code image), and differentiates from related siblings like login_qr_poll by explicitly mentioning the post-scan polling step. The verb-resource pairing is specific and unambiguous.

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

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

It provides clear context for when to use (免鉴权) and explicitly directs the agent to call login_qr_poll after scanning, effectively distinguishing this from other login methods. However, it does not explicitly state when not to use it or mention alternatives like login_email or login_qr_recognize, though the flow is implied.

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

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

With no annotations, the description must carry the behavioral burden. It discloses the HTTP GET method and that the tool returns structured data, implying a non-destructive read, but it does not mention authentication, error cases, or response 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?

A single front-loaded sentence states the action, endpoint, and result with no redundant words; the raw-text example is already in the schema and not 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?

The tool is simple and the description covers action, input, and endpoint, but without an output schema it leaves 'structured bill information' vague, and no usage or error context is provided.

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 50%: text is documented, user_id is not. The description's endpoint path at least exposes the existence of userId and links text to raw input, but it does not explain user_id semantics or compensate fully 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?

The description uses a specific verb ('解析'/parse) and resource (raw bookkeeping text), names the exact GET endpoint, and states the output (structured bill info). This clearly differentiates it from save_bill and other sibling write tools.

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

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

The description implies the tool is for converting raw text into structured bill data, but it does not state when to choose it over alternatives (e.g., save_bill/save_bills) or mention any prerequisites/exclusions.

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

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

No annotations are provided, so the description bears the full burden of behavioral disclosure. It does reveal the mutating/upsert nature, but leaves key behaviors unclear: whether updates are partial or full replacement, what happens with missing fields, authorization needs, or irreversible side effects. The phrase '字段按服务端契约传递' is vague and does not clarify server-side expectations.

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

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

The description is compact, front-loads the core action, and organizes the field list efficiently. It does not waste words, though the final clause '字段按服务端契约传递' adds little information and could be replaced with more concrete details.

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 has no annotations, no output schema, and a dynamic nested entity object, the description supplies the endpoint, upsert semantics, and field names, which is a reasonable foundation. However, it omits field types, required fields for create vs update, response expectations, and error conditions. For a mutation tool, this is a moderate gap that could leave an agent uncertain about constructing a valid entity.

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

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

The schema only documents 'entity' as an object with no nested properties, so the description adds real value by listing the meaningful fields: accountBookId, bookName, bookType, and shareUsers, along with semantic labels. It identifies accountBookId as the primary key, which is essential for the upsert behavior. It still lacks types and required status, but the field enumeration substantially improves schema interpretation.

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 clearly states the tool creates or updates an account book ('新增或更新账本'), identifies the endpoint, and explains the upsert behavior. It does not explicitly differentiate from sibling tools like save_bill or delete_account_book, but the resource type '账本' is distinct and 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 provides an implicit usage condition: supply accountBookId to update, omit it to create. However, it does not state when to prefer this tool over alternatives (e.g., save_bill, save_asset) or mention any prerequisites like authentication or ownership. The upsert rule is useful but only covers one aspect of usage.

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 discloses the mutation behavior (upsert), the HTTP endpoint, and that userId/updateTime are automatically filled, which goes beyond the input schema. It does not mention authentication or response details, but the core behavioral traits are visible.

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 dense sentence that front-loads the operation and endpoint before listing fields. The field list is necessary and not padded with filler. Slight structure loss from the run-on format, but it is efficient and information-dense.

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 no output schema and no annotations, the description covers the endpoint, upsert behavior, update-vs-insert detection, and complete field semantics, which is enough for an agent to construct a valid call. It omits the response/return shape and auth context, which would be needed for full completeness, but the main invocation requirements are satisfied.

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

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

The input schema only describes entity as an object, providing no property-level details. The description compensates richly by naming assetId as primary key, explaining each field's business meaning, marking optional fields, and noting which fields are auto-populated. This is a substantial addition 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 clearly states the tool's action: 新增或更新资产 (add or update an asset), specifies the endpoint POST /asset/addOrUpdateAsset, and explains upsert semantics with the primary key determining update. This makes it easy to distinguish from sibling tools like delete_asset, get_assets, and save_asset_history.

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 a concrete rule: if the entity carries the primary key assetId, the operation updates; otherwise it creates. It also enumerates the asset fields so an agent knows what kind of object to pass. It does not explicitly name alternatives or exclusion conditions, but the usage context is clear enough.

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 burden. It discloses the upsert semantics (带主键为更新) and mutating nature via 新增或更新, but does not mention auth requirements, idempotency details, error cases, or response behavior. The core write behavior is transparent, but additional context is limited.

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 dense sentence with endpoint and field list; every part carries information. The field definitions are packed compactly, though the lack of natural-language formatting slightly reduces 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?

For an upsert tool with one nested object and no output schema, the description covers the essential behavior and key fields. However, it omits details like whether the field names are camelCase or Chinese semantic keys, required vs optional subfields, and any constraints on values. Given the open additionalProperties schema, the description could be more complete for error-free 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 100% with a single entity object, and the description adds meaning by listing the meaningful fields inside entity: assetHistoryId primary key, assetId account, time, currentNum balance after change, changeNum change amount, changeContent description. This goes beyond the generic '资产变动记录对象' in the schema and compensates for the schema's additionalProperties being open.

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?

Description clearly states the operation (新增或更新, i.e., create-or-update upsert) and the exact endpoint /assetHistory/addOrUpdateAssetHistory. It further distinguishes update behavior by presence of primary key, so an agent knows what the tool does at a glance.

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 when update vs insert occurs via the primary key presence, and identifies the resource. It does not explicitly say when to prefer save_asset_history over delete_asset_history or save_asset, but for a single-entity upsert tool this is reasonably clear 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?

The description discloses several behavioral traits: automatic normalization of tags to JSON string, defaulting recordTime to updateTime/current time, and regenerating billId if it exceeds int32. These go beyond what annotations (none provided) offer. It does not cover error handling or side effects, but the disclosed behaviors are valuable. Since annotations are absent, the description carries the burden and does a good job.

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 comprehensive but dense. It front-loads the core purpose (add/update) and the normalization behaviors, then lists all fields in a compact paragraph. It is not overly long for the complexity of the bill object, but the field listing could be more structured (e.g., bullet points) to improve readability. It earns each sentence by providing essential 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?

Given the tool's complexity (many nested fields, auto-normalization rules), the description covers the essential information: how to distinguish update vs. add, automatic behaviors, and a full field breakdown. It lacks output return details, but there is no output schema, and the caller likely needs to know the operation succeeded; that is a minor gap. Overall, it is sufficiently complete for an agent to invoke it correctly.

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

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

The input schema has 100% description coverage, as it says '账单对象，见描述字段说明' (bill object, see field descriptions in the description). The description elaborates extensively on each field of the bill object, adding meaning beyond the minimal schema. Since schema_coverage is high, baseline is 3, and the description does provide value, but it doesn't significantly exceed the baseline because the schema already points to it.

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

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

The description clearly states the tool's purpose: creating or updating a bill via an upsert endpoint, with explicit details on how the addition/update is differentiated (presence of billId). It distinguishes from sibling tools like save_bills and delete_bill by specifying the single-bill upsert operation. The verb and resource are clear, though it doesn't explicitly name siblings, the API path and behavior make the purpose 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 implies usage: use this tool when you need to add or update a single bill, as opposed to save_bills for batch operations or delete_bill for deletion. It provides the condition for update vs. add (billId presence). It doesn't explicitly state when not to use it or name alternatives, but the context is clear enough for an agent to infer the appropriate tool.

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

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

No annotations are provided, so the description carries the full burden. It discloses the HTTP method, endpoint, upsert behavior, and the condition that determines update vs. add. It does not mention return values or permissions, but the core behavioral traits are transparent.

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 entire definition is one compact sentence with a parenthetical endpoint and a semicolon-separated field list. Every part earns its place, the action is front-loaded, and there is 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 tool with one nested object parameter and no output schema, the description covers the operation, endpoint, upsert logic, and all known entity fields. It lacks explicit return-format and required-field details, but these are minor for this simple upsert 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?

The schema only describes 'entity' as '账单附件对象', while the description enumerates all meaningful subfields: fileId as primary key, billId, remotePath, fileName, fileSize, and the optional transferId/lendId. This adds substantial value 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?

Description opens with '新增或更新账单附件' (add or update bill attachment), naming a specific verb and resource, and gives the exact endpoint. It further clarifies the upsert semantics with '带主键为更新', so an agent can tell it apart from sibling tools like save_bill or delete_bill_file.

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 provides clear context: use this tool to add or update a bill attachment, and include the primary key to trigger an update instead of an insert. It does not explicitly name alternatives or exclusion conditions, so it falls 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?

No annotations are present, so the description carries the full burden. It does disclose the upsert semantics (update when primary key is present) and a caveat about 'no snapshot data', but it does not clarify what happens to existing data in an update, whether updates are partial or full replacements, or any permission requirements. For a mutation tool, this is a significant gap; the agent is left uncertain about the tool's side effects beyond the basic upsert hint.

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 concise—two short sentences that front-load the main action, endpoint, upsert condition, and the key note about the entity field. Every sentence adds value, and there is no redundant or filler content. It is well-structured for quick agent consumption.

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 has one free-form object parameter, no output schema, and no annotations, the description should provide enough guidance to call it correctly. It mentions the endpoint and upsert behavior, but it does not explain the required structure of the billImport record or what the server contract expects. The agent would likely need external knowledge about the API contract, leaving the description incomplete for safe and correct invocation.

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

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

Schema coverage is 100% since the entity parameter has a description ('bill import record object'). The tool description adds meaningful context beyond the schema by explaining that the entity is the billImport record, that no snapshot data should be included, and that it should be passed per the server contract. This helps the agent understand the intent of the free-form object even though the schema itself is generic.

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 clearly states the action 'add or update bill import record' with a specific resource (bill import) and the upsert behavior based on primary key presence. It distinguishes this tool from siblings like save_bill and save_bills by focusing on the import record domain, leaving no ambiguity about what resource it acts on.

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

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

The description provides no explicit guidance on when to use this tool instead of alternatives like save_bill or save_bills. It implies usage through the 'bill import' context, but there is no stated exclusions, prerequisites, or comparisons. The agent must infer when to select this tool based solely on the name and resource type.

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?

在没有任何注解的情况下，描述主动披露了自动分批、每批 updateTime 递增、与网页端一致等超出 schema 的行为，这对批量写入工具很有价值。但它未说明鉴权要求、返回内容、部分批次失败后的行为或整体原子性，对于写入类工具仍有明显缺口。

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

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

两句话内依次交代了动作、端点、分批行为、updateTime 语义和字段参照，信息密度高，没有冗余或装饰性内容，结构紧凑且关键信息前置。

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?

描述覆盖了核心调用信息：端点、批量语义、批次大小、时间戳策略和字段来源，足以支撑基本调用。但没有输出 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 中 bills 参数只是泛化的对象数组，字段结构依赖描述中的“bill 字段同 save_bill”补全，这为调用者提供了比 schema 更具体的参数含义。虽然需要查阅 save_bill 才能获得完整字段列表，但已有明确指引，价值高于单纯重复 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?

描述以明确的动词和资源开头：“批量新增/更新账单”，并附带具体端点 POST /bill/addOrUpdateBillList。通过“bill 字段同 save_bill”与单条保存工具形成区分，使工具的功能边界清晰，不会与 save_bill 等兄弟工具混淆。

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?

“批量”和“自动按 100 条分批”清晰传达了该工具适用于多条账单提交场景，并借用 save_bill 提示字段一致性。虽然没有显式写出“单条请用 save_bill”这样的排除条件，但使用场景已经足够清楚。

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 of behavioral disclosure. It clearly exposes the mutating nature via '新增或更新', the POST method, and the upsert behavior where a primary key triggers an update. It does not mention response details or validation effects, but the core side-effect is well disclosed.

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

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

The description is compact and efficient: one sentence states the operation, endpoint, and upsert behavior, and the second lists the data fields. Every sentence contributes useful information with no filler or redundancy.

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

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

Given the extremely thin schema and lack of annotations, the description compensates well by defining the upsert semantics and the entity field meanings. It is sufficient for an agent to understand how to structure a call, though it omits explicit constraints or value formats for fields like hide and categoryType.

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

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

The schema only defines entity as a generic object with no properties, so the description provides essential semantics by enumerating all meaningful fields: categoryId, categoryName, iconUrl, parentCategoryId, positionWeight, hide, and categoryType. This is high-value information that the input schema alone completely lacks.

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 clearly states a specific operation: creating or updating a second-level category, with the exact HTTP endpoint and upsert semantics. This makes it easily distinguishable from sibling tools like save_parent_category and delete_child_category.

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 implies when to use the tool: any time a child category needs to be added or updated, and the upsert note clarifies whether the operation will insert or update based on presence of categoryId. It does not explicitly say when not to use it or name alternatives, so it stops short of full guidance.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It explicitly mentions 'upsert：带主键为更新' (upsert: with primary key it's an update), which is a crucial behavioral trait beyond the schema. However, it does not disclose side effects like validation errors, required auth, or return value behavior, but the core mutation behavior is covered.

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

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

The description is compact and front-loaded with the key action and upsert behavior, then lists the entity fields in a structured way. It is slightly dense with punctuation but every part contributes; the field listing is necessary given the nested object. No wasted sentences.

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 has a nested object parameter, no annotations, and no output schema, the description provides exhaustive detail on all entity fields, upsert behavior, and endpoint. An agent can construct a valid request without needing to open the schema or guess field meanings. The only gap is response format, but with no output schema, and the focus on mutation, this is acceptable.

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

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

The schema has 100% coverage but only describes 'entity' as '借贷对象' (lend object). The description goes far beyond by enumerating each sub-field with its meaning, such as 'number 金额' (amount), 'type 类型（借出/借入）' (type: lend or borrow), and clarifying primary key semantics. This significantly adds meaning that the generic schema does not 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 clearly states a specific verb '新增或更新' (add or update) on a specific resource '借贷' (lend), and even names the underlying HTTP endpoint and upsert behavior. It distinguishes itself from sibling 'delete_lend' by focusing on create/update, and lists all relevant entity fields, making its purpose unmistakable.

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 clarifies that it performs an upsert with primary key detection, which is a critical usage condition, but it does not explicitly state when to prefer this over other save tools like 'save_bill' or 'save_transfer' — although the context of lend-specific fields makes this clear. It gives no explicit exclusions or prerequisites, but the upsert explanation is a strong usage guideline.

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 burden. It discloses the upsert behavior (with primary key = update), which is a key behavioral trait. It also lists the entity fields, giving some transparency about what data is used. However, it doesn't mention whether the operation is destructive, requires authentication, or what happens on failure. The upsert disclosure is valuable but incomplete.

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

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

The description is compact and front-loaded with the core purpose and endpoint. The field list is dense but useful. It could be slightly more structured (e.g., separating the field list from the behavior), but it's efficient and every sentence earns its place.

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

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

For a single-parameter tool with no output schema, the description covers the main purpose, the endpoint, upsert behavior, and the entity fields. However, it lacks details on field semantics (e.g., what 'hide' means, valid categoryType values), required sub-fields, and any side effects. Given the tool's simplicity, this is adequate but not 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% for the single parameter 'entity', which is described as '一级分类对象' (parent category object). The description adds meaning by enumerating the entity's fields (categoryId, categoryName, iconUrl, positionWeight, hide, categoryType), which is helpful since the schema's entity is loosely defined with additionalProperties. However, it doesn't explain the semantics of each field (e.g., what 'hide' does, what categoryType values are valid), so it adds moderate value 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 clearly states the tool's purpose: creating or updating a top-level category (一级分类), and explicitly mentions the underlying endpoint and upsert behavior. It distinguishes itself from sibling tools like save_child_category and delete_parent_category by specifying it handles parent categories. However, it doesn't explicitly name those siblings, so it gets a 4 rather than 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 implies usage: use this tool when you need to add or update a parent category, and the upsert note (with primary key for update) gives a clear condition for update vs create. However, it doesn't explicitly state when NOT to use it or mention alternatives like save_child_category. The context is adequate but not fully explicit.

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

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

With no annotations, the description carries the full disclosure burden. It does well by revealing that the tool is an upsert, that the HTTP method is POST, that providing the primary key makes it an update, and that refundInfos is JSON. It stops short of stating required fields for creation or behavior on invalid input, but the core write behavior is transparent.

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 fits into one compact sentence that front-loads the action, then supplies endpoint, upsert rule, and the critical entity fields in order. Every clause earns its place; there is no filler or repetition of the title.

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

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

It covers endpoint, entity fields, and the primary-key behavior, which is a solid baseline for an upsert tool. However, it leaves an agent to infer how to construct a valid create payload, what fields are required, and what shape refundInfos must take; there is also no output/return information and no annotations to fill those 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?

The schema only describes the entity as '退款对象', so the description adds real value by enumerating the meaningful fields inside it: refundId (primary key), billId, refundNum, and refundInfos. This is field-level semantics the schema alone does not provide, though it leaves the internal shape of refundInfos unspecified.

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 leads with a specific action, '新增或更新退款' (create or update refund), and anchors it to a concrete endpoint, POST /refund/addOrUpdateRefund. It also clarifies the upsert semantics, which distinguishes it from sibling tools like delete_refund and save_reimbursement 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?

The description gives clear context for when to call it: use it to create or update a refund, and choose the mode by whether refundId is present ('带主键为更新'). It does not explicitly name alternatives or exclusion conditions, but the resource-specific verb and endpoint make the intended scenario 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?

With no annotations provided, the description carries the full disclosure burden. It does disclose meaningful behavioral traits: the create-or-update mutation semantics, that 'reimbursement 无快照数据' (reimbursement has no snapshot data), and that the payload must follow a server-side contract. However, it omits return values, auth prerequisites, and error behavior — information an agent needs to safely predict the outcome of a mutation.

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 dense sentences with no filler: the first front-loads the operation, endpoint, and upsert rule; the second covers payload requirements. Every clause earns its place, and the most important information (what the tool does) appears first.

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 description covers the essentials for invocation — payload shape and upsert semantics — which is critical given the effectively empty entity schema. However, with no annotations and no output schema, it leaves return-value behavior and error handling completely unspecified, so an agent cannot fully predict the result of the call or handle failure cases.

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?

Although schema coverage is nominally 100%, the entity parameter is an open object (additionalProperties: {} with zero property definitions), so the schema itself conveys almost nothing about the payload structure. The description compensates by explicitly listing the fields to include (billId/remark/amount and userId) and warning that the object has no snapshot data — genuinely additive 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?

The description opens with '新增或更新报销' (create or update reimbursement), a specific verb+resource pair, then reinforces it with the exact endpoint 'POST /reimbursement/addOrUpdateReimbursement' and the upsert rule ('带主键为更新'). This makes the tool's function unambiguous and clearly separates it from delete_reimbursement and the other save_* siblings that operate on different resources.

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

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

The description gives concrete usage conditions: the upsert rule ('带主键为更新' — including a primary key means update) tells an agent exactly how to invoke it for both create and update modes, and it specifies which payload fields to carry. It doesn't explicitly name alternative tools or state when not to use it, but the resource-specific semantics plus the upsert clarity provide solid invocation 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?

With no annotations, the description carries the behavioral burden. It discloses the HTTP method, upsert behavior, and that tag field has no snapshot data. It does not mention return values, error behavior, authentication needs, or that an update overwrites existing data.

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

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

The description is one dense but purposeful sentence: it front-loads the operation and endpoint, then gives the required payload details. No filler words are present, though the long clause structure slightly reduces skimmability.

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 and no output schema, the description covers the essential call requirements but leaves several operational unknowns: the exact shape of the server contract, expected response, and error cases. It is sufficient to make a plausible call but not fully self-contained.

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

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

The schema only describes entity as '标签对象', so the description adds crucial meaning by naming required subfields and the 'no snapshot data' constraint. It also explains that remaining fields follow the server contract, which helps agents construct the payload despite the schema being an open object.

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 clearly states the action '新增或更新标签' (add or update tag), names the concrete POST endpoint, and defines the upsert semantics. It is immediately distinguishable from siblings like delete_tag and save_bill because the resource and verb are explicit.

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

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

It explains when update occurs ('带主键为更新') versus insert, and specifies required fields ('至少携带 tagId/tagName 与 userId'). However, it does not explicitly mention when not to use this tool or name alternative tools such as delete_tag.

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 burden. It discloses the HTTP method (POST), the endpoint, and the upsert semantics. It does not describe side effects like whether existing records are overwritten, whether related bill/asset data changes, or error conditions, but the upsert note adds some transparency.

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

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

The description is compact and packed with useful field mappings. It is a bit dense but front-loaded with the main action and endpoint. The inline field list is efficient for a tool with a nested object parameter.

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

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

The description covers the main purpose and the entity fields, but given the tool has no output schema and no annotations, an agent might need more information about required vs optional entity fields and response behavior. The core callable behavior is covered reasonably.

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% for the only parameter 'entity', but the schema only says '转账对象' (transfer object) with additionalProperties allowed. The description compensates by listing the key fields of entity (transferId, cost, serviceCharge, time, fromAssetId/toAssetId, toCost, billId, remark), which adds 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?

The description states a clear verb ('新增或更新转账' = create or update transfer) and resource, and gives the endpoint. However, it doesn't distinguish itself from the sibling tool 'delete_transfer' or other save tools explicitly, though the meaning is understandable.

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 indicates an upsert behavior (带主键为更新 = with primary key means update), which implies when to use it for create vs update. It does not provide explicit exclusions or alternatives, but the upsert mechanism gives some usage 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?

With no annotations, the description carries full behavioral burden. It usefully discloses that no authentication is required and specifies the HTTP method. It does not describe side effects, error behavior when no session exists, or idempotency, but the action is simple enough that the gap is moderate.

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 conveys the action, endpoint, HTTP method, and authentication requirement with no filler. Every piece of information earns its place.

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

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

For a one-parameter tool this is mostly complete: it gives the endpoint and auth contextmag. But it does not clarify whether session_id is effectively required despite schema marking it optional, and it omits any expectation about response or failure 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?

The schema already documents session_id as 'sync_start 返回的 sessionId' with 100% coverage publication. The description adds the query-string representation but little semantic value beyond that. 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 action ('结束同步限流会话') and resource ('限流会话'), and includes the exact endpoint path. It clearly identifies the tool's function, though it does not explicitly contrast with sibling tools like sync_start or sync_pull.

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 implies this tool is the counterpart to sync_start by referring to a rate-limit session, and the schema's reference to 'sync_start 返回的 sessionId' reinforces that. However, it never explicitly states when to call it or how it relates to other sync 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 are absent, so the description carries the burden. It discloses the return format (returns {syncTime, ...} entity lists), the meaning of time (0=full), and the data size warning. It doesn't mention authentication requirements (likely covered by siblings like auth_status) or pagination details, but given the output schema is absent, this description provides substantial behavioral context, earning a high score.

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 sentences, front-loads the core purpose and endpoint, and packs essential details like time semantics, default behavior, and a recommendation for cursor retrieval without fluff. Every sentence earns its place.

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

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

Given the tool's complexity (a sync operation with multiple entity types), the absence of an output schema, and the 2-parameter schema, the description covers all essential aspects: purpose, endpoint, response structure, parameter behavior, and use-case advice. It is complete enough for an agent to invoke the tool correctly.

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

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

Schema coverage is 50%: time is documented in schema, but user_id is not. The description doesn't add details on user_id format or usage, but it does explain time semantics (0=full) beyond the schema's '0=full' hint, which is marginal. Since time is well-covered, a baseline of 3 is appropriate, but the description could have compensated for user_id's lack of 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?

The description clearly states the tool's purpose: incremental pull of all business data via a specific API endpoint, with a verb (sync/pull), resource (business data), and the distinction from full sync via time parameter. This makes it distinguishable from siblings like sync_start/sync_end without needing schema inspection.

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?

Explicitly states when to use it: for new sync, first call get_book_last_time or get_me to get the cursor, and warns about full sync data size affecting output limits. This guides the agent on prerequisites and alternatives, making it extremely 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?

No annotations are provided, so the description must carry the full burden. It discloses that the endpoint is免鉴权 (no authentication required), which is useful, and that the tool must be paired with sync_end to avoid triggering rate limits. However, it doesn't describe the lifecycle in detail (what happens if sync_end is never called) or the exact side effects beyond returning a sessionId. This is adequate but not rich.

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

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

The description is compact and front-loaded: it leads with the primary action and endpoint, then critical usage guidance, then a brief return hint. Every sentence contributes value, with no fluff. The structure is optimal for a no-param tool.

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

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

Given the tool has no parameters and no output schema, the description covers the essential context: endpoint, auth requirement, usage sequence, and return shape. The only minor gap is that it could mention error conditions or what happens if sync_start is called again without sync_end, but for an agent the core information is present.

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

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

With zero parameters in the schema stub (full coverage implicitly, as there are no params to document), the description correctly focuses on the tool's behavior and output. It mentions the return payload contains {syncCount, sessionId}, which is a form of parameter/return clarification beyond the schema. Since there are no parameters, the baseline for parameter semantics is high (4).

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 clearly states the tool's purpose in Chinese: '开始同步限流会话' (start sync rate-limit session), specifies the exact endpoint (POST /bookkeeping/rateLimit/sync/start), and positions it as a prerequisite for batch write operations. This distinguishes it from the sibling 'sync_end' which is the matching teardown call.

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 provides explicit usage guidance: it names the exact scenario (batch write operations), instructs to call this tool before batch writes, and mandates calling 'sync_end' afterward to release the session and avoid rate limiting. It could name a specific alternative, but the pairing with 'sync_end' acts as an implicit alternative and the when-to-use is clear.

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