JiZhiMCP · China MCP Gateway

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

The description clearly portrays a write: it records an attestation, persists it, and returns an immutable hash plus a record_id and created_at timestamp. However, the annotations declare readOnlyHint=true, which conflicts with what the description says the tool does. The description is otherwise rich (immutability, UTC timestamps, example payload), so it is not a total void, but the contradiction with the structured safety hint is the dominant issue.

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

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

It is front-loaded with purpose, then when-to-use, then parameters, then return values, then a JSON example, so it reads well. The parameter recap duplicates the 100%-covered schema, so a little space could be reclaimed.

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

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

With no output schema, the description usefully enumerates the returned fields (record_id, digest, created_at UTC) and supplies a complete example call. It does not cover idempotency, error behavior, or how the digest is computed over the fields, which leaves minor gaps for a persistence 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 schema already documents all four parameters including which are optional. The description restates them (actor, action, target optional, detail optional) with the same glosses plus a worked example, which adds only marginal value beyond the structured fields.

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

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

The description states a specific verb and resource: recording a cross-Agent invocation attestation and returning a tamper-proof SHA-256 content hash. The purpose is unambiguous, but it never differentiates itself from the nearby metering.record sibling, even though both relate to cross-Agent settlement accounting, so an agent has to guess which one to use.

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 names concrete invocation contexts: when you need to prove which Agent did what to which resource and when, or to leave an audit trail before cross-Agent task settlement. It gives no explicit exclusions and never names metering.record as the alternative, so the boundary with that sibling 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered and the description only adds that rates are 'latest or for a given date'. It does not disclose the rate source, rounding or precision behaviour, or whether historic lookups can fail for unsupported dates/currencies.

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

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

The definition is one compact sentence plus an example, with the core operation front-loaded. The inline example duplicates the schema's examples array, which is mild waste but does help an agent read the call shape 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 four-parameter read-only conversion tool the description covers the operation and its date option, but with no output schema it never says what comes back (rate only, converted amount, both, precision). That return-value gap is the main thing an agent must guess before relying on the result.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema, and the baseline of 3 applies. The description reinforces the ISO three-letter code convention for the currencies and repeats the schema's own example object, adding little new 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 a specific verb and resource: convert an amount between two currencies using the latest or a specified-date rate, with ISO three-letter codes. This is clear enough to act on, but it never contrasts itself with the sibling tools exchange_rate or unit_convert, leaving the agent to infer which one to pick.

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

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

'按最新或指定日期汇率' implies the date-optional behaviour and the worked example shows the call shape, so usage is implied rather than stated. There is no explicit when-to-use rule and no exclusion against the sibling tools exchange_rate and unit_convert, which an agent could easily confuse with this one.

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

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

Annotations already cover the safety profile (readOnlyHint=true, destructiveHint=false), and the description adds real behavioral context the schema cannot convey: the Cloudflare DoH data source, that it is free and needs no key, and automatic fallback to Tencent DNSPod DoH when unreachable. It does not mention rate limits or the exact shape of the failure state, keeping it short of a 5.

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

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

The purpose and scope are front-loaded in the first sentence, followed by use cases and data-source notes; there is no padding prose. It loses a point for redundantly repeating the record-type list and the example payload that already appear in 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?

For a two-parameter read-only lookup with no output schema, the description covers purpose, inputs, data source, and a summary of the return values (resolution results, TTL, query status). Only details like error/empty-result semantics are absent.

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

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

Schema coverage is 100% and both parameters are documented with examples in the schema. The description adds only a short example input and restates the record-type list already covered by the enum, so the schema carries most of the load and the baseline 3 applies.

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

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

The description states a specific verb and resource ('通过 DNS-over-HTTPS 查询域名的 DNS 解析记录') and enumerates the exact record types supported. An agent can distinguish this from network-adjacent siblings like ip_info or ip_locate 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?

It explicitly names the scenarios where the tool is appropriate: troubleshooting resolution failures, verifying DNS configuration, and inspecting MX/TXT records such as SPF/DKIM. No exclusion or named alternative is given, but no sibling tool overlaps this function, so the guidance is practically complete.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds that rates are real-time and that the response covers major currencies, but says nothing about data source, freshness limits, or rate limits.

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

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

