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

No annotations exist, so the description carries the full burden. It implies a read operation via '查看' and helpfully discloses the return record shape, but says nothing about permissions, pagination behavior beyond the limit cap, or whether the history is bounded/retained. Adequate but incomplete for a zero-annotation 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?

Front-loads the purpose, then Args, then Returns, with no filler. The Returns block is somewhat verbose but earns its place since no output schema exists to convey the field list.

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 tool with no output schema, the description covers the purpose, the sole parameter's semantics, and the return structure, which is more than the structured fields provide. Only auth/retention context is missing, a minor gap.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it explains that limit returns the most recent N records, with default 20 and maximum 200. That meaning and its bounds are absent from the schema and are fully supplied here.

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 (查看/view) and resource (交割单导入历史/import history) and enumerates the fields surfaced (file, broker, import time, success/skipped rows). An agent can distinguish this read-history tool from the write-side broker_import_statement, though the description never names that sibling explicitly.

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

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

There is no explicit when-to-use guidance or routing to alternatives. The read-only intent is implied by '查看', but the agent gets no signal about when this is preferable to broker_import_statement or broker_list_trades, and no prerequisites are stated.

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

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

With no annotations provided, the description carries the full behavioral burden. It discloses the data source ('已导入交易') and a partial return shape, and the aggregation nature strongly implies a read-only operation, but it does not explicitly state read-only safety, permissions, error behavior, 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?

The description is front-loaded with the tool purpose, then structured into Args and Returns sections. Every line contributes useful information with no redundancy or filler.

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

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

For a 3-parameter statistics tool with no output schema, the description supplies the missing parameter details and a useful return-key summary. It is nearly complete, missing only explicit usage guidance against alternatives and read-only safety confirmation.

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: it documents all three parameters, including date format (YYYY-MM-DD), inclusive bounds for start_date and end_date, and broker as an optional filter defaulting to all.

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, '汇总' (aggregate), and a specific resource, '已导入交易' (imported trades), then lists the exact metrics computed. It clearly distinguishes this as a statistics tool rather than a listing or import tool, though it does not explicitly name sibling alternatives.

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

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

The description implies the tool is for summarizing imported trades, but gives no explicit when-to-use guidance, no prerequisites, and no comparison to alternatives such as broker_list_trades or broker_get_imports. It leaves the agent to infer its place among 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 burden and does well: it discloses idempotent dedup behavior (re-importing the same file yields imported_rows=0 and a 'already exists' hint), auto broker detection with generic fallback, and a warnings/hint channel. It does not cover permissions, file-size limits, or error modes, 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 purpose sentence is front-loaded, and the Args/Returns sections are tightly organized with no filler. The return-field enumeration is justified because no output schema exists. Slightly verbose but every part earns its place.

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

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

For a two-parameter mutation tool with no annotations and no output schema, the description supplies both parameter semantics and the full return shape (import_id, row counts, date range, warnings, hint), which fills the output-schema gap. Minor omissions around permissions and failure behavior keep 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 coverage is 0% with two parameters, so the description must compensate, and it does: file_path is documented as an absolute path to the broker's exported statement, and broker is given the candidate identifiers (htsc / citic / cms / gtja / generic) plus the auto default and its header-based detection logic. This adds meaning well beyond the bare 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+resource: importing broker statement CSVs, parsing them into standardized trade records, and persisting them. This is unambiguous and clearly distinct from read-only siblings like broker_get_imports or broker_list_trades. It does not explicitly name a sibling, but the action is unique enough that an agent can identify it.

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 explicit when-to-use or when-not-to-use guidance, and no alternatives are named. The description implies usage context by explaining that broker defaults to auto-detection from header features, so an agent can call it with only file_path. That is useful implied guidance but falls short of explicit 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?

With no annotations, the description carries the full burden, and it does disclose useful behavior: default time-descending sort, default limit of 200 with a max of 2000, and the full return shape. It does not state read-only safety explicitly or explain paging beyond the limit cap, but the substantive behavioral facts are present.

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, then a clean Args/Returns split. Each line carries information and there is no filler, though the docstring formatting makes it slightly longer than a prose equivalent.

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 correctly documents the return structure (total plus trade fields). All six parameters are covered, and the read/list semantics need no permission disclosure beyond what is stated. Complete for an agent to call it correctly.

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

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

Schema description coverage is 0%, so the description must compensate entirely, and it does: every one of the six parameters is documented in the Args block with meaning, format (YYYY-MM-DD, 含/inclusive), example values, and the accepted value sets for side (buy/sell/other/unknown) and broker (htsc/citic/cms/gtja/generic). Nothing in the schema adds meaning beyond this.

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 (查询/list) and resource (已导入的标准化交易记录), plus the default ordering. This clearly distinguishes it from siblings like broker_get_trade_stats and broker_get_imports, which operate on aggregates and imports rather than individual trade rows.

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 (list imported normalized trades, filter by date/symbol/side/broker) but there is no explicit when-to-use versus when-not, and no guidance on choosing this over broker_get_trade_stats or broker_get_imports. An agent must infer the boundary from the resource name alone.

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

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

No annotations are supplied, so the description carries the burden; the 'view' verb plus zero parameters make it clear this is a side-effect-free query. It further discloses the shape of the returned data (brokers with id/name/sample_columns, standard_fields, note), which is meaningful behavioral context for a reference 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?

Front-loads the purpose, then the usage condition, then the return shape. The two Chinese sentences overlap slightly in restating the field-mapping idea, but overall the structure is efficient and well ordered.

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 no output schema exists, the embedded Returns block usefully documents the response payload (brokers list, standard_fields, note), which the agent would otherwise lack. For a simple zero-parameter reference tool this is nearly complete, missing only minor details such as whether coverage is exhaustive or cached.

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

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

The tool takes no parameters, so there is nothing for the description to disambiguate. Per the baseline for zero-parameter tools, a 4 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?

States a specific verb (查看/view) and resource (支持的券商交割单格式与标准字段映射), making it clear this is a reference lookup for supported broker statement formats and field mappings. It is easily distinguished from siblings like broker_import_statement (which performs the import) and broker_list_trades (which lists trades).

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 contextualizes when to use it: before an import to verify format compatibility, implicitly routing the agent here ahead of broker_import_statement. No exclusions or named alternatives are given, so it stops 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 burden. It mentions archiving and that a final_summary is returned, which adds some context, but omits whether the abandon is irreversible, whether partial progress is preserved, and what errors occur if the session is invalid.

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 text is short and front-loaded with the core action, with Args/Returns cleanly separated. There is no wasted framing, though the parameter line is redundant with 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?

With no annotations and no output schema, the description does cover the return value (dict with final_summary), which helps. But for a mutation tool it should disclose more behavioral and edge-case detail to be truly complete.

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

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

Schema coverage is 0% and the single parameter is undocumented in the schema. The description only restates '要放弃的会话 ID' (the session ID to abandon), which adds no format, source, or lookup guidance beyond the parameter name itself.

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 (abandon) and resource (the in-progress Socratic coaching session) plus an outcome (archiving). It is distinguishable from siblings like coaching_start_coaching and coaching_continue_coaching, though it does not explicitly name the contrast.

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

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

Usage is implied by '当前进行中的' (currently in-progress) session, suggesting it applies mid-session. However, there is no explicit when/when-not guidance or reference to alternatives such as continue or switch_to_simple, leaving the agent to infer.

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 usefully discloses that the comparison is performed by an LLM and that the return value is a dict with status and comparison. It does not clarify read-only nature, side effects, permissions, or cost implications.

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 the comparison purpose and then uses a compact bullet list plus Args/Returns sections. It is efficient and well structured, 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 two-parameter comparison tool with no output schema and no annotations, the description covers what the tool does, both parameter meanings, and the return shape. Gaps remain around usage alternatives and behavioral safety context, but the core information needed to invoke it 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?

Schema description coverage is 0%, so the description must compensate, and it does for both required parameters. It explains event as a description of the current new event with an example, and scenario_id as the historical scenario ID obtained from list_coaching_scenarios.

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: comparing a new event's variable structure against a historical scenario using LLM analysis. It is clear what the tool does, though it stops short of explicitly differentiating itself from other coaching-related siblings beyond pointing to list_coaching_scenarios as the source for IDs.

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

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

