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

With no annotations, the description carries the full burden and does disclose the input→output transformation and its downstream purpose. But it omits key behavioral facts such as whether it overwrites the output file, permission/auth needs, or what the platform-side docking expects, which a mutation-style converter should state.

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?

Compact and front-loaded: the operation, the concrete I/O, and the prerequisite each appear once with no filler. Only minor gain available by specifying parameter expectations, but as written it is efficient.

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

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

For a format-conversion tool with nested object inputs and no output schema or annotations, the description names the output artifact and the prerequisite but leaves the input contracts and failure semantics unexplained. It is minimally adequate but not complete for the tool's complexity.

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

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

Schema description coverage is 0% and both params are undocumented nested objects. The description only loosely gestures at the input ('估算数据JSON', mapping to estimate) and says nothing about the project_info parameter or the expected shape of either object, so it fails to compensate for the coverage gap.

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

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

States a specific transformation (估算数据JSON → construction_data.json) for a clear purpose (平台侧数据对接用), using a specific verb and named artifact. It is not a tautology and an agent can understand the operation, though it does not explicitly contrast itself with siblings like estimate_excel or permitted_cost_excel.

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

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

Provides an explicit prerequisite ('需先调 get_protocol_instructions'), which is genuine usage guidance for ordering calls. However, it gives no when-to-use vs when-not, no alternatives, and no indication of when this conversion path is preferred over the sibling 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, so description carries full burden. It discloses the default return behavior (72h short link), the fallback mode, and that formulas are present in the output. It doesn't state rate limits or error behavior, but the delivery semantics are unusually 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?

Three front-loaded sentences with no filler. Everything stated is actionable: input type, output type, delivery modes, prerequisites.

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

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

Covers delivery, prerequisites, and return modes well, but the required `estimate` object is a nested, undocumented structure (schema coverage 33%, no output schema). An agent cannot verify how to shape the estimate JSON from this description alone, relying entirely on get_skill_instructions routing.

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 covers 33% of parameters; the estimate object has no description at all, and file_name has no description either. The description compensates for return_mode (default vs recommended) but not for the required estimate structure. Baseline 3 given the partial schema coverage.

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: 估算数据JSON → 三表Excel(估算表/汇总/技术经济指标,全公式). It names the output artifact type and the input type, distinguishing it from siblings like fast_calc_excel or permitted_cost_excel.

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 names two prerequisite tools (get_skill_instructions(skill=estimate) for format spec, get_protocol_instructions as prerequisite). The return_mode alternatives (base64 vs url) are also explained. This is routing-grade 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, the description carries the burden and does well: it discloses the default delivery mechanism (72h download short link), the reason (prevent large files from blowing up context), the fallback mode, and an automatic downgrade threshold (100k chars). It does not cover permissions, idempotency, or failure behavior, but for a compute tool this is solid disclosure.

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 with the input→output transformation, then delivery behavior, then the prerequisite. Dense but each clause carries information. There is mild overlap between the description and the return_mode schema text, costing it a perfect score.

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 3-param tool with no annotations and no output schema, the description covers the essential return behavior (file.url short link), the fallback path, and an ordering prerequisite, which is more than most peers. It leaves the actual Excel content/12-sheet structure unexplained, but that is out of scope for invocation correctness.

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 files, file_name, and return_mode, so the baseline is 3. The description restates the return_mode semantics (url default, base64 fallback, auto-downgrade) rather than adding new meaning beyond the enum description. No compensating gaps 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?

States a specific verb (快速测算) and the exact transformation: 5 txt inputs → a 12-sheet full-formula Excel in the E投 caliber. The 'E投口径' qualifier is a real distinguishing signal versus generic siblings like estimate_excel. It stops short of naming an alternative sibling to disambiguate fast_calc_reports or fast_calc_solve.

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

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

Provides an explicit prerequisite: '前置：需先调 get_protocol_instructions' — a concrete ordering constraint most descriptions omit. It also explains when to prefer the default url mode vs base64 fallback. It does not say when to use this over sibling calculation tools, so it is not a full 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, the description carries the full burden and does so richly: it discloses the ~50–60KB output size, the 50KB truncation failure mode, the complete:true sentinel for self-checking, the verbatim-number requirement (禁止自行换算), and the IRR-non-convergence caveat. These are behavioral traits beyond anything the schema provides.

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?