Two short sentences with the purpose front-loaded and no filler. The second clause about returning major currency rates is slightly redundant with the first but does clarify scope.

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-optional-parameter read tool with annotations and a fully documented schema, the essentials are present. However, with no output schema, the description's vague 'returns major currency rates' leaves the actual response shape (pair keys, quoting direction, precision) unspecified.

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

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

Schema description coverage is 100% and the base parameter is fully documented in the schema, including the USD default. The description only repeats the {"base":"USD"} example already present in the schema, adding no new 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?

States a specific verb and resource (query real-time exchange rates of major currencies against a base currency) plus the return scope. It is clear on its own, but it never explains how it differs from the sibling currency_convert, which an agent will likely confuse it with.

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

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

There is no guidance on when to use this versus currency_convert or any other sibling, and no prerequisites or exclusions are stated. The single example is an input example, not 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds what the tool returns (简介、主要语言、Star 数、Fork 数、链接) and how matching/sorting work, which is useful beyond annotations, though it omits rate limits or pagination beyond per_page.

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

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

Purpose is front-loaded, followed by usage guidance and an example. The example duplicates the schema's example, which is minor redundancy but not harmful.

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?

No output schema exists, so the description helpfully lists return fields (简介、语言、Star、Fork、链接). Parameters are fully covered by the schema. Complete enough for correct invocation, though pagination limits beyond per_page are not discussed.

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 all parameters are documented in the schema. The description only reiterates sorting by Star/更新时间 and shows the same example as the schema, adding little new parameter 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?

States a specific verb (搜索) and resource (GitHub 开源仓库), and specifies matching scope (名称/描述/语言) and sort options. An agent can distinguish it easily from siblings like stackoverflow_search or hacker_news_search.

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 says when to use it: tasks involving finding open-source projects, codebases, frameworks, or comparing library popularity. It does not name exclusions or alternatives among siblings, which keeps it from 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds return-field context and an invocation example, but it does not describe rate limits, result ordering, pagination behavior, or authentication requirements.

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

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

The description is two short sentences plus a compact example. The core purpose is front-loaded and no sentence is wasted.

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

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

With no output schema, the description appropriately names the return fields an agent needs. Parameter documentation is fully handled by the schema, and annotations cover safety. Only minor details such as result ordering or pagination behavior are absent.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters. The description repeats an example using query and hitsPerPage but adds no parameter semantics beyond what the schema provides, making the baseline score appropriate.

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

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

The description states a specific verb and resource: searching Hacker News technology news and discussions. It also names the returned fields (title, link, score, comment count), so an agent can immediately understand what this tool does. Sibling tools are unrelated utility functions, so no direct differentiation is needed.

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

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

Usage is implied by the description and example: use this tool when searching Hacker News content. However, it provides no explicit guidance on when to use it versus alternatives, and it does not mention exclusions or prerequisites.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds real semantic content beyond them: it discloses that 调休 (make-up workday shifts) is included, not just holiday dates, and it names the returned facts (是否放假、节日名称), which matters since there is no output schema. It stops short of describing the response shape or how 调休 days are represented.

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?

Front-loaded and short: capability first, then an example. The example duplicates the schema's own examples block, which is the only wasted content — otherwise every clause carries information.

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

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

For a one-parameter read-only lookup with no output schema, the description covers what the tool answers and what it returns. Minor gaps remain (timezone/date boundary assumptions, whether non-mainland or historical/future years are covered), but nothing essential for a correct call is missing.

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

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

Schema coverage is 100% and the single parameter already documents the YYYY-MM-DD format and the empty-string-equals-today default. The description only repeats an example value already present in the schema's examples array, adding no new semantics. Baseline 3 applies.

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

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

States a specific verb (查询) and a precise resource (中国法定节假日与调休安排), plus the exact facts returned (是否放假、节日名称). The resource is narrow enough that no sibling in the list (time_now, world_time, weather_query) could be confused with it, though it never names an alternative explicitly.

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

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

Usage is only implied by the resource name — an agent infers 'call this when you need to know if a Chinese date is a holiday.' There is no statement of when not to use it, no mention of whether non-China dates are supported, and the trailing Example is an invocation sample rather than guidance.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered by structured data. The description adds the meaningful behavior that a blank ip returns the caller's egress IP, but says nothing about latency, rate limits, failure modes, or the 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?