The description implies usage by saying to retrieve a historical event from the scenario library and comparing it, and it names list_coaching_scenarios as the source of scenario_id. However, it does not state when to use this tool versus alternatives like coaching_iterate_judgment or coaching_continue_coaching, nor does it give exclusions.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the core mechanism (LLM-driven priority adjustment) and the return shape, but omits whether the rule mutation persists, whether it is reversible, or any permission/auth requirements for changing investment rules.

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 purpose, then usage trigger, then Args, then Returns. Efficient overall, though the opening prose and the Args section restate the same two inputs, adding minor 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 tool with no output schema and no annotations, the description covers purpose, trigger context, both parameters with examples, and the response shape. The main gap is behavioral: persistence and reversibility of the rule mutation are 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 0% (properties have only titles), so the description must compensate, and it does: it supplies a concrete example for each parameter (wrong_variable: uncontrolled variable like 'gold and dollar rising together'; correct_result: what actually happened). This meaningfully disambiguates both string inputs beyond the bare titles.

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: updating variable priority in investment research rules after a wrong judgment. The mechanism (LLM analyzes and suggests which variable to raise/lower) is concrete. It does not, however, distinguish itself from nearby siblings such as coaching_coaching_suggest_thresholds or the other coaching_ tools, leaving the agent to infer the boundary.

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

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

Explicitly states when to use it: after the user makes a wrong judgment, feeding the wrong variable and the actual correct result. That is a clear triggering condition. It offers no exclusions or named alternatives, so the agent cannot tell when NOT to use it versus the other coaching_ 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 must carry the behavioral burden. It discloses that the tool uses the user's past transaction records and that an LLM produces the suggestion with reasoning, but it does not explicitly state that the operation is read-only, whether permissions or existing history are required, or what happens on failure.

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 structured and front-loaded, with purpose first and Args/Returns sections afterward. It is appropriately sized for a one-parameter advisory tool, with only minor redundancy in restating the LLM analysis.

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

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

The description covers the core purpose, input examples, and a basic return shape, which is adequate for a simple advisory tool. However, with no annotations and no output schema, it should say more about prerequisites such as transaction-history availability and 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?

The schema has one required parameter with 0% description coverage, so the description's Args section does add meaning by giving examples such as interest rates, FX, commodities, A-shares, and US stocks. It still does not define an enum or validation constraints for asset_class.

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: suggest numeric thresholds to trigger deep analysis. It also names the data source (past transaction records) and the asset-class scope, making the tool's intent clear, though it does not explicitly distinguish itself from sibling coaching tools.

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

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

The use case is implied: analyze past trades to suggest a magnitude threshold for a given asset class. However, there is no explicit guidance on when to use this tool versus alternatives such as coaching_start_coaching or coaching_continue_coaching, so the agent must infer the context.

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

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

With no annotations provided, the description carries the full burden and does so well. It discloses that remaining questions are abandoned, existing analysis context is reused, a 10-step investment research template is run, and the result is archived to the scenario library; it also states the return shape.

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

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

The description is front-loaded with the core action, then efficiently documents behavior, the single argument, and the return value. There is no redundant or filler 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?

Given the absence of annotations and an output schema, the description supplies enough context for correct invocation: it identifies the session prerequisite, explains side effects and archival behavior, and describes the returned fields answer and scenario_id.

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

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

Schema coverage is 0%, but the only parameter is explicitly described as the session ID returned by start_coaching. This adds meaningful origin and usage context beyond the bare schema type string.

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: switching an ongoing Socratic coaching session to simple mode. It also clarifies the resulting behavior (abandon remaining questions, run the 10-step template, archive to scenario library), which distinguishes it from siblings such as continue_coaching or abandon_coaching.

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 '进行中的' establishes the required context: this applies to an ongoing coaching session. However, it does not explicitly name alternatives or state when not to use it, such as when the session is already in simple mode or should instead be continued or abandoned.

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 the description carries the full behavioral burden. It usefully discloses that 「别问了」 abandons the round and 「直接说」 downgrades to simple mode, which is real behavioral context. However, it doesn't state session-state effects (does abandoning end the session?), persistence, or error behavior for an invalid session_id.

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-loads the core action, then the reply protocol, then Args/Returns. Efficient overall, though the Args/Returns block partly restates the intro (the reply options reappear in user_input).

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 briefly notes the return (next question or final result), and with no annotations it explains the interactive protocol. Sufficient for an agent to call it correctly, though session lifecycle and error handling remain unstated.

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

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

Schema coverage is 0%, so the description must compensate, and it does: session_id is explained as originating from start_coaching, and user_input is defined as either an option letter or instruction text. This meaningfully exceeds the bare schema, though exact accepted command strings are only illustrated, not enumerated.

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 (continue an in-progress Socratic multi-turn coaching session) and clearly distinguishes itself from coaching_start_coaching and coaching_abandon_coaching by implying an active session is required. An agent can tell what this 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?

Gives clear usage context: advance by replying with option letter (A/B/C/D), switch to simple mode with 「直接说」, or abandon with 「别问了」. It doesn't explicitly name sibling tools as alternatives, but the when-to-use condition (an in-progress session) is unambiguous.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that records are auto-generated on session completion and what each record contains (triggering event, variable structure, causal chain, conclusion), which is real context about the data. However it omits ordering, pagination, and any access/prerequisite behavior for a list operation.

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

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

Purpose is front-loaded in the first line, followed by useful archive context and the argument/return sections. No filler; the Returns line is a compact supplement to the missing output 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?

With no output schema, the description supplies the return shape ({"count": N, "scenarios": [...]}) and explains what a scenario record consists of, which is what an agent needs to consume the result. Missing only minor operational details such as sort order.

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 there is only one parameter, yet the description documents it directly ('limit: number of records, default 20'). This fully compensates for the schema gap, though it adds no detail beyond count semantics (e.g. no max or ordering interaction).

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 first line states a specific verb (列出/list) and resource (学习辅导情景记录/coaching scenario records), so an agent knows exactly what it fetches. It does not explicitly contrast with siblings like coaching_compare_history, but the resource is distinct enough to be actionable.

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 explicit when-to-use guidance or naming of alternatives. The second sentence describes how records are created ('auto-archived after every coaching session'), which implies the tool is for reviewing past sessions, but the agent must infer that this is the read/retrieval counterpart to the coaching_* write verbs.

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

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

With no annotations, the description carries the full burden. It does well on output shape for both modes, but omits that complex mode starts a persistent session (implied only by session_id), says nothing about permissions, cost/latency, or whether state is created and how it is torn down.

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 action and the branching rule, then structured Args/Returns. Every line adds information; the only mild bloat is the conventional docstring headers rather than prose.

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, and the description compensates by enumerating the return payloads for both modes (status/mode/answer/scenario_id vs. session_id/question/options). Combined with the mode-selection logic, an agent has enough to call and interpret results 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 0% and the schema declares no enum for mode, so the description must compensate: it explains user_input with a concrete example and enumerates the legal mode values ('simple' or 'complex') plus the default-by-omission behavior. That closes the biggest gap, though it doesn't cover input length or language expectations.

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 (启动学习辅导/start coaching on an investment question) and immediately distinguishes two operating modes with concrete examples ('该不该买XX' → simple, '为什么XX和YY走势背离' → complex). An agent can tell exactly what this does and how its behavior branches.

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 for when each behavior fires and how to force it via mode; the auto-detection rule is explicit. It does not name the follow-up siblings (continue_coaching, abandon_coaching) that a complex-mode session implies, so routing after invocation is left 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?

With no annotations, the description carries the full burden and does well: it discloses that 3-5 masters are auto-matched, that each independently calls an LLM, and that a host synthesizes the debate. These internal mechanics imply meaningful latency/cost that an agent should anticipate, though auth requirements and idempotency are 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?

Well front-loaded: purpose first, then behavior, then Args and Returns. Each block earns its place, and there is no redundancy, though the Args/Returns headers are the only structuring beyond the prose.

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 steps up and names the return structure (scene/masters/rounds/verdict), and it explains the parameter. An agent could call it correctly, though the lack of when-to-use routing leaves a minor gap given same-domain siblings.

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

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

Schema coverage is 0% for the single 'topic' parameter, so the description must compensate. It does by giving a concrete example topic ('贵州茅台当前估值合理吗？'), which clarifies the expected input far better than the bare schema string type.

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

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