Dense but front-loaded: purpose first, then output structure, then truncation/batching, then numeric-integrity rules. Every clause carries operational information, though the length is heavy and some output-structure detail could be trimmed.

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

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

For a complex financial-modeling tool with nested inputs, no output schema, and no annotations, the description supplies the output shape (_meta.years, financial_ratios row list, annual matrices), truncation handling, and result-interpretation guidance. Nothing essential to correct invocation 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 description coverage is already 100%, so baseline is 3, but the description adds real value by explaining WHY tables exists (truncation avoidance / 省流且截断自检) and reinforcing the comma-separated, .txt-optional format and the complete flag. It goes beyond restating the schema's parameter text.

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 with scope: 5类输入txt → 16键JSON（11张报表+指标+IRR/MIRR诊断+资金缺口）. An agent can tell this apart from siblings like fast_calc_excel and fast_calc_solve without opening a schema, because the exact output composition is enumerated.

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 conditional guidance: if the client 50KB response limit truncates the payload, pass tables="..." to pull in batches. It also directs the agent to trust annual IRR and corrected MIRR when irr_health/warnings flag non-convergence. It does not, however, explicitly contrast itself with the sibling fast_calc_excel/fast_calc_solve tools.

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

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

With no annotations, the description carries the full behavioral burden and does so thoroughly: it explains the binary-search plus engine method, return semantics for ok/nochange/range failure, and boundary warnings near ±90%/+300%. It also discloses that invest_pct includes tax amounts, progress payments, proportional adjustments, and a closure guard.

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 long and dense, but it is front-loaded with the core purpose and organized by knob, target, want, and return semantics. Most sentences add distinct information, though some enum repetition could be trimmed.

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 and no annotations, the description is complete enough for correct invocation: it explains required inputs, parameter meanings, success and failure return shapes, boundary warnings, and when to seek baseline values first. Nothing critical is missing for an agent to call or interpret 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 description coverage is 100%, so the enums for knob, target, and want are already documented. The description adds useful meaning beyond the schema, such as the exact financial meaning of invest_pct, the native units for IRR/NPV/payback, and the default behavior of want.

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: inverse calculation of financial indicators (IRR/NPV/payback) from five input text files and a target value. It names the sibling fast_calc_reports as a baseline prerequisite, so an agent can distinguish it from related calculation 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?

It explicitly recommends using fast_calc_reports first to view baseline values before running this tool, and describes the default want=down versus want=up. It does not, however, explain when not to use this tool or compare it against all alternatives such as fast_calc_excel.

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 and does it well: it reveals the ~1.1MB output size, the default 72h download short-link delivery with base64 fallback, and the gatekeeper validation that rejects non-native/self-assembled reports. It does not cover permissions, processing duration, or failure/error behavior, so it stops short of a 5.

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

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

Dense but front-loaded: purpose and output format come first, then delivery semantics, then the ①② usage enumeration. Nearly every clause earns its place (size, offline capability, gatekeeper rule), though the single long paragraph is information-heavy and slightly hard to parse at a glance.

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

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

For a complex nested-object tool with no output schema, the description is well covered: it explains input combinations, the validation rule, the returned artifact and both delivery channels. Remaining gaps are secondary details such as runtime expectations or auth requirements, which are not strictly needed 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?

Schema coverage is 100%, so the baseline is 3; the description adds real meaning by tying parameters to the two usage patterns (input = five categories or at minimum project_basic_info.txt; reports = the 11 native report files; return_mode = base64 default vs url recommended). It clarifies the valid input combinations rather than restating field 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?

States a specific verb+resource: it generates a financial dashboard (dynamic cash-flow演绎 + dual-caliber solvency analysis) delivered as a single self-contained HTML file with named sidebar sections and inlined ECharts. This is concrete enough that an agent can distinguish it from generate_ppt_html / generate_word_report without opening a 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?

Explicitly lays out two mutually exclusive usage modes (① recommended: full five-category input files letting the platform compute the standard 11 reports; ② reports: E投 native 11 reports + project_basic_info.txt), and warns that hand-assembled simplified tables are rejected by the gatekeeper. It also advises the recommended return_mode for external clients, leaving essentially nothing to inference.

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

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