One sentence plus a compact example object: no filler, and the main purpose is front-loaded before the blank-ip caveat and example.

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

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

For a single-optional-parameter read tool with annotations and no output schema, the description covers what it does, the return fields, and the empty-parameter case. Adequate; only the sibling overlap with ip_locate is left unresolved.

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

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

Schema description coverage is 100% and the single 'ip' parameter already documents the 'blank means current egress IP' behavior, so the description largely restates the schema. Baseline 3 applies; no extra syntax or format detail is added.

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 (IPv4 地址的地理位置与网络信息) and enumerates what comes back: country/province/city/carrier/timezone. It is clear on its own, but a sibling named 'ip_locate' implies nearly the same operation and the description does nothing to distinguish the two.

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

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

The only usage rule given is that an empty 'ip' queries the caller's own egress IP, which is genuinely useful. There is no guidance on when to prefer this tool over the sibling ip_locate, and no stated constraints or prerequisites.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful context by naming the categories of data returned, but with no output schema the exact response shape, error behavior for invalid IPs, and any lookup limitations remain unstated.

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 first, then the empty-input rule, then an example. The inline example duplicates the schema's `examples` block, a minor redundancy that keeps it just short of a 5.

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

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

For a single-optional-parameter, read-only lookup with annotations already conveying safety, the description covers what the tool returns and how the default behaves. The only real gap is the unresolved overlap with the `ip_info` sibling, which matters for tool selection.

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

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

Schema coverage is 100% and the single `ip` parameter already documents the default and the empty-string behavior, so the description's restatement adds no new semantics. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description states a specific verb and resource ("查询 IPv4 地址的归属地") and enumerates the returned fields (country/province-city/ISP/timezone), so the agent knows exactly what it gets. It does not differentiate itself from the sibling tool `ip_info`, which sounds functionally near-identical, leaving the choice between them ambiguous.

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

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

It gives one concrete usage rule — "ip 留空查调用方出口 IP" — which covers the empty-input case. However, it never says when to prefer this tool over the sibling `ip_info`, and offers no exclusions or prerequisites (e.g., IPv6 unsupported, rate limits).

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

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

The annotations declare readOnlyHint=true, but the description states that mode=record writes a metering entry into the ledger — a write operation. This is a direct contradiction; the agent could believe writes are impossible, which is a serious safety inconsistency. However useful the extra details are (the return fields total_units and by_metric, and the actor/metric/units semantics), they cannot offset the contradiction.

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 leads with the purpose, then covers the modes and parameters, then the when-to-use, and is dense with little filler. The inline example duplicates the schema's own example field, which is a small 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?

There is no output schema, and the description fills that gap by naming the return fields (total_units and by_metric) and explaining both modes. Nothing essential for invoking it correctly is missing. The one real problem, the mismatch with the readOnlyHint annotation, is a correctness issue scored elsewhere.

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 enum modes and each parameter are already documented. The description adds real value by explaining that actor/metric/units are used only in record mode and that query aggregates by actor. That reinforces but largely restates 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 names specific verbs (record / query) and the resource (cross-Agent usage metering for settlement/split-billing), and it splits the two modes explicitly. An agent can tell exactly what this tool does and does not do 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?

"当多 Agent 协作需要计量各方资源消耗、或做任务结算/分账时使用" gives a clear triggering scenario for use. There is no statement of when not to use it, and no sibling is named as an alternative, so it stops short of a 5.

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

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

The description says mode=open opens an account, which is a write/mutation behavior, while the annotations declare readOnlyHint=true. This is a direct contradiction of the structured safety metadata. Although the description usefully mentions idempotency and initial balance, the contradiction is serious enough to warrant a 1.

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-loads the main action and mode distinctions. The example is helpful but partly duplicates the schema examples. Overall it is efficient with little 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 two-parameter tool with full schema coverage and no output schema, the description covers both mode behaviors, idempotency, initial balance, and funding paths. It does not describe the exact response shape, but the tool is simple enough that this is not a major gap. The annotation contradiction is handled separately under behavioral transparency.

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

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

Schema description coverage is 100%, so the schema already documents both mode and account_id, including the enum meanings. The description repeats the mode semantics and gives an example, but adds little beyond what the schema already provides. Baseline 3 is appropriate.

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

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