The description states a specific verb+resource: simulating a structured roundtable discussion among 3-5 semantically matched investment masters. It is concrete about the output (scene/masters/rounds/verdict), but it never distinguishes itself from sibling tools like rag_ask_investment or rag_get_master_view, which also surface master perspectives.

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 a use case (wanting a multi-master structured debate rather than a single answer), but gives no explicit when-to-use guidance. It does not name alternatives or state exclusion conditions, so the agent must infer when this beats rag_ask_investment.

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 usefully discloses the upstream source ("Sina") and admits it is "Simplified," but then describes a return payload that contradicts the tool's own name, leaving the agent unsure what it actually receives.

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 sentence plus compact Args/Returns blocks; nothing is padded. The Returns block is short but is the source of the semantic error, which keeps this out of 5 territory.

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 is solely responsible for explaining returns — and it states the wrong thing (index name and value instead of constituent list). For a data-retrieval tool with one undocumented parameter, that leaves a critical gap.

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

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

Schema coverage is 0% and the single index_code property has no schema description, so the description must compensate — and it does, giving concrete code examples ("000300" for CSI 300, "000001" for Shanghai). Format guidance is the one thing an agent needs here and it is present.

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?

"Get constituent stocks of an index" names a specific verb and resource, which is good on its own. But the Returns line then says the function gives "Index name and current value" rather than constituents, so the stated purpose contradicts itself. It also fails to differentiate from the near-identical sibling tushare_get_index_components.

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

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

No when-to-use guidance is offered, no preconditions, and no mention of the closely related tushare_get_index_components that an agent must choose between. The only hint is the parenthetical "(CSI300, etc)."

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

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

With no annotations, the description carries the full burden. It does disclose useful behavior: the proxy methodology (Shanghai Composite) and the shape of the return (index value, change %, sentiment reading). However, it says nothing about data source, freshness, or whether the single-index proxy has known limitations, so important behavioral context is missing.

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

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

Very short and front-loaded, leading with the purpose before the methodology and return shape. The 'Returns: dict:' block is slightly redundant prose for a no-output-schema tool but is not wasteful.

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

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

For a parameterless read tool with no output schema, the description covers what the tool does, the proxy it uses, and the return contents. It is adequately complete, with only source/freshness details 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?

The tool takes zero parameters, so there are no semantics to document and the baseline is a 4. The description correctly indicates the tool is invoked without arguments.

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

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

States a specific verb and resource ('Get overall market sentiment indicators') and clarifies the methodology by naming the Shanghai Composite as the proxy used. It is clear what the tool returns, though it offers no explicit differentiation from siblings like market_get_valuation or market_get_index_components.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. The agent must infer its role from the name alone, despite a crowded market_* sibling set that would benefit from routing 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?

No annotations are provided, so the description carries the full burden. It discloses the return shape (OHLCV fields), which is genuinely useful behavioral context, but omits auth requirements, rate limits, data range limits, and whether results are paginated.

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 one-line purpose followed by compact Args/Returns blocks with zero filler. Every line carries information the schema does not.

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 tool with no output schema and no annotations, the description covers the required parameter, the period options, and the return fields, which is close to sufficient. It could say more about ticker format across markets and any range limits, but nothing essential is missing for a correct call.

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

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

Schema description coverage is 0% and there are no enums in the schema, so the description must compensate, and it does: it documents both parameters, gives a ticker example ("600519"), and supplies the valid period values (daily/weekly/monthly) plus the default. This adds real meaning beyond the bare 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 (Get) and resource (historical K-line data for a stock), so the agent immediately knows what it produces. It does not distinguish itself from heavily overlapping siblings like tushare_get_daily_price, tushare_get_weekly_price, or market_get_stock_quote, which is the only clear gap.

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 choose this tool over the many sibling price/history tools, nor any prerequisites or exclusions. Usage is only implied by the name and the period parameter.

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

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

No annotations exist, so the description carries the full burden. It usefully discloses the return shape (current price, change %, volume), which substitutes for the absent output schema, but says nothing about data freshness, source, rate limits, or market coverage.

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-loads the purpose in one clear sentence, then uses compact Args/Returns sections. The boilerplate scaffolding is slightly verbose but every line carries information and nothing is padded.

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

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

For a single-parameter read tool with no output schema and no annotations, the description covers the essential purpose, input format, and return fields. Remaining gaps (data source, latency, exchange coverage) are minor for this simple operation.

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

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

Schema description coverage is 0% and the schema only names the param 'Ticker', so the description's examples ('600519', 'sh600519', '贵州茅台') add real value by revealing accepted format variants including a prefixed code and a Chinese name, which would otherwise be ambiguous.

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: 'Get real-time quote for a stock ticker.' This separates it from market_get_stock_history, but it does not differentiate from the very similar sibling tushare_get_realtime_quote, leaving the agent to guess which realtime source 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?

No explicit when-to-use or when-not-to-use guidance, and no alternative named despite multiple overlapping siblings (tushare_get_realtime_quote, market_get_stock_history). 'Real-time' implicitly contrasts with historical data but nothing is stated.

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

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

No annotations exist, so the description carries the full burden. It does disclose a meaningful trait beyond the schema: the Sina source returns only limited, price-based fundamentals rather than full valuation metrics, which sets correct expectations. It says nothing about auth, rate limits, or failure modes.

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

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

The description is short and front-loaded, with the key limitation stated before the Args/Returns sections. The Returns line is mildly redundant with the opening sentence but nothing is bloated.

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 annotations, no output schema, and one undocumented parameter, the description covers the basics but not the specifics. It does not say which price-based metrics are returned or how this tool relates to the overlapping valuation sibling.

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

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

Schema coverage is 0% and the single parameter has no schema description, so the description must compensate. It does add value by defining ticker as a stock symbol with a concrete example ('600519'), but it omits exchange/prefix conventions and any format constraints.

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

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

The description gives a clear verb+resource ('Get valuation data for a stock'), so an agent knows what it does. However, it never distinguishes itself from the sibling 'tushare_get_valuation_multi' or from quote/history tools, so the agent cannot tell which valuation source 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?

There is no when-to-use guidance, no statement of when not to use it, and no named alternative despite several closely related siblings (tushare_get_valuation_multi, market_get_stock_quote). The only contextual note is about data source limitations, not tool selection.

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

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

With no annotations, the description carries the full behavioral burden. It helpfully discloses the shape and flavor of the return value with concrete examples, but says nothing about whether these patterns are precomputed or derived on demand, what happens when no history exists, or any auth/permission requirement.

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?

Short and front-loaded: the purpose sentence comes first, followed by a compact return description. The 'Returns:' block is slightly code-doc flavored but earns its place given there is no output 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 zero-param read tool with no output schema, describing the return content with examples is exactly the right compensation. It could go further on empty-state or refresh behavior, but nothing essential for 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?

The tool takes zero parameters, so the schema baseline is 4. There is nothing further for the description to clarify about inputs, and it adds nothing misleading.

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

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