No annotations, so description carries full burden: discloses 2–4MB output size, 72h download short-link default, base64 fallback, offline self-containment. Missing only info on failure modes or rate limits, but the delivery 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?

Dense but efficient single paragraph front-loading the core transformation, then prerequisites and delivery mode. No wasted sentences, though multi-clause parentheses make it busy.

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

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

Covers the transformation, upstream/downstream sequencing, skill/protocol prerequisites, and delivery semantics for a 3-param, no-output-schema tool. Adequate; only missing edge-case/error behavior.

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

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

Schema coverage is 100% and each parameter already has a description (file_name, return_mode enum with url recommendation, content_html). Description restates return_mode default but adds little beyond the schema. 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?

Specific verb+resource: wraps content HTML into a self-contained offline HTML presentation with Plotly.js inlined. Clearly distinguishes itself from siblings like generate_dashboard/generate_word_report and names ppt_extract_data as the upstream data step.

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?

Explicit sequence: first use ppt_extract_data, then this tool; consult get_skill_instructions(skill=ppt) for HTML structure; prerequisite get_protocol_instructions. States the recommended delivery mode (url) and its rationale. Nothing left to inference.

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

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

With no annotations to lean on, the description carries the full burden and does so richly: hard chapter-catalog validation that rejects non-conforming submissions and returns the standard catalog, number_audit.unmatched flagging suspected fabricated/converted figures, number placeholders that auto-fill from engine values to prevent drift, and default 72h download short-link delivery with base64 fallback. This is exactly the kind of mutation/validation/auth-adjacent behavior an agent needs.

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

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

Nearly everything is packed into a single run-on paragraph with no line breaks or hierarchy, mixing pipelines, validation, placeholder syntax, delivery mode and block formatting. The content is mostly valuable, but the scanning cost is high and it is not front-loaded by task.

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 16-parameter, nested-object tool with no output schema and no annotations, the description covers generation modes, data sources, validation behavior, delivery format and block structure thoroughly. The main residual gap is the exact shape of the returned result object beyond the download URL, which it only gestures at.

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?

At 50% schema coverage the description must compensate, and it adds real meaning for the complex params: the three-way data-source choice (p_id/files/reports), the report_type pipelines, the content_blocks block grammar (heading/info/table plus accepted aliases and whole 2D array form), and the charts spec with rendering standards. Trivial params (title, file_name, subtitle, project_id) remain undocumented, keeping it from a 5.

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 ('生成Word报告') and enumerates four distinct output pipelines (gongwen/feasibility/econ/national) with their differing contracts, so an agent can distinguish which mode it needs without opening another tool. It also implicitly separates this doc-generation tool from data-producing siblings like get_chapter_data and fast_calc_reports, which it names as data sources.

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 routing: which report_type to pick, which data source to use (p_id/files is explicitly '推荐' over reports), and points to get_skill_instructions for the feasibility/econ/national contracts. It lacks explicit when-not-to-use guidance versus siblings like run_delivery_bundle or fast_calc_excel, so it stops short of full alternative coverage.

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 burden and discloses that numbers must be referenced from return values, that data keys can be used as placeholders in generate_word_report with {{章节.键[.年份|.total]}} syntax, and that numbers are injected by the system. It doesn't mention rate limits, permissions, or error behavior, but it provides substantial operational context for a read-only data retrieval tool.

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

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

The description is dense but front-loaded with the core purpose and then packed with essential usage rules. Some parenthetical details and the placeholder syntax could be slightly clearer, but every sentence adds actionable 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 six parameters with nested objects, no output schema, and no annotations, the description covers the data structure, the alternative input methods, the downstream integration, and the placeholder contract thoroughly. An agent has enough to invoke correctly and use the output.

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 already 100%, but the description adds non-obvious semantics: chapter=list means get directory, p_id requires a pure numeric E投 project ID, reports can be a fast_calc_reports tables package or a subset, and stage defaults to scheme_stage. It explains the three-way exclusivity (p_id, reports, files) beyond the schema.

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

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