The description states a specific verb and resource: open or query a cross-Agent settlement account. It clearly distinguishes the two modes, open and balance, and mentions related operations settlement.credit and settlement.transfer. An agent can understand exactly what the tool does 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 explicitly says when to use each mode: mode=open for opening an account and mode=balance for querying balance. It also notes that accounts can be funded through settlement.credit or settlement.transfer. It does not give explicit when-not-to-use conditions, but the mode-based guidance is clear.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds real value by disclosing the hash-chain structure (each digest contains the prior prev_hash) and the returned fields, but says nothing about auth requirements, error behavior, or ordering/pagination limits beyond the cap.

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

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

Purpose is front-loaded, followed by parameters, return shape, and an example; every element is useful. It is somewhat dense and repeats schema-documented parameter defaults, which keeps it from a 5.

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

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

With no output schema, the description compensates well by enumerating return values (balance, direction, counterparty, amount, digest, prev_hash). It leaves edge cases such as unknown accounts or ledger ordering unaddressed, so it is strong but not exhaustive.

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

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

Schema coverage is 100%, and the description essentially restates what the schema already documents (account_id identity, limit default 50 / max 200). It adds the worked example, but no new 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?

States a specific verb+resource pair: query the settlement account balance and its transaction ledger with hash-chain proofs. It clearly distinguishes itself from settlement.account and settlement.transfer by emphasizing reconciliation and chain verification.

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

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

Gives clear usage context: multi-Agent settlement reconciliation, checking an Agent's income/expense, and verifying chain integrity. It does not explicitly exclude alternatives or say when to prefer settlement.account instead, so it stops short of a 5.

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

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

The description says the tool atomically debits the payer and credits the receiver, and writes an immutable hash-chain ledger entry — a clear write/mutation. Annotations declare readOnlyHint=true, directly contradicting the described behavior. This is a serious inconsistency that could mislead an agent into treating a balance-mutating call as safe/read-only.

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?

Well front-loaded: core transfer semantics first, then use cases, params, and returns, ending with a concrete example. Some redundancy with the already-complete schema in the parameter enumeration, but it is organized and each section is usable.

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

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

With no output schema, the description usefully discloses return values (tx_id, both updated balances, digest) and provides an example call. Missing only error/failure semantics (insufficient balance, invalid account), which matter for a settlement tool, but overall it is complete enough to invoke correctly.

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

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

Schema description coverage is 100%, so all six parameters are already documented in the schema. The description's parameter list (from_account, to_account, amount positive, reason optional, unit default credits, idempotency_key strongly recommended) largely restates the schema rather than adding syntax or format details, so the baseline 3 applies.

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

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

The description states a specific verb and resource: transfer credits between two cross-Agent settlement accounts with atomic bilateral settlement and hash-chain ledger writing. This is clearly distinguishable from settlement.account/ledger by behavior, though those sibling names are never explicitly referenced to route 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?

Gives a concrete usage scenario — an orchestrator settling credits to Agent A after task completion / revenue split — so the agent knows the context to invoke it. It does not state when NOT to use it (e.g., read-only queries should go to settlement.ledger) 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?

Annotations already declare this as a safe read-only operation. The description adds useful behavioral context beyond annotations by stating relevance ordering and listing the returned fields, though it omits rate limits or pagination details.

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

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

The description is front-loaded with purpose and return fields, followed by usage guidance and an example. It is efficient overall, but the example duplicates the schema's examples rather than adding new information.

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

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

With no output schema, the description usefully lists the return fields. Combined with complete parameter descriptions and read-only annotations, it gives an agent enough information 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 description coverage is 100%, and the schema documents each parameter, including limit range and the answers filter. The description's example mirrors the schema examples and does not add semantic detail beyond what the schema provides.

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: searching Stack Overflow technical Q&A, sorted by relevance. It also enumerates the returned fields, making the tool clearly distinguishable from siblings such as github_search and web_fetch.

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 explicitly names appropriate scenarios: troubleshooting code errors, researching technical solutions, and finding best practices. It does not cover when not to use it or name alternatives, 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?

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description only confirms it returns the current date/time for the timezone and says nothing about the actual return shape, precision, or default timezone behavior beyond the example.

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

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