States a specific verb and resource ('Get identified behavior patterns from user's investment history'), which is clear on its own. However, it does not distinguish itself from similarly named siblings like pattern_get_pattern_summary or pattern_get_pattern_report, leaving an agent to guess 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?

There is no when-to-use guidance, no prerequisites, and no reference to any alternative tool. The agent is told what it returns but not under what circumstances to call it instead of the pattern_* 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?

No annotations are provided, so the description carries the full burden. It does disclose the return contents (risk preference, circle of competence, investment principles), which is real behavioral value for a getter with no output schema. It says nothing about access scoping, whether the profile is per-user/per-account, or freshness/caching, so it falls short of complete 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?

Two short lines, purpose front-loaded before the return summary. Nothing is wasted, though the 'Returns:' block formatting is slightly verbose for what is essentially one sentence of content.

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

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

For a no-param getter with no output schema, the description does give the caller a sense of the returned fields, which is the main thing needed. But with no annotations and a confusingly similar sibling (user_get_profile), the definition leaves the agent without enough to confidently select or scope the call.

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

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

The tool takes zero parameters, so there is nothing to document and the schema is trivially at 100% coverage. Baseline 4 applies; no parameter meaning is missing.

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: 'Get user investment profile.' That is unambiguous on its own. However, the sibling list contains a near-identical tool (user_get_profile), and the description does nothing to distinguish this memory_* variant from it, which is exactly the differentiation the 5-level requires.

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 alternative to prefer. Given the presence of user_get_profile and memory_get_behavior_patterns, a routing hint would have been genuinely valuable and is entirely absent.

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

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

No annotations are provided, so the description carries the full burden. It implies a mutation (recording) and mentions a confirmation return, but does not disclose persistence semantics, authentication needs, duplicate handling, or whether decisions are overwritten or appended.

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 core purpose, then structured Args/Returns. Efficient and readable, with no padding, though it does not encode any actionable constraints.

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-object write tool with no annotations and no output schema, the description is adequate but thin. It names the fields but omits required-vs-optional status, validation rules, and error behavior, leaving real gaps.

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

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

Schema description coverage is 0% and the single parameter is an opaque nested object with additionalProperties=true. The description compensates by enumerating expected fields (ticker, action, price, reason, timestamp), adding real 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+resource: 'Record an investment decision made by the user.' This clearly separates it from siblings like user_record_activity or thought_record_thought. However, it does not explicitly name what makes it distinct from those recording-style 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?

No when-to-use guidance, no prerequisites, and no alternatives named. The agent must infer that this is for logging investment decisions and cannot tell from the description when it should prefer this over thought_record_thought or user_record_activity.

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 exist, so the description carries the full burden. It does add real behavior: send_test sends a message immediately, defaults for enabled/send_test, and that the return value is config status for ALL channels plus the test result. But it never states whether re-configuring overwrites prior settings, whether credentials are required, or whether changes persist across sessions.

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 one-line purpose followed by a tight Args block and a Returns line; every entry maps to a real parameter. The Google-style docstring formatting is slightly boilerplate-heavy for five fields 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 5-parameter mutation tool with no annotations and no output schema, the description covers all parameters and describes the return shape itself. The remaining gap is mutation semantics (overwrite vs. merge, persistence), which leaves it just short of complete.

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

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

Schema description coverage is 0%, so the description must compensate and largely does: it enumerates supported channel values (feishu, dingtalk, bark, pushplus), scopes webhook_url to webhook-based channels and token to pushplus only, and gives defaults for enabled and send_test. It does not say what happens with an unsupported channel value.

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: 'Configure a notification channel.' An agent can tell it apart from the sibling notify_get_notifier_config (read side) by the verb alone. It does not name the sibling explicitly, so it stops short of 5.

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

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

There is no when-to-use / when-not-to guidance: nothing says whether configuring overwrites an existing channel, whether notify_get_notifier_config should be called first, or which channel to pick. Usage is only implied by the verb 'Configure'.

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 describes the return structure and implies a read-only getter, but does not explicitly state read-only behavior, permission requirements, or side effects.

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 the core action and includes a compact return example. Every sentence and the example add useful context without waste.

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 zero-parameter getter with no output schema, the description supplies the essential return shape with an example. It is adequate, though not exhaustive about each channel's configuration fields.

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

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

The tool takes zero parameters, so the baseline is 4. The description does not need to explain parameter semantics further.

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 (Get) and resource (notification configuration) with scope (all channels), so the operation is clear. It does not explicitly distinguish itself from the sibling notify_configure_notifier, which keeps it from a 5.

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

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

Provides no guidance on when to use this tool versus alternatives, no prerequisites, and no mention of the related configure tool. The agent must infer 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?

No annotations are provided, so the description bears the full burden. It discloses the return shape (report path and Markdown content), which implies a file is written to disk, but it never states that side effect explicitly, nor whether detection is triggered, whether output is cached, or whether the call is 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?

Front-loaded with the purpose in the first line, then Args and Returns blocks. There is minor docstring boilerplate (empty type hints, 'dict:' label) that adds nothing, but nothing is wasted overall.

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

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

With no annotations and no output schema, the description does cover the return payload, which is helpful. It stops short of describing what the report actually contains, how long a 'weekly' window is anchored to, or where the file path points — all decisions the caller might care about.

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 is the only source of meaning for the single parameter, and it fully compensates by enumerating the two valid values ('weekly' or 'monthly') and naming the default. Only the enum constraint is left to the schema's bare string type.

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 ('Generate a behavior pattern report') plus the output format (Markdown). It is distinguishable from pattern_get_pattern_summary only by the word 'report', but the sibling tools themselves are not referenced, so differentiation is implicit rather than explicit.

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

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

No guidance on when to use this versus pattern_run_pattern_detection or pattern_get_pattern_summary, and no stated prerequisite that pattern detection must have run first. The agent must infer the workflow from the sibling list alone.

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

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

With no annotations, the description carries the full burden, and it does disclose the return shape (pattern type -> {count, last_seen}) plus a non-obvious behavioral trait: the prompt_hint for proactive user engagement. It omits permissions, data freshness/staleness, and whether the summary is cached, so the disclosure is partial rather than complete.

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

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

Short and front-loaded: the purpose sentence comes first, followed by a compact return description. The docstring-style 'Returns: dict:' formatting is slightly mechanical but not wasteful.

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

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

For a zero-parameter, no-output-schema read tool, the description supplies the essential return structure and the prompt_hint semantics, which is enough to call it correctly. Absent annotations, a note on read-only safety or data freshness would have made it fully complete.

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

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

The tool takes zero parameters, so there is nothing for the description to disambiguate; the baseline for a no-arg tool applies.

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

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

States a specific verb and resource: 'Get cumulative summary of all detected behavior patterns.' It is distinguishable from siblings like pattern_run_pattern_detection and pattern_get_pattern_report by the 'cumulative summary' framing, though it does not explicitly contrast itself 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?

Usage is implied rather than stated. The mention of a prompt_hint 'for the agent to decide whether to proactively engage the user' hints at the intended use, but there is no explicit when-to-use guidance or routing versus pattern_get_pattern_report or pattern_run_pattern_detection.

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

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

With no annotations, the description carries the full burden, and it does add real value by disclosing that results are written to the behavior_patterns table (a mutation side effect) and by summarizing the return shape. It still omits whether the run is idempotent, how expensive it is, what happens with zero recorded data, and whether any permission is needed.

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 first sentence front-loads the action and scope, and the detection list plus persistence note are compact. The trailing 'Returns:' block with a Python-style 'dict:' line is slightly noise for an agent but still short and informative.

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 zero-parameter tool with no annotations and no output schema, the description covers the action, the detected patterns, the persistence target, and the return contents, which is most of what is needed. It stops short of routing guidance relative to the read-side siblings and of stating preconditions (e.g., needing previously recorded decisions).

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

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

The tool takes zero parameters, which is the baseline-4 case. The empty schema is fully covered, and there are no argument semantics the description could add.

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

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

The description uses a specific verb+resource ('Run behavior pattern detection on all recorded decisions and thoughts') and enumerates the four Chinese pattern names it detects, so the scope is concrete. It does not, however, differentiate itself from close siblings like pattern_get_pattern_summary, pattern_get_pattern_report, or memory_get_behavior_patterns, which an agent must distinguish from this one.

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 explicit when-to-use guidance and no mention of alternatives. An agent cannot tell from the text whether this should be run before pattern_get_pattern_summary/get_pattern_report, or whether it is safe to call repeatedly. Usage is only weakly implied by 'on all recorded decisions and thoughts'.

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

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

No annotations are provided, so the description carries the full burden. It does disclose that the response is a dict with source citations drawn from a 'master knowledge base', which is useful output context absent an output schema, but says nothing about scope, latency, auth, or how it handles unanswerable questions.

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?

Short and front-loaded, with the core action in the first sentence. The Args/Returns boilerplate is slightly redundant but not wasteful for a single-parameter tool.

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

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

For a one-parameter, no-annotation, no-output-schema tool, the description covers purpose, the input, and the return shape. It is still incomplete on the key decision an agent faces: when to use this Q&A tool versus the other rag_* search tools.

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

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

One parameter at 0% schema description coverage, so the description must compensate. It names the parameter and gives a concrete natural-language example ('什么是护城河？'), which usefully signals free-text phrasing rather than a keyword or ID, but adds little beyond that.

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

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

States a clear verb (ask) and resource (investment question) and specifies the output is a RAG-augmented answer with source citations. However, it never distinguishes itself from close siblings like rag_search_knowledge, rag_rag_search_reports, or rag_get_master_view, which an agent must choose between.

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 explicit when-to-use, when-not-to-use, or alternative-tool guidance. The only signal is the implied 'investment question' framing, which does not tell the agent how this differs from the other rag_* retrieval tools.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the return shape ('dict: Master's view on the topic with citations'), which is genuinely useful for a retrieval tool, but it says nothing about behavior when the master or topic is unknown, whether the view is cached/generated, or any access constraints.

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

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

The one-line purpose is front-loaded, followed by compact Args/Returns sections with no filler. Slightly over-formatted for only two parameters, 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?

With no output schema and no annotations, the description is the only source of truth, and it covers inputs plus the rough return shape. It leaves open the routing question against sibling RAG tools and any failure behavior, which matters for a tool whose only inputs are free-text names.

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% – the schema lists only bare string types for 'master' and 'topic'. The description compensates by documenting both parameters and supplying concrete example values in the target language, which is well beyond what the schema offers. It stops short of enumerating the valid master set, so an agent could still guess an unsupported name.

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

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

The first line states a specific verb and resource ('Get a specific master's view on a topic'), which is unambiguous on its own. It does not, however, distinguish itself from near-neighbors like rag_ask_investment, rag_search_knowledge, or rag_rag_search_reports, so an agent cannot tell from the description alone which RAG tool 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?

Usage is only implied through the argument examples (masters 巴菲特/芒格/段永平, topics 护城河/安全边际), which signal a value-investing wisdom lookup. There is no explicit statement of when to use this versus the sibling RAG tools, and no exclusions or prerequisites are given.

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

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

No annotations are provided, so the description carries the burden. It usefully discloses that results are limited to recently ingested reports (最近入库) and that each hit carries a distance/similarity score, but it omits auth requirements, result caps, and whether the corpus is date-bounded.

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 one-line purpose, then Args and Returns in a scannable structure. The Returns block is long but justified since no output schema exists; nothing is wasted, though the block could be trimmed to field names.

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

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

With no output schema and no annotations, the description does the heavy lifting well: it documents both parameters and the full return shape. The remaining gap is the absence of any routing guidance against the many sibling search/retrieval tools.

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

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

Schema description coverage is 0%, so the description must compensate — and it does: query is explained with concrete example phrasings ("宁德时代 业绩", "保险 增长") and top_k is given its default of 5. Only the allowed range/upper bound of top_k is left unspecified.

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

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

The description states a specific verb and resource (搜索券商研报) plus the retrieval mechanism (基于语义向量检索), and enumerates the fields returned (机构、股票、行业、评级、盈利预测). This is clearly distinct from generic knowledge search, though it never names the sibling tools (rag_search_knowledge, user_knowledge_search) it must be chosen over.

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 explicit when-to-use or when-not-to-use guidance. The description implies report search, but with siblings like rag_search_knowledge, rag_ask_investment and user_knowledge_search available, the agent gets no routing criteria for picking this tool.

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

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

No annotations are provided, so the description carries the full behavioral burden. It implies a read-only search and loosely notes the return shape ('list: Matching knowledge entries'), but says nothing about result limits, ranking, pagination, or required permissions. For a search over a knowledge base with zero annotation coverage, this is thin.

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?

Short and front-loaded: purpose first, then a compact Args/Returns block with no filler. The docstring-style formatting is slightly robotic but every line 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, no-output-schema read tool, the description covers the essentials an agent needs to invoke it. It falls short only on the sibling disambiguation and return-detail front, neither of which is fatal at this complexity level.

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

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

Schema coverage is 0% and the single parameter has no schema-level description at all, so the description must compensate. It does add value by giving concrete example queries ('价值投资', '周期'), clarifying that this is a semantic/free-text lookup rather than an ID lookup, but it does not specify language handling or query length constraints.

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

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

States a clear verb+resource ('Search the investment knowledge base'), which is better than a tautology. However, it does not distinguish this tool from several close siblings such as rag_rag_search_reports, rag_ask_investment, or user_knowledge_search, so an agent cannot tell which search surface to pick without opening 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?

No when-to-use guidance is given and no alternative is named. With siblings like rag_ask_investment (question answering) and user_knowledge_search (user-specific knowledge) present, the absence of routing guidance leaves the agent to guess.

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

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

With no annotations, the description carries the full behavioral burden. It implies a destructive mutation but says nothing about irreversibility, whether the ID must exist, error behavior, or permissions. Only the single line 'Returns: dict: Deletion confirmation' adds any behavioral signal.

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, with the core action in the first sentence. The 'Args/Returns' boilerplate restates what the schema already shows for a single obvious parameter, so it is slightly padded but not wasteful.

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

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

A destructive tool with no annotations and no output schema, so the description must compensate - and it does not. Nothing covers irreversibility, failure on unknown IDs, or side effects, leaving an agent without the context needed to call it safely.

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

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

Schema coverage is 0% and the schema only titles the field 'Id'. The description clarifies it is a 'Reminder ID to delete', adding modest meaning beyond the bare schema, but no format, example, or constraint (e.g., ID shape) is provided.

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 ('Delete a reminder by ID'), which cleanly separates it from siblings reminder_get_reminders and reminder_set_reminder. Clear, but it never names those siblings or explains the distinction 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?

No when-to-use, when-not-to-use, or alternative guidance is given. The agent must infer the context entirely from the name; there is no mention of prerequisites or of the related get/set reminder tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. 'Active' hints that inactive/completed reminders are filtered out, which is useful, but there is nothing about ordering, pagination, ownership scoping, or side effects — thin for a tool with zero annotation coverage.

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

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

Two short lines, front-loaded with the action, with no wasted prose. The 'Returns' block mildly restates the first sentence, but the cost is trivial.

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

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

For a no-parameter, no-annotation list tool with no output schema, the description supplies the minimum needed: what is fetched and the rough shape of the return value. It could go further on filtering or ordering, but the tool's simplicity keeps the gap small.

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

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

The tool takes zero parameters, so per the rubric the baseline is 4. There is nothing for the description to explain beyond what the empty schema already conveys.

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 ('Get') and resource ('reminders') with a clear scope qualifier ('all active'). It does not name or differentiate from the sibling reminder_set_reminder/reminder_delete_reminder, but the nouns make the read-vs-write split obvious.

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

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

No when-to-use guidance, no exclusions, no mention of alternatives such as reminder_set_reminder or reminder_delete_reminder. The agent must infer that this is the listing operation purely from the name.

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

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

With no annotations, the description carries the full behavioral burden. It discloses that a reminder is created and returned with an ID, and gives condition examples, but does not describe persistence, duplicate handling, permissions, notification behavior, or error cases.

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 the core action and uses a clean Args/Returns structure. The examples are useful rather than redundant, though the formatting is slightly verbose for a single-parameter tool.

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

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

The tool has one nested object parameter and no output schema. The description explains the condition shape with examples and briefly states the return value, which is enough for correct invocation, though more detail on supported condition types and side effects would improve completeness.

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

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

Schema description coverage is 0%, but the description compensates strongly with concrete condition examples covering price, time/cron, and pe_ratio triggers including fields like ticker, operator, value, and cron. This adds substantial meaning beyond the bare object 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: "Set a reminder with trigger condition." It is clear what the tool does and distinguishable from reminder listing/deletion siblings by name, though it does not explicitly differentiate itself from 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?

Provides no guidance on when to use this tool versus alternatives such as reminder_get_reminders or reminder_delete_reminder. Usage is only implied by the tool name and the word "Set."

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

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

No annotations are provided, so the description carries the full burden. It discloses the return shape ('summary, insights, highlight, and report file path'), which hints that a report file is produced, but never states the write/side-effect, permissions, or whether calling it repeatedly overwrites output.

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-loads the purpose in one sentence, then uses clearly labeled Args and Returns blocks. Every element earns its place, with only minor redundancy between the opening sentence and the Args section.

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

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

For a one-parameter tool with no output schema, the description covers purpose, argument, and return contents adequately. It falls short on sibling differentiation and on the side effects of generating/writing a report, which an agent scheduling this call would need to know.

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

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

Schema coverage is 0%, so the description must compensate, and it does: it documents the single 'range' argument, its accepted values ('week'/'month'), and its default. The only gap is that it offers no guidance on choosing month over week.

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 ('Generate a behavior pattern report') with scope (week/month), so the agent knows what it produces. However, it does not distinguish itself from the sibling pattern_get_pattern_report or pattern_run_pattern_detection, leaving ambiguity about which pattern tool 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?

The note 'Designed to be called on a schedule by the agent (e.g. every Sunday)' implies a usage context, which is better than nothing. But it gives no explicit when-to-use vs. the pattern_* siblings and no conditions under which it should not be called.

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. 'Get' implies a read, but it says nothing about ordering, pagination, whether archived/stale cards are included, or what happens when the ticker has no cards (empty list vs error).

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

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

Very short and front-loaded: the core behavior is in the first sentence, followed by docstring-style Args/Returns blocks. No filler, though the Args block largely restates the single parameter name.

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

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

For a one-parameter read tool with no output schema, the description at least names the return shape ('list: all thought cards for this ticker'). Still missing are the return fields, ordering, and empty-result behavior, which an agent would need to use the output 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 0%, so the schema alone gives no meaning for 'ticker'. The description partially compensates by giving concrete example values in both Chinese and English ('贵州茅台', 'AAPL'), clarifying that local symbols are accepted, but it does not explain ticker normalization or whether exchange suffixes are required.

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

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

States a specific verb and resource ('Get all thought cards') and scopes it to a single ticker/symbol, which is clear. It does not, however, distinguish itself from near-siblings like thought_search_memories or thought_record_thought, so an agent must infer the boundary.

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

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

There is no when-to-use guidance, no exclusions, and no named alternative despite several related thought/memory tools in the sibling list. The agent is left to guess whether this is for retrieval by symbol only or overlaps with memory search.

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

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

No annotations are provided, so the description carries the full burden. It does disclose the return shape ('a thought card with parsed entities and card ID'), which is useful. However, it does not state that this persists data, whether it requires auth, or whether duplicate thoughts are deduplicated.

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 the Args/Returns structure is easy to scan. The docstring formatting (indentation, 'Args:'/'Returns:') is mildly verbose 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 single-parameter tool with no output schema, the description covers the input example and the return content, which is most of what an agent needs. It omits side-effect and persistence details, but the core invocation is well-enough specified.

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

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

Schema coverage is 0% (bare {type: string}), so the description must compensate. The example ('茅台跌到1400可以考虑买入') adds helpful meaning about what qualifies as a thought, but no format, length, or constraint guidance is given, leaving the compensation partial.

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 ('Record') and resource ('an investment thought/idea from the user'), which cleanly separates it from read-oriented siblings like thought_search_memories and thought_get_thought_cards. It does not explicitly name or contrast with any sibling, so it stops short of a 5.

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

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

There is no explicit when-to-use, when-not-to-use, or alternative guidance. 'from the user' weakly implies the trigger is user-shared thoughts, but no conditions or routing advice are given, matching the score-2 'no guidance' level.

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

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

With no annotations, the description carries the full burden, and it does disclose two useful traits: retrieval is semantic (not keyword) and results are sorted by relevance. It omits pagination, result-count limits, and any auth or scope constraints.

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

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

Front-loaded purpose sentence followed by short Args/Returns blocks; every line carries information. The Args/Returns scaffolding is slightly heavier than needed for one parameter but is not wasteful.

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

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

For a single-parameter read tool with no output schema, the description usefully explains the return shape (matching thought cards sorted by relevance), which compensates for the missing output schema. It is still thin on result volume and pagination behavior, leaving a small gap.

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

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

Schema coverage is 0% and the single 'query' property has no description, so the description must compensate. It supplies the parameter name plus two illustrative queries ('茅台', '上次关于苹果的想法'), which conveys that natural-language or mixed-language input is expected, but adds no syntax or length guidance.

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: searching the user's historical thoughts and memories, with the retrieval mode (semantic search) named. It is distinguishable from list-style siblings like thought_get_thought_cards, though it does not name any sibling explicitly.

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

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

No guidance on when to prefer this over the many adjacent tools (thought_get_thought_cards, rag_search_knowledge, memory_get_behavior_patterns). The example queries imply it is for fuzzy recall, but the agent is left to infer the routing decision.

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 the return content ('Token status and user info') and the read-only nature of a 'check', but says nothing about auth requirements, failure modes, or what an invalid/missing token yields.

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 states the action and condition, followed by the return type. Nothing is wasted and there is no filler.

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

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

For a zero-parameter, no-output-schema utility, the description covers what it does and what it returns. It stops short of describing failure/invalid-token behavior, which would fully complete it.

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

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

The tool takes no parameters, which is the baseline-4 case. No parameter semantics need explaining, and the empty schema is fully consistent with the description.

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

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

States a specific verb ('Check') and resource ('Tushare token') with the exact condition tested (configured and valid). Among the many tushare_* siblings that fetch market data, this one's configuration/status-check purpose is unmistakable.

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

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

Usage is only implied: an agent can infer you call this before other tushare tools to verify credentials. No explicit when-to-use, no prerequisites, and no named alternative (e.g. what to do if the token is invalid) are given.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that the input may be either Tushare format or a plain number, and that a Tushare-format string is returned, which implies a pure/idempotent conversion. However, it says nothing about error behavior for invalid tickers, case sensitivity, or market-suffix handling.

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 core purpose in one sentence, followed by a compact Args/Returns block. No wasted text; the only mild redundancy is restating the return type already covered by the output 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 single-parameter conversion utility with an output schema present, the description covers input formats and the returned type adequately. The main remaining gap is the absence of usage context relative to the many sibling tools, but as a standalone converter it is essentially complete.

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

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

Schema coverage is 0% and the single parameter is only typed as string in the schema. The description compensates by explaining the parameter accepts either Tushare format (600519.SH) or a plain number (600519), giving concrete examples that materially add meaning beyond the bare 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 (convert) and resource (stock ticker to Tushare format), which is unambiguous. It is distinguishable from the data-fetching tushare_* siblings as a pure formatting utility, though it doesn't explicitly name or contrast those 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?

There is no explicit when-to-use or when-not-to-use guidance. The usage is only implied by the name and the 'Args' note. An agent must infer that this should be called to normalize a ticker before passing it to other Tushare tools.

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

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

No annotations are provided, so the description carries the full behavioral burden. It says only that the result is a dict and does not disclose permissions, data freshness, rate limits, pagination, or behavior when period is omitted.

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

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

Front-loads purpose and uses a compact Args/Returns structure with little wasted text. The return line 'dict: Balance sheet data' is minimally informative but not verbose.

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

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

Covers the call parameters and basic return type for a simple retrieval tool. However, with no annotations and no output schema, the vague return description leaves the agent without field-level context, and optional-period behavior is undocumented.

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%, but the description documents both parameters: ts_code as a Tushare stock code with an example, and period as a YYYYMMDD reporting period. It still omits optional/default behavior for period, 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 ('Get') and resource ('balance sheet data'), and identifies the Tushare endpoint. It does not explicitly differentiate from sibling financial-statement tools such as tushare_get_income_statement or tushare_get_cash_flow, so it is clear but not sibling-differentiating.

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

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

Provides no when-to-use or when-not-to-use guidance. It does not say when to choose this over sibling financial statement tools, nor does it mention prerequisites; usage is only implied by the tool name.

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

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

With no annotations, the description partially discloses behavior: "Get" implies a read-only retrieval and it states the return type is a dict. However, it omits permissions, rate limits, pagination, and any detail about the returned cash-flow data structure.

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

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

The description is short and front-loaded with the purpose, then standard Args/Returns sections. The return line is vague but the overall structure is efficient with little waste.

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

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

For a simple two-parameter read tool, the description is sufficient to make a call, but it lacks explicit period optionality and gives no useful return-shape detail despite there being no output schema. Completeness is adequate but has clear gaps.

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

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

Schema coverage is 0%, so the description must carry parameter meaning. It does document both parameters: ts_code as a Tushare stock code with an example, and period as YYYYMMDD. It does not note that period is optional/defaulted, which keeps 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?

The description states a clear verb and resource: "Get cash flow statement," and identifies the upstream Tushare API. It is distinguishable from income statement and balance sheet siblings by resource name, though it does not explicitly route between 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?

There is no guidance on when to use this tool versus sibling financial-statement tools such as income statement, balance sheet, or financial indicator. Usage is only implied by the tool name and resource.

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

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

With no annotations, the description carries the full burden, and it does disclose useful behavior: default date window (30 days ago to today), date format, and the returned OHLCV fields. It omits Tushare-specific operational traits such as token/authentication requirements (a sibling tool checks token status), rate limits, and history-depth 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?

Front-loaded one-line purpose followed by Args/Returns sections; every line carries information. The docstring formatting is slightly verbose 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 3-parameter tool with no annotations and no output schema, the description covers inputs and return fields adequately. It falls short on operational context: authentication/token prerequisites, rate limits, and whether the date range is inclusive or capped are all 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 coverage is 0% (only titles and empty defaults), so the description must compensate, and it does fully: ts_code format with a concrete example and exchange codes (SH/SZ), plus YYYYMMDD formats and defaults for both date parameters. An agent could call this correctly without ever reading 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 ('Get daily price data for a stock') and anchors it to the Tushare 'daily' endpoint, so the agent knows exactly what data comes back. It does not explicitly distinguish itself from siblings like tushare_get_weekly_price, tushare_get_realtime_quote, or market_get_stock_history, leaving the 'daily' qualifier to do the differentiation implicitly.

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 explicit when-to-use or when-not-to-use guidance. The description never mentions the sibling tools that overlap heavily (weekly price, realtime quote, market history) nor states that this is for historical end-of-day data only, so the agent must infer routing from the name alone.

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

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

With no annotations, the description carries the full behavioral burden. It implies a read via 'Get' and mentions the return is a dict, but does not disclose Tushare authentication requirements, rate limits, which reporting period or frequency the indicators cover, or whether data is cached. Coverage is thin for a domain tool requiring a token.

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 readable, but the 'Args:' section merely restates the single schema field, and the 'Returns:' line adds little ('dict: Financial indicators' just echoes the title). Some boilerplate that could be trimmed, though nothing is egregious.

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 single-parameter tool with no output schema, the essentials are present: it says what the tool returns in general terms. Gaps remain around data period/frequency and the meaning of the returned fields, but for this complexity level it is minimally viable.

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

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

Schema coverage is 0%, so the description must compensate. It does add value by giving the ts_code format example ('600519.SH'), which the schema omits entirely. It doesn't explain whether the code is optional, case-sensitive, or how other exchanges are formatted, so compensation is partial.

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 ('Get financial indicators for a stock') and names the source API and some fields (PE, PB, ROE, gross margin). However, it does not distinguish itself from siblings like tushare_get_valuation_multi or market_get_valuation, which also surface valuation metrics, so the boundary is left implicit.

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

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

No when-to-use guidance, no prerequisites, and no named alternatives. The agent must infer from the sibling list whether this or market_get_valuation is appropriate. Only the underlying API name hints at its scope.

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

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

No annotations are provided, so the description carries the full disclosure burden. It mentions the return is a dict of income statement data, but never states that this is a read-only operation, whether it requires authentication, rate-limit behavior, or how stale/complete the data is. For a data-fetch tool with zero annotation coverage this is thin.

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?

Short and front-loaded, with the core purpose in the first line and parameters/return grouped after. The parenthetical Tushare API note is minor filler but nothing is bloated.

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 tool with no output schema and no annotations, the description covers the basics of inputs and return type. It still omits when-to-use guidance and the omission behavior of the period default, leaving meaningful gaps.

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

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

Schema description coverage is 0%, so the description does add value by giving both parameter names with format guidance and examples (e.g., "600519.SH", "20250331"). However, it never explains the schema's default of empty string for period or what happens when period is omitted, which is the semantically important gap.

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

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

States a specific verb and resource (get income statement / P&L) plus the upstream API it wraps, which is enough to distinguish it from siblings like tushare_get_balance_sheet and tushare_get_cash_flow. It never names those siblings explicitly, so differentiation is implied rather than stated.

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

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

The description says nothing about when to call this versus the other financial-statement tools, nor any prerequisites such as needing a valid token or a listed stock code. Usage is left entirely to inference from the tool name.

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

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

No annotations are provided, so the description carries the full behavioral burden. It mentions the underlying Tushare endpoint and return shape, but it does not disclose permissions/auth needs, rate limits, data freshness/as-of semantics, or error behavior for a 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 front-loaded with the core action and uses an Args/Returns structure without redundant text. Every sentence contributes to understanding the call or return value.

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

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

For a simple one-parameter retrieval tool with no output schema, the description adequately states the input example and the return content: constituent stocks with weights. It could be more complete by documenting that index_code is optional with a default and by stating data freshness or as-of behavior.

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

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

The schema provides no description for index_code, so the description must compensate. It explains that the parameter is an index code and gives a concrete example, "000300.SH" for CSI 300, though it does not clarify the default value or broader accepted formats.

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

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

The description gives a specific verb and resource: "Get constituent stocks of an index." It clearly identifies the returned data, but it does not distinguish this tool from the sibling market_get_index_components or explain the Tushare-specific variant.

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 does not say when to choose this tool over alternatives such as market_get_index_components, nor does it state any prerequisites or exclusions. Mentioning "Tushare API: index_weight" is an implementation detail, not usage 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?

No annotations are provided, so the description carries the full burden, yet it only says it returns OHLCV data. It omits anything about Tushare token/points requirements, rate limits, or what an empty date range does, all of which matter for a data-fetch tool with no annotation safety net.

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 purpose followed by a clean Args/Returns docstring layout with no filler. Every line is functional, though the Returns line is nearly redundant with the purpose line.

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 three-parameter read tool with no output schema or annotations, the description is minimally adequate: it covers purpose, parameter formats, and a rough return shape. It still leaves auth/tier requirements and empty-date-range behavior 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 coverage is 0%, but the description does compensate partially by giving the YYYYMMDD date format and real index_code examples (000300.SH, 000001.SH) that the schema lacks. It fails to explain the default empty-string values for start_date/end_date, leaving the coverage gap only half closed.

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 (Get) and resource (index daily K-line) plus the upstream Tushare API name. The 'index' scope implicitly separates it from tushare_get_daily_price/weekly_price, but no sibling is named explicitly, so it stops short of a 5.

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

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

There is no guidance on when to use this versus tushare_get_daily_price or tushare_get_index_components, no mention of prerequisites, and no exclusions. The agent must infer the use case purely from the tool name.

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

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

No annotations are provided, so the description carries the full burden. It discloses the return content (SW industry, Shenwan classification) and the backing API endpoints, but says nothing about auth/token requirements, rate limits, failure modes, or fallback behavior when classification is unavailable.

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 purpose sentence, then compact Args/Returns sections. The structure is efficient, though the Args/Returns scaffolding is slightly heavier than the one-line payload warrants.

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 tool with no output schema, the description usefully names the return payload (SW/Shenwan industry), which is the main missing piece structured data would otherwise supply. It is adequate but leaves auth requirements and error/token behavior undocumented.

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

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

Schema coverage is 0% and the schema only labels the field 'Ts Code', so the description meaningfully compensates by specifying the Tushare stock code format with an example ('600519.SH'). No additional parameter nuance (exchange suffix handling, type) is given beyond that example.

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

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

States a specific verb and resource ('Get industry classification for a stock') and names the underlying Tushare sources, so the agent knows exactly what data is returned. No sibling tool competes for industry classification, so explicit differentiation isn't needed, but the description doesn't route against any alternative either.

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

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

There is no guidance on when to use this tool versus alternatives, no prerequisites, and no exclusions. Usage must be inferred from the name and resource alone.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it falls short: nothing about Tushare token/authentication requirements (notable given the sibling tushare_check_token_status), rate limits, or how many rows 'top' returns. The brief Returns line ('top gainers, losers, and most active stocks') is the only behavioral disclosure, and it slightly expands on the summary line.

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?

Short and front-loaded: purpose first, then Args and Returns. The Args/Returns scaffolding is slightly verbose for one optional parameter 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 one-parameter data fetch with no output schema, the description covers the purpose, parameter format, and rough return shape. It is still thin on authentication context and on what 'top' quantifies, which an agent would need to call it confidently.

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 single parameter has 0% schema description coverage, so the description must compensate — and it does, specifying the YYYYMMDD format and the 'default: today' behavior. That fully covers the only parameter, leaving little room for improvement.

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

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

States a specific verb and resource ('Get top gainers/losers for the day') and even names the underlying Tushare endpoint (top_list), so the agent knows it is a daily market-mover snapshot. It does not, however, contrast itself with siblings such as market_get_market_sentiment or market_get_stock_quote, so disambiguation relies on the name alone.

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

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

The description never says when to pick this over the many sibling quote/sentiment tools, nor does it state any prerequisites or exclusions. The only usage signal is the implied 'for the day' scope.

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 not meet it. It does not disclose rate limits, token/auth requirements, whether data is delayed, or freshness semantics — all relevant for a realtime market-data call.

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?

Short and front-loaded: purpose first, then the single argument with an example, then a brief return note. Minimal waste, though the Args/Returns skeleton is slightly verbose for one parameter.

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

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

For a simple one-parameter read tool the description covers purpose, the arg format, and a rough return summary, which is adequate. But with no output schema it only gestures at returns ('etc.') and omits freshness/auth context an agent would want before calling.

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

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

Schema coverage is 0% (the property is bare 'Ts Code'), so the description must compensate. It does add real value by giving the Tushare code format and an example ('600519.SH'), which the schema lacks. However it says nothing about exchange suffixes beyond the example or optional filtering.

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 ('Get') and resource ('realtime quote for a stock'), which clearly separates it from the daily/weekly price siblings. It does not explicitly differentiate from the near-synonym market_get_stock_quote, but the 'realtime' qualifier carries meaningful 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?

There is no explicit when-to-use or when-not-to-use guidance and no alternatives named. The word 'realtime' implies it is the intraday counterpart to tushare_get_daily_price, but the agent must infer this rather than being told.

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, yet it only says it returns 'pledge ratio and status'. It does not state that this is a read-only lookup, whether auth/token is required, rate limits, or error behavior. The 'Returns' line adds minor value but is thin for a zero-annotation 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 definition is short and front-loaded with the core purpose, followed by Args/Returns sections that are easy to scan. The docstring-style framing is slightly heavier than needed for one parameter 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 one-parameter retrieval with no output schema and no annotations, the description covers the input format and names the return fields, which is minimally adequate. However, the return value description ('Pledge ratio and status') is vague, leaving the agent unsure of the actual dict structure.

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

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

Schema description coverage is 0%, so the description must compensate for the single parameter—and it does by specifying 'Tushare stock code' with a concrete format example ('600519.SH'). This is meaningful detail absent from the bare string-typed 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 ('Get stock pledge status') and names the backing Tushare endpoint (pledge_stat), so the agent knows exactly what data it retrieves. It does not explicitly differentiate itself from the other tushare_* data endpoints, but the resource is narrow enough to be unambiguous.

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

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

There is no statement of when to use this tool versus siblings like tushare_get_valuation_multi or other fundamental endpoints, and no prerequisites or exclusions are given. The agent must infer usage from the name alone.

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

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

No annotations are provided, so the description carries the full burden. It notes the underlying 'daily + basic' Tushare APIs but does not disclose rate limits, auth requirements, list-size limits, or what fields the returned dict contains—significant gaps for a data-fetch 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?

Front-loaded purpose sentence followed by structured Args/Returns sections with no filler. Every line is relevant, though the Returns section adds little beyond restating 'valuation data'.

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 annotations and no output schema, the description should say more about the return shape than 'Valuation data for multiple stocks', and should note whether the stock list is capped. The parameter documentation is adequate, but return-side completeness is lacking.

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

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

Schema coverage is 0%, so the description must compensate and mostly does: it documents all three parameters, gives an example stock code format, and specifies YYYYMMDD date formats. It omits that start_date/end_date are optional (defaults exist), costing it a point.

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

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

States a specific verb and resource ('Get PE/PB ratios for multiple stocks over time'), which is clearer than a tautology. The 'multi' framing hints at batch scope versus a single-stock sibling like market_get_valuation, but that distinction is never made explicit.

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

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

Usage is only implied—'multiple stocks over time' suggests batch historical valuation, but there is no explicit when-to-use or when-not guidance, and no routing to alternatives such as market_get_valuation or tushare_get_daily_price.

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

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

With no annotations, the description carries the full behavioral burden. It discloses the return content ('Weekly OHLCV data') and the underlying API endpoint, which is useful, but says nothing about auth/token requirements, rate limits, pagination, or default behavior when dates are omitted.

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

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

Front-loaded with the core purpose, then cleanly sectioned into Args and Returns. No filler; every line maps to a parameter or the return value. Minor redundancy between the purpose line and the Args header.

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 must describe the return, and 'dict: Weekly OHLCV data' is minimal – it names the fields conceptually but not their keys or shape. Combined with no routing guidance among price siblings, it is adequate but incomplete.

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

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

Schema description coverage is 0%, so the description must compensate, and it does: it documents all three params with meaning and format, including a concrete ts_code example ('600519.SH') and the YYYYMMDD date format that the bare schema lacks. Only the empty-default semantics of the date params are left unstated.

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

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

States a specific verb and resource ('Get weekly price data for a stock') and names the exact upstream endpoint (Tushare weekly). The word 'weekly' implicitly separates it from sibling tushare_get_daily_price, but no sibling is named explicitly, so it stops short of full differentiation.

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

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

There is no guidance on when to use this tool versus tushare_get_daily_price, market_get_stock_history, or tushare_get_realtime_quote. The agent gets no conditions, prerequisites, or exclusions to route between the many overlapping price 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 the description carries the full burden. It discloses the prerequisite, the retention/activity-tracking role, and the return shape ({created: true, profile: {...}}), which is useful. It omits key behavioral facts: whether calling it twice overwrites an existing profile, errors, or is idempotent, and whether any permission/auth is needed.

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 in the first sentence, followed by a prerequisite note, then Args and Returns in a scannable structure. The Args block is slightly verbose but each entry earns its place given the 0% schema coverage.

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, but the description supplies the return shape, and with no annotations it covers the prerequisite, all parameters, and the tracking purpose. The main remaining gap is behavior on a pre-existing profile, which matters for a create 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 0%, so the description must carry all parameter meaning, and it does: it documents all 7 params, supplies the enum values for risk_profile (conservative/moderate/aggressive) and investment_style (value/growth/trend/mixed) that the schema lacks, gives example shapes for goals and settings, and notes the user_id default of local.

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 (创建本地用户 profile) and adds that it is the anchor for retention/activity tracking, which is meaningful scope. It does not explicitly contrast itself with the sibling user_update_profile, so an agent must infer create-vs-update from the name.

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 clear prerequisite/when-to-use trigger. However, it never names the alternative for an existing profile (user_update_profile) nor states what happens if a profile already exists, leaving the create-vs-update decision 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?

With no annotations, the description carries the full burden. It does disclose the parameter defaults and the exact return structure (exists, stats.total, active_days, daily_avg, by_type, etc.), which is genuinely useful. However, it never states that this is a read-only operation, nor mentions permissions, rate limits, or behavior when a user has no activity.

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 line, followed by compact Args and Returns blocks. Every element earns its place with no filler.

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

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

There is no output schema, but the description supplies a Returns block listing the exact response fields, covering the return-value gap. For a two-parameter read tool with no annotations, this is largely complete, missing only explicit read-only/edge-case disclosure.

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: it documents both parameters with meaning and defaults ('user_id: 用户 ID（默认 local）', 'days: 统计窗口天数，默认 30'). The only gap is the absence of accepted ranges or formats for days.

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: '获取用户活跃度统计（近 N 天）' (get user activity statistics over the last N days). This is clearly distinguishable from siblings like user_get_profile or user_get_retention, though it never explicitly names a sibling to route between 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?

There is no when-to-use guidance, no prerequisites, and no mention of alternatives such as user_get_profile or user_get_retention. The agent is left to infer when activity stats are the right call.

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

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

No annotations are provided, so the description carries the full burden. It does add real value by disclosing the return shape, including the exists boolean, which signals behavior when no profile is present. It says nothing about permissions, storage location semantics beyond '本地', or side effects, but for a simple read this is an acceptable middle score.

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

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

The Args/Returns layout is front-loaded and compact, with the purpose stated first. Every line carries information; the only mild waste is repeating the default value that the schema already declares.

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 profile fields returned (昵称/风险偏好/投资风格/经验年限/目标/设置/创建与最近活跃时间). For a one-parameter read tool this is close to complete, missing only guidance on which sibling to prefer.

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