The description states a specific verb and resource: return structured data plus writing points per chapter for feasibility (8 chapters) or econ (6 chapters) reports. It also distinguishes itself from siblings by naming get_skill_instructions for templates and generate_word_report downstream.

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 tells when to use chapter=list to see the directory, when to use p_id+stage vs reports, and that fast_calc_reports should be used first if no platform project number exists. It also directs to get_skill_instructions before template work, covering alternatives and conditions.

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

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

With no annotations, the description carries the full burden. It clearly indicates a read operation, describes the content to be retrieved, states a mandatory prerequisite for another tool, and gives a time-bound validity note. It does not describe authentication, rate limits, or return format, but for a simple instruction reader this is reasonably 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 two tight sentences: the first front-loads the purpose and scope, the second adds the critical prerequisite and validity. No wasted words, and the important constraint is placed immediately after the purpose.

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

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

Given the tool has no parameters, no output schema, and no annotations, the description adequately explains what will be read and when it must be used. It does not specify the return format (e.g., text, JSON), which would help an agent know what to expect, but overall the essential context 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 tool has zero parameters, so there are no parameter semantics to document. The baseline for zero parameters is 4, and the description does not need to add parameter details.

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 (读取/read) and a specific resource (Agent接入总则/Agent access general rules), then enumerates the covered content (directory structure, file naming, archiving, final product naming). This distinguishes it from sibling tools like get_skill_instructions by specifying the exact 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?

It gives an explicit prerequisite: must be read before calling fast_calc_excel. It also adds a validity window (72 hours). However, it does not mention when to use it versus the similar sibling get_skill_instructions, nor any exclusions, so it falls short of a full 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 provided, so the description carries the full behavioral burden. '读取' implies a read operation, but the description never states whether the call is side-effect free, how large the returned template is, or what a missing/invalid skill yields. For a zero-annotation tool 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?

A single dense sentence, front-loaded with the purpose and then the value mappings, with no filler. It is slightly cramped but every clause earns its place.

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

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

For a one-parameter lookup with no output schema and no annotations, the description is minimally adequate: it names the purpose and partially documents the enum. It falls short by omitting three of the eight skill values and giving no sense of what the returned template contains.

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

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

Schema description coverage is 0%, so the description must compensate, and it does map five enum values (nlmodel, estimate, ppt, permitted_cost, national_econ) to their meanings. However three enum values (feasibility_report, econ_report, national_report) remain unexplained anywhere, leaving the compensation incomplete.

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 (读取/read) and resource (技能工作流指令模板, skill workflow instruction templates), so the agent knows exactly what the tool returns. It does not differentiate itself from the sibling get_protocol_instructions, which also appears to serve instruction retrieval.

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

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

There is no statement of when to use this tool, when not to, or which sibling to prefer. The sibling list contains get_protocol_instructions, an obvious alternative for instruction retrieval, yet the description makes no attempt to route between them.

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

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

With no annotations, the description carries the full burden, and it discloses two non-obvious behaviors: the full library is never distributed and only matching candidates are returned, plus the anti-fabrication constraint. It does not state whether matching is deterministic or how ties/scores are produced, so it is good but not exhaustive.

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 key information (what it does, when to call it, the fabrication ban) is front-loaded in the first clauses, and there is little filler. The final sentence is dense but every clause adds a real constraint, so only minor tightening is possible.

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 or annotations, so the description must explain return behavior — and it does, listing the returned fields and their relevance ordering. The main remaining gap is what to do when no candidate matches, which an agent may need during estimation.

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 are documented with concrete examples, so the baseline is 3. The description adds only the framing of query as a sub-item description and the relevance ordering, which the schema already implies via top_k.

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 transformation: a sub-item/project description becomes ranked candidate cost indicators from the platform library, and it even enumerates the returned fields (name/unit/indicator value/note). This clearly distinguishes it from estimate_etou_json and the calc/report 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?

It gives explicit usage context — during investment estimation, call this per sub-item first — and a negative rule (never fabricate indicators that are not in the library). It stops short of naming an alternative tool or a fallback when no candidate matches.

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 burden. It discloses the default return (72h download short link) and the base64 fallback, which is useful. However it omits whether the operation is read-only/side-effect-free, permission requirements, and expected output characteristics beyond format.

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?