One short sentence plus an example – front-loaded purpose with no filler. The example duplicates the schema's own examples array, which is slightly redundant but not harmful.

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

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

For a two-parameter, zero-required, read-only lookup with no output schema, the agent has enough to call it correctly: purpose, use cases, and a timezone example. Only the missing differentiation from world_time keeps it from a 5.

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

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

Schema description coverage is 100% and both parameters (format enum, timezone with Chinese-city alias) are fully documented in the schema. The description's inline example merely repeats the schema example, adding no syntax or semantics beyond it, so baseline 3 applies.

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

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

States a specific verb+resource: query the current date/time in a given timezone, and the title reinforces it. It does not, however, distinguish itself from the sibling world_time, which plausibly covers the same ground.

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

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

Gives concrete triggering intents ("现在几点"、"今天日期"、"某时区时间"), which is clear usage context. It lacks an explicit exclusion or pointer to the overlapping world_time sibling, so it stops short of the top score.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so safety is covered. The description adds useful context beyond that: the computation is local (JS Date, zero external dependencies) and the timezone defaults to Asia/Shanghai. It doesn't describe the output string format, which is the remaining gap.

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

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

The purpose is front-loaded in the first sentence and follows with usage and data source in a compact block. The appended example object duplicates the schema's examples array, which is minor waste but not harmful.

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

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

With read-only annotations, a fully described 3-parameter schema, and no output schema, the description covers purpose, direction, timezone default, and computation locality. The only missing piece is what the returned date/string looks like, which is minor for a simple conversion.

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 enum for mode, value format, and the IANA timezone default are already fully documented in the schema. The description's '典型输入：时间戳 1700000000 或日期 2026-01-01' repeats what the schema says rather than adding new format or edge-case meaning; 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 bidirectional verb+resource: converting between second-level Unix timestamps and datetimes, with a named timezone parameter. It is clearly distinguishable from siblings such as time_now, world_time, and unit_convert, which do different jobs.

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

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

It gives concrete use cases ('把日志或 API 返回的时间戳转成可读日期' and '把某日期转成时间戳做比较与计算'), so the agent knows when this tool is appropriate. It never explicitly names alternatives or exclusions (e.g., vs. time_now), which keeps it 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?

Annotations already declare readOnlyHint=false and destructiveHint=true, so the safety profile is partly covered. The description adds genuinely new context — data is isolated per caller — but never warns that clear/delete permanently remove items or whether the deletion is reversible, which is the key behavioral detail an agent needs for a destructive tool.

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

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

A single compact sentence front-loads the resource and operations, followed by a concrete usage example that anchors the action/title pairing. Little waste, though the example largely duplicates the schema's examples array.

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

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

With 5 params fully documented in the schema, one required field, and no output schema, the description covers what the tool does and how data is scoped. The remaining gap is the shape of list results and the blast radius of clear (all completed items across all lists?), which an agent must infer.

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%: every parameter, including the action enum and the id requirement for complete/delete, is already documented in the schema. The description adds no per-parameter meaning beyond the caller-isolation note, so the baseline 3 applies.

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

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

The description names a specific verb and resource (管理待办事项清单) and enumerates all five operations, which map exactly to the action enum. Sibling tools are all unrelated (weather, currency, IP), so no differentiation is required; the only missing piece is per-action scope nuance, which the schema supplies.

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

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

Usage is implied by the action list (新增/查看/完成/删除/清空), so an agent can infer which operation to pick. However, there is no guidance on prerequisites (e.g., that complete/delete require an id obtained from list) and no when-not-to-use or alternative routing.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds one genuine behavioral fact — that unit names are accepted in Chinese or English — but says nothing about error handling for unrecognized units or precision/rounding of results.

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

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

One front-loaded sentence naming scope plus a compact example — efficient overall. The example slightly duplicates the schema's own examples array, which is minor redundancy rather than 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 3-parameter read-only converter with full schema coverage, the description gives enough to invoke it correctly. The one meaningful omission is the boundary against currency conversion, which is a sibling rather than a parameter concern.

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 each parameter is already documented with examples (km, 公斤, °C, GB). The description's example call and the Chinese/English note largely restate what the schema provides, so baseline 3 is correct.

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

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