Information is front-loaded with the core purpose, but the sentence is dense and mixes purpose, output sheets, delivery modes, and prerequisites in one block. It is reasonably compact but not as structurally clean as it could be.

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 complex nested data schema and generated output, the description covers what the tool produces, delivery modes, and prerequisite tool calls. It is fairly complete, though it doesn't explain the division of labor with sibling Excel generators.

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 three parameters in detail. The description repeats the return_mode behavior and file naming conventions but adds little syntax or format meaning 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?

States a specific verb and resource (pricing data JSON → full-formula Excel workbook) and even enumerates the sheets produced. This is clearly distinguishable from siblings like estimate_excel or fast_calc_excel, though the description does not explicitly contrast with them.

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

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

Gives prerequisites (call get_protocol_instructions first; see get_skill_instructions for the five-step data collection) and states the default vs. recommended delivery mode. It does not name an alternative sibling for the same task, but the prerequisite routing is concrete.

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 one important behavioral trait, the mandatory get_protocol_instructions prerequisite, but says nothing about failure modes, missing-report handling, or the shape/limits of the emitted JSON.

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?

Compact and front-loaded: the transformation is stated first, then the dimension list, then the prerequisite. The enum repetition 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, nested-object transform with no output schema, the description covers the input-to-output mapping, the dimension options, and the prerequisite step. It leaves the JSON output structure unspecified, a minor gap given no output schema exists.

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%. The reports parameter is already documented in the schema (filename→full text), and the description merely re-lists the dimension enum values that the schema already enumerates, adding no real semantic explanation of what each dimension yields.

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: it converts E-investment report txt into structured JSON for PPT authoring. An agent can tell it is a data-extraction transform, distinct from sibling generators like generate_ppt_html. It stops short of explicitly naming the sibling it replaces or excludes, keeping it at 4.

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 context (used to avoid manually copying report figures into PPT scripts) and an explicit prerequisite: get_protocol_instructions must be called first. It does not explain when NOT to use it or which alternative to pick among the calc/generate siblings.

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

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

With no annotations, the description carries the full disclosure burden. It usefully scopes the query to the caller's own usage ('自己') and lists the four metric categories returned, which is valuable given there is no output schema. It does not state auth requirements, rate limits, or whether results are paginated for high-volume accounts.

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-loaded with the tool's purpose (用量统计) followed by the metric list. No filler or repetition. Slightly dense with the parenthetical month clause embedded mid-sentence, but nothing is wasted.

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

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

For a simple read-only tool with one optional parameter and no output schema, the description is nearly sufficient: it identifies scope, the default period, and the returned metrics. Only the ambiguity of what '自己' resolves to (API key, account, or workspace) and any response-shape details are left unstated.

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

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

Schema description coverage is 100% and the single parameter already documents 'YYYY-MM，缺省当月'. The description merely restates the same default, adding no format rules, range limits, or error behavior beyond the schema. Baseline 3 applies when the schema does the heavy lifting.

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

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

The description names a specific verb (查询/统计) and resource (用量), and enumerates exactly what is measured: 调用量、下行流量、平均耗时与分端点统计. This is far more specific than the bare name query_usage. It does not differentiate against siblings, but no sibling tool overlaps in domain, so differentiation is unnecessary rather than missing.

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 '自己当月（或指定 YYYY-MM）' implies the usage context: call it with no argument for the current month, or pass a month to target a specific period. However, there is no explicit when-to-use vs alternatives, no prerequisites, and no stated exclusions. Usage is implied rather than guided.

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 behavioral burden and does so well: it discloses runtime (25-30s, with Word ≈28s), a recommended client timeout, failure isolation ('single item failure does not interrupt; returns files success list and errors detail'), output delivery via 72h short links, quick-mode default and cost, and the condition for Word report generation. This is rich operational detail beyond 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?

The description is dense and front-loaded: pipeline purpose, outputs, timing, failure behavior, prerequisite, and optional Word conditions are all packed into a few sentences with no filler. Every sentence adds actionable information for an agent.

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

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

For a complex multi-step pipeline with no annotations, no output schema, and a nested object parameter, the description covers the essential ground: artifacts produced, timing, timeout advice, error handling, prerequisite call, and the conditions that trigger the optional Word report. An agent has 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 the baseline is 3. The description provides overall pipeline semantics but adds no parameter-level detail beyond what the schema descriptions already state (quick mode, report structure, file_name condition, report_type default).

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

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

The description clearly states a one-click delivery pipeline that converts 5 types of input txt into Excel (12 tables), a financial dashboard, sensitivity analysis, and an optional Word report. It names the exact artifact set and recommends itself for external agents, which distinguishes it from the single-purpose sibling tools like fast_calc_excel or generate_dashboard.

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 explicit usage context ('recommended for external agents') and a hard prerequisite ('need to call get_protocol_instructions first'), plus timeout guidance (≥60s). It does not name alternatives or state when not to use it, but the context for invocation 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?

With no annotations, the description carries the full burden. It discloses valuable behavioral context such as per-item result symbols (✅/⚠️/❌/ℹ️), automatic missing-data marking, and second-level response time, but it does not state whether the operation is read-only or has side effects, nor does it mention permissions or auth requirements.

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

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

The description is front-loaded with purpose and check scope, then moves to usage modes and a fallback. It is dense but well-organized; the parenthetical enumerations of check types and status symbols are informative rather than 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 no output schema and no annotations, the description does a good job explaining what is checked, how to supply inputs, and what result categories look like. It remains somewhat incomplete on side-effect/permission behavior and exact return structure beyond status symbols, but is largely sufficient 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?

Schema description coverage is 100%, so the schema already documents each parameter. The description adds meaning beyond the schema by explaining the two mutually exclusive usage modes (p_id+stage vs reports), that reports may be a subset, and that missing reports are auto-flagged.

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: performing cross-check validation on financial reports across six segments and 73 items. It clearly distinguishes itself from siblings by naming fast_calc_reports as the tool to generate reports first, so an agent can tell it apart from generation or delivery 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?

It gives explicit alternatives: pass p_id (+stage) to locate a project, or pass a reports object directly, and notes the fallback to fast_calc_reports when no platform project number exists. It also states the use case ('交付前自检或向用户展示报表质量用'), leaving little to inference.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses inputs must be in shadow-price terms excluding taxes/subsidies/domestic-interest transfers, that arrays start at year 0 in 万元, and that single-factor sensitivity and multi-scenario comparison are appended by default. It omits auth requirements, rate limits, and error behavior, so it stops short of a 5.

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

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

The definition is a dense but front-loaded single 'input → output' sentence followed by a targeted pointer to the methodology skill. Every clause carries information, though the packing of conventions makes it slightly heavy for a reader scanning 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?

Because there is no output schema, the description must, and does, explain the return values (ENPV/EIRR/BCR/cumulative net benefit/feasibility verdict) plus default sensitivity behavior and data conventions. It is largely self-sufficient for correct invocation, with only auth/side-effect context missing.

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

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

Schema description coverage is 100%, so the baseline is 3, but the description adds genuinely new meaning: benefits and costs must be expressed on a shadow-price basis with transfer payments (taxes/subsidies/domestic interest) removed, and year 0 is the first entry. This contextualizes how to populate the arrays beyond what the schema states.

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 method (国民经济评价/national economic evaluation) and enumerates the exact outputs (ENPV/EIRR/BCR/累计净效益+可行性判定), so an agent knows precisely what this computes. It does not, however, explicitly contrast itself with sibling tools like run_uncertainty or run_revenue_review, which would elevate it to 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 this is the tool for national economic evaluation and routes the agent to get_skill_instructions(skill=national_econ) for benefit/cost identification and shadow-price adjustment methodology. It gives no explicit when-to-use vs when-not, no prerequisites, and no direct contrast with alternative evaluation tools, leaving usage largely 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 and no output schema, the description carries the full burden and does well: it discloses that the tool returns 16 graded items (🔴/🟡/🟢/ℹ️), and crucially warns that some items are unqualified numerical outputs the host AI must benchmark online against local pricing. That grading legend and the follow-up caveat are exactly the behavioral context an agent needs. It omits any mention of permissions, cost, 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?