States a specific verb+resource (unit conversion) and enumerates the supported unit families (length/weight/temperature/volume/speed/area/data volume), which is more than the title alone conveys. However it never says it is distinct from the sibling currency_convert, so an agent must infer that currency is out of scope.

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

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

Usage is only implied by the listed unit categories; there is no explicit statement of when to use this over currency_convert, nor what happens for an unsupported unit. The nearest sibling is the one case where guidance was most needed.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description adds value by listing which weather fields are returned, but it does not mention data freshness, source, rate limits, or error behavior for unknown cities.

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 capability and the returned metrics, followed by an illustrative example. The example largely duplicates the schema's examples block, which is the only redundancy.

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

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

For a two-parameter read-only tool with a fully documented schema, the description covers purpose and the shape of the return values, which matters because no output schema exists. Minor gaps are freshness/error semantics, which are not essential for correct invocation.

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

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

Schema coverage is 100% and both parameters are fully documented, which sets a baseline of 3. The description adds a concrete worked example ({"city":"北京","days":3}) that shows the shape of a real call, giving a small boost above baseline.

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

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

Names a specific verb (查询) and resource (指定城市的当前天气与未来数日预报) and enumerates the returned metrics (温度/天气现象/风力/湿度). Sibling tools are all unrelated utilities, so no differentiation is needed; an agent can tell instantly what this 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?

Implies usage through the `days` example and the phrase 未来数日预报, so an agent can infer that days=1 yields current weather and larger values yield forecasts. However, there is no explicit statement of when to use this versus other inputs or of any limits beyond what the schema states.

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

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

Annotations already declare readOnlyHint=true and destructiveHint=false, so the safety profile is covered. The description does add real behavioral context — that scripts, styles and tags are stripped and only body text is returned — which is beyond the annotations. However, nothing is said about timeouts, redirects, failure modes, or JS-rendered content, so the picture remains partial.

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

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

Two short sentences, front-loaded with the action and transformation. The example sentence is redundant with the schema's examples block, so it does not fully earn its place.

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

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

For a two-parameter read-only fetch tool with full schema coverage and annotations carrying the safety profile, the description covers what the tool does and what it returns (plain body text). Only edge-case behavior (failures, dynamic pages) is missing, which is a minor gap at this complexity.

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

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

Schema description coverage is 100%, with both url and max_chars (including default 3000 and 上限 10000) fully documented in the schema. The description's only added nuance is that max_chars limits the extracted 正文, which is a marginal gain. The inline example duplicates the schema's own examples array verbatim, adding nothing.

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

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

States a specific verb+resource (抓取指定 URL 网页) and, crucially, the transformation applied (提取正文纯文本，去脚本/样式/标签). No sibling overlaps this capability, so an agent can select it without 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?

Usage is only implied by the name and verb; there is no statement of when to prefer this over other approaches, no prerequisites, and no exclusions (e.g., pages requiring JavaScript rendering, non-HTML content, authentication). Adequate for a simple utility but leaves the agent to infer boundaries.

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

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

Annotations already establish readOnlyHint=true and destructiveHint=false, and the description adds genuine value by disclosing the return content (date/time, weekday, DST status), which matters since there is no output schema. It does not mention format details or any timezone-validation behavior, keeping it short of a 5.

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

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

One sentence stating the capability plus a compact example payload — nothing wasted and the core 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?

For a single-parameter read-only lookup, the description plus annotations plus a fully documented schema cover nearly everything needed to call it correctly. The only real gap is sibling differentiation against time_now and any note on how invalid IANA names are handled.

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%: the timezone parameter is documented with IANA naming and three concrete examples. The description repeats the same example without adding new semantics such as accepted aliases, offsets, or error behavior for invalid zones, so the schema does the heavy lifting and the baseline 3 applies.

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

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

The description names a specific verb+resource (查询指定时区) and enumerates what is returned: current date/time, weekday, and DST status. It is clear what the tool does, but it never distinguishes itself from the sibling time_now, so an agent cannot tell which one to pick from the text alone.

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

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

Usage is only implied: 'query the current time of a given timezone' suggests calling it when a specific zone's local time is needed. There is no explicit when-to-use, no exclusion, and no mention of the obvious alternative time_now, leaving routing entirely to inference.

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