A single dense paragraph that front-loads the purpose, then the 16-item breakdown, then the grading legend, then the input modes — a sensible ordering. It is information-heavy but nearly every clause earns its place by carrying inspection criteria or input rules.

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 nested-input, no-annotation tool, the description covers the essentials: what gets reviewed, how results are graded, the two input paths, and the fallback sequence via fast_calc_reports. No output schema exists, yet the grading legend gives enough of a picture of the return shape; only edge-case behavior of the reports object is left implicit.

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

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

Schema coverage is 100%, so p_id, stage, and reports are already documented in the schema, including the 'p_id 与 reports 二选一' constraint and the stage default. The description only restates the dual-input structure and adds a light workflow hint (use fast_calc_reports output), so it lands at the baseline 3.

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 (收入费用合理性审查 / revenue-and-expense reasonableness review) and quantifies scope (16 items across R/C/X categories), so an agent knows exactly what the tool produces. It does not, however, differentiate itself from overlapping siblings such as run_model_check or run_national_econ.

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?

Explains the two alternative input paths (p_id+stage vs reports object) and gives a concrete prerequisite sequence: when no platform project number exists, call fast_calc_reports first to generate the 11 tables. This is clear input-sourcing guidance with a named sibling, but it stops short of stating when this review is preferred over the other review/analysis tools.

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

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

With no annotations, the description carries the full burden and does so well: it discloses output destinations (user workspace vs. platform file repository), return artifacts (file list, 72h download short links), an explicit negative (no base64), runtime (1–3 min) and a timeout recommendation (≥300s). It does not cover permissions/auth or error behavior, so it falls short of a perfect 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?

Information-dense but front-loaded: the purpose and the two usage modes lead, with timing/prerequisite details trailing. Every sentence carries content, though the packing of many facts into a single block slightly hurts scanability.

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 7-parameter tool with nested objects and no output schema, the description covers both invocation paths, the required prep call, runtime/timeout, and the returned artifacts, so nothing essential for correct invocation 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 already 86%, so the baseline is 3, but the description adds real meaning: the mutual exclusivity of p_id and files, what each mode returns, and how quick trades scope for speed. It complements rather than merely restating the schema.

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

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

States a specific verb and resource (uncertainty analysis computing sensitivity/scenario/Monte Carlo plus an overall report) and explicitly separates the two invocation modes. It even names a sibling, fast_calc_reports, as the producer of inputs, so an agent can route correctly without opening other 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?

Gives explicit when-to-use for each mode (p_id+stage for your own platform project vs. files direct-upload when there is no platform project number) and states a hard prerequisite (call get_protocol_instructions first). It also explains the closed loop with fast_calc_reports, leaving little to inference.

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

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

With no annotations, the description carries the full behavioral burden and does well: it discloses that the feedback is transcribed and persisted, that the platform inspects records daily, that the user must be told it was recorded, and mandates content fidelity (user's own words, no AI speculation). It stops short of stating permissions, failure/error behavior, or whether submission can ever fail, which is why it is not a 5.

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

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

Front-loaded with purpose and trigger, then parameter guidance, then the user-notification step, then a shortcut note. Every clause earns its place; only the '(2026-09-12 新增)' changelog tag is dead weight, and the heavy parenthetical density makes it slightly harder to scan than ideal.

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

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

Four-parameter tool with no output schema and no annotations; the description covers trigger, required content semantics, optional tool/rid sourcing, side effect (recorded, daily review), and the closing user-facing step. It omits any error/failure handling and what the call actually returns, a minor gap given the tool's low-stakes 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 is 3. The description goes beyond the schema by adding the content-fidelity rule ('do not add the AI's own speculation') and by explaining when to supply tool and rid (from the error return), which the schema only labels as optional.

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

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

States a specific verb (提交) and resource (用户反馈), plus the exact trigger condition (user expresses dissatisfaction, suggestion, or question about tool/result/platform). This is unmistakably distinct from every sibling, all of which are computation or report-generation 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?

Explicitly names when to invoke (user dissatisfaction/suggestion/question) and adds a clear when-not/lower-bar note: '低门槛：无需先读总则', meaning no need to read general rules first. Nothing about the trigger is left to inference.

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