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

With no annotations, the description fully discloses behavioral traits: OCF approximation precision, fallback from akshare to baostock, clamping of forecast_growth, graceful degradation of history, and reporting of fcf_quality. No annotation contradiction.

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

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

The description is long but well-structured with clear paragraphs and a bullet-like list for arguments. Front-loaded with core purpose. Some redundancy could be trimmed, but overall it earns its length.

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

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

Given the tool's complexity (multiple data sources, fallback, clamping, intermediate quality metrics), the description covers all critical aspects: return values (EV, equity), data provenance, and edge cases. No output schema, but the narrative sufficiently explains outputs.

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 has no descriptions (0% coverage), so the description must compensate. It provides extensive meaning for each parameter: data sources, constraints (e.g., forecast_years must be 1-20), and usage conditions (e.g., capex_to_ocf_ratio ignored when akshare available).

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

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

The description clearly states it is a 'Simplified DCF valuation' and explains the derivation of OCF, FCF, and enterprise value. It distinguishes itself from sibling tools like calculate_ddm_valuation by focusing on DCF methodology.

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

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

The description provides detailed usage context (e.g., fallback behavior, prerequisites for net_debt), but does not explicitly state when to use this tool versus alternatives like DDM or PEG ratio. Implicit guidance exists but lacks explicit comparisons.

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 fully discloses behavioral details: data source, multi-payout handling, year exclusion, bucket distortions, growth cap logic, and growth_clamped field. This provides comprehensive transparency.

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

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

The description is well-structured with clear sections and bullet points, front-loading key information. It is somewhat lengthy but every sentence adds value, balancing detail and clarity.

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 complexity of DDM, no output schema, and 0% schema coverage, the description is remarkably complete. It explains assumptions, calculation details, and parameter constraints, leaving little ambiguity for the agent.

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 adds meaning for four of five parameters: provides examples for discount_rate and terminal_growth_rate, and a range for forecast_years. It lacks detail for code and years_back, but overall compensates well.

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

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

The description clearly states it performs DDM valuation using specific data sources and details the methodology. The tool name itself distinguishes it from siblings like calculate_dcf_valuation.

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 explains how the tool works (e.g., auto-summing multi-payouts, excluding current year) but does not explicitly state when to use it over alternatives or when not to use it. It implies suitability for dividend-paying stocks but lacks direct guidance.

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

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

With no annotations, the description clearly explains data sources, unit conversions (YOYNI ratio vs percent), and return values (peg=None under conditions), though could be more explicit about output 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?

Well-structured with formula, explanation, and args section; no fluff, though slightly lengthy.

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 key aspects like undefined conditions and output fields (growth_period, growth_period_type) but lacks explicit return structure without an output schema.

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

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

The single parameter 'code' is described only as 'Stock code' with no format details, adding minimal value beyond the schema's type and 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 description states the formula for PEG and specifies the inputs (PE_TTM, YoY growth), making the purpose clear and distinct from sibling tools like DCF or DDM valuation.

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 extensive conditions when PEG is undefined (PE==0, PE<0, no growth report, growth<=0) with reasoning, but does not explicitly compare to alternative valuation tools for when to use PEG vs others.

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 provided. Description reveals the constraint that lookback_days must yield >=30 trading-day bars or call is rejected, but does not disclose other behaviors like read-only nature 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?

Front-loaded with purpose, then clear parameter docs. Slightly verbose but every sentence adds value. Could be more concise without losing 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?

Covers all parameters with defaults and usage notes, lists returned metrics. No output schema, but description adequately explains what to expect. Missing prerequisites or data source info, but sufficient for a focused financial metrics 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?

With 0% schema coverage, description fully compensates by explaining each parameter: code (stock code), benchmark_code (default and meaning), lookback_days (conversion to trading days, minimum constraint), risk_free_rate (default and context).

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

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

Description clearly states it calculates risk metrics (beta, Sharpe, max drawdown, volatility, correlation) and distinguishes from siblings like calculate_dcf_valuation, which are valuation-focused.

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 what the tool computes and provides defaults for benchmark and risk-free rate, implying usage context. However, it does not explicitly say when not to use it or compare to alternatives.

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

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

With no annotations provided, the description fully discloses behavioral traits: raises NoDataFoundError for missing data, lists skipped peers with reasons, excludes target from statistics, and uses trimmed mean. All critical behaviors are transparent.

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

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

The description is concise yet comprehensive, with a front-loaded purpose statement and a well-organized behavior contract. It uses markdown-style headings and bullet points, making it easy to parse. Every sentence adds 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?

Given the tool's simplicity (2 parameters, no output schema), the description is complete: it covers input semantics, error conditions, peer coverage output, and statistical methodology. No gaps remain.

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 add meaning. It explains 'code' as the target stock code, 'date' as comparison date with format and default behavior ('YYYY-MM-DD' and defaults to latest). This fully compensates for the lack of schema descriptions.

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

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

The description clearly states the tool's purpose: compare a stock's valuation (PE/PB/PS) against industry peers. The verb 'compare' and resource 'valuation' are specific, and the function distinguishes itself from siblings like get_valuation_metrics or calculate_dcf_valuation by focusing on peer comparison.

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 includes a detailed behavior contract explaining when errors occur and how peer coverage is handled. It implicitly guides usage for stocks with industry classification and data availability, but does not explicitly direct when to use this tool over alternatives.

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

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

No annotations provided, so description carries full burden. It mentions empty list behavior but lacks details on read-only nature, authentication, 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 concise with a clear purpose line and structured Args section. Every sentence adds value, though could be slightly more compact.

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

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

Given no annotations or output schema, it covers basics and edge case but misses explanation of adjustment factors significance and output format.

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

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

With 0% schema coverage, the description adds meaning by specifying stock code and date format (YYYY-MM-DD) for the required params, though code format is not detailed.

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

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

The description clearly states the tool fetches adjustment factor data for calculating adjusted prices, which is specific and distinct from siblings like get_historical_k_data.

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

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

It explains that factors only exist on ex-div/ex-rights dates and returns empty list if none, guiding when to use it and what to expect. However, no explicit when-not or alternatives.

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

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

No annotations provided, but description warns about empty query returning full market (~5000+ stocks, ~1 MB), which is helpful. Does not disclose other behavioral traits (e.g., read-only, rate limits).

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

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

Two concise paragraphs, first sentence communicates purpose, args are clearly listed with details. No unnecessary 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 no annotations and no output schema, description covers purpose, arguments, return fields, and a data size caveat. Could mention return type (list) but otherwise 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?

With 0% schema coverage, description fully explains both parameters: query is substring case-insensitive search, empty string returns all; date format and default are specified. Adds significant meaning.

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

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

States 'Search stocks by name' as verb+resource, and lists return fields (code, code_name, tradeStatus). Clear but does not explicitly distinguish from sibling tools like get_stock_basic_info or get_stock_snapshot.

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

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

No guidance on when to use this tool vs siblings (e.g., get_stock_industry for industry filtering). Missing context about prerequisites or alternatives.

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

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

No annotations are provided, so the description bears the full burden. It explains the structure of rate_type (deposit and loan with term breakdowns) but does not disclose data freshness, authorization needs, rate limits, or output format. Some behavioral context is added, but significant gaps remain.

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

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

The description is concise and well-structured: a one-line purpose, a bullet for rate_type details, and an Args list. It repeats some schema info but adds value. Could be slightly tighter by removing the Args line that merely restates 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 three parameters (one required) and no output schema, the description explains the required parameter well but does not describe the return format, error cases, or data availability. This leaves the agent partially informed.

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. It explains rate_type in detail with enum values and their included terms. For start_date and end_date, it adds the format hint 'YYYY-MM-DD' and notes they are optional, which is helpful but minimal.

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

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

The description clearly states 'Fetch PBoC benchmark deposit or loan rates within a date range,' specifying verb, resource, and scope. It distinguishes between deposit and loan rate types, making the tool's purpose unambiguous among sibling tools.

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

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

The description does not explicitly state when to use this tool versus alternatives. While it implies usage for fetching benchmark rates, no guidance on when-not-to-use or comparisons to siblings like get_money_supply_data or get_required_reserve_ratio_data is provided.

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

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

No annotations are provided, so the description carries full burden. It details the behavior: returns annual total and payout details, explains that annual_cash_per_share_pretax is summed and can be None for non-cash distributions, and describes how semicolon-separated values are already summed. This is comprehensive.

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 well-structured with a summary, details, Args, and Returns sections. It is informative but contains slight redundancy (explaining annual_cash_per_share_pretax twice). Overall concise and front-loaded.

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

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

There is no output schema, so the description must cover return value structure. It does so explicitly: '{code, year, annual_cash_per_share_pretax, payout_count, payouts}'. It also addresses edge cases (None for non-cash) and clarifies multi-value handling. Complete for 3 parameters with no output schema.

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

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

Schema has 0% description coverage. The description includes an 'Args:' section that explains each parameter's meaning and type (e.g., year is '4-digit year', year_type is 'report' or 'operate'). This adds crucial value 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 explicitly 'Fetch a year's dividends: annual cash total plus every payout's detail.' It uses specific verbs and resources, and clearly distinguishes from sibling tools which cover different financial data (valuation, balance sheet, etc.).

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

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

The description provides guidance on when to use the tool (to get dividend data) and explains how to interpret results, including handling of non-cash distributions and multi-values. However, it does not explicitly state when not to use or mention alternatives, though siblings are unrelated.

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?

Discloses that values are cumulative-from-year-start, the workaround for liabilityToAsset, and the distinct field sets for each report. Since no annotations are provided, the description carries the burden and does so well, though it omits output format or authorization needs.

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

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

The description is well-structured with bullet sections for each report, but it is somewhat verbose. The initial sentence clearly states the purpose, and the detailed field lists are helpful, though slightly lengthy.

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 4 required parameters and no output schema, the description provides sufficient details to use the tool correctly, including data quirks and report options. It lacks only the return data structure, but that is partially mitigated by listing 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?

With 0% schema coverage, the description fully compensates by explaining the code example, listing all enum values for report with their fields, specifying year format, and indicating quarter values 1-4. Every parameter's meaning is clarified beyond the schema.

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

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

Specifically states 'Fetch a quarterly financial report' with the `report` parameter selecting the statement. The description lists each report type and its fields, clearly distinguishing this from sibling tools like get_financial_statement.

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 context about cumulative values and quarter meaning, and explains the data source's structure. However, it does not explicitly state when to use this tool versus alternatives like get_financial_statement, nor does it mention when not to use it.

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

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

No annotations are provided, so the description carries the full burden. It discloses that returns are raw EastMoney field names, rows ordered most-recent-first, empty columns dropped, and the critical YTD cumulative behavior for income and cash_flow. This is thorough and honest about the tool's behavior.

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

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

The description is moderately long but well-organized with sections, bullet points, and bolded emphasis. Every sentence provides necessary detail; there is no fluff. It could be slightly shorter, but the complexity of the data warrants the length.

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

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

Given no output schema, the description explains the return structure (raw field names, row order, dropped columns) and how to interpret the data (cumulative YTD, subtraction for single quarters). It covers all aspects a user needs to understand the output, making the tool useable without external documentation.

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

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

The input schema has no descriptions (0% coverage), so the description must add meaning. It provides the stock code format, explains each statement enum value, gives default period count recommendation, and warns about raising period only when needed. This far exceeds what the schema offers.

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

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

The description clearly specifies that the tool fetches a full financial statement from EastMoney via akshare, listing all statement types and their content. It distinguishes from sibling tools like get_balance_data by emphasizing that this returns all columns and periods in one call, and it provides concrete details on field names and ordering.

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 advises to request only the needed statement because each fetch is a separate endpoint. It also explains the cumulative nature of income and cash flow data, implicitly guiding when to use this vs. calculating single-quarter values. However, it does not explicitly state when NOT to use this tool or list alternatives beyond the sibling names.

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

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

No annotations, so description must disclose behavior. It explains parameters and defaults but doesn't mention data source limitations, rate limits, or error handling. Adequate but not thorough.

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-structured with summary line followed by argument list. Slightly verbose but front-loaded with purpose. Could be trimmed slightly.

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, so description should explain return format. It doesn't. Parameter documentation is good but lacks behavioral context like data limits or pagination. Adequate for a 6-param tool with 3 required.

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 description provides detailed explanations for each parameter (code format, date format, frequency options, adjust_flag choices, fields default). Adds significant meaning beyond schema types.

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

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

Description clearly states 'Fetch historical K-line (OHLCV + valuation) data for a Chinese A-share stock' – specific verb and resource. Distinct from sibling valuation and financial data 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 guidance on when to use this tool vs alternatives like get_stock_basic_info or get_technical_indicators. No exclusions or context provided.

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

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

No annotations provided. The description does not disclose read-only nature, data source freshness, or other behavioral traits beyond parameters. It mentions default date but not limitations.

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?

Description is concise: one-line purpose followed by structured parameter details. No unnecessary words. Front-loaded.

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

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

No output schema provided, yet description does not mention return type or structure. Given the tool's complexity (fetching index constituents), expectations on response are unclear. Missing context on data delay or error cases.

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

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

Schema coverage is 0%, but description explains both parameters: index enum values with full names, and date format with default. This adds significant value beyond the schema.

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

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

The description clearly states 'Fetch constituent stocks of a major A-share index', using a specific verb and resource. It distinguishes from siblings like get_all_stock by focusing on index constituents.

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

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

No explicit guidance on when to use this tool versus alternatives. The description implies usage for fetching index constituents but does not mention exclusions or related tools.

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

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

With no annotations, the description carries the full burden. It discloses that it probes CSI 300, returns a date string, and is safe (read-only). It could add detail on return format consistency, but it's sufficient for a simple tool.

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

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

The description is concise and well-structured: front-loaded with the main result and format, followed by context on usage and edge cases. Every sentence adds value without 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?

Despite no output schema, the description explains the return format and the tool's behavior comprehensively for a zero-parameter tool. It covers purpose, usage context, and edge case (before market close), making it 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?

No parameters exist, so schema coverage is 100%. The description adds value by explaining the semantics of the output (date format, anchor usage), which is appropriate for zero-parameter tools.

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

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

The description clearly states the tool returns the most recent trading date with K-line data published, in YYYY-MM-DD format. It specifies the source (CSI 300) and positions it as a safe anchor date, distinguishing it from sibling tools like get_trade_dates.

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

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

Explicitly tells when to use this tool: as a safe anchor for follow-up K-line queries, guaranteed to have data regardless of wall-clock time. Also explains when today's bar is not yet published, providing clear guidance on timing.

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

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

Without annotations, the description describes the tool as fetching data (read operation) and details the behavior of date formats per frequency. However, it does not disclose any rate limits, authentication needs, data volume, or error handling, which would be expected for full transparency.

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

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

The description is concise, front-loaded with the core purpose, and uses a clear Args section for parameter details. Every sentence adds value with no redundancy or wasted words.

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

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

The description thoroughly covers the input parameters and hints at output fields (YOY, ChainRelative, YearYOY). However, without an output schema, a more explicit description of the return structure would improve completeness. Given the tool's simplicity, it is largely adequate.

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

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

The description adds significant meaning beyond the input schema by explaining the meaning of each freq value ('month' vs 'year'), the associated series names, and the date format dependency. Schema coverage is 0%, so the description fully compensates with detailed parameter explanations.

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

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

The description clearly states the verb 'fetch', the resource 'money supply data (M0, M1, M2)', and the frequency options (monthly/yearly). This distinguishes it from sibling tools which focus on company-specific financial data or valuation.

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 explains how to use the parameters (freq, start_date, end_date) and date formatting, but does not provide explicit guidance on when to use this tool over alternatives or when not to use it. Sibling tools have different domains, so the context is implicit, but not stated.

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

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

With no annotations, the description bears full responsibility for behavioral disclosure. It explains the return structure (one row per trading day), warmup prefetching to avoid nulls within the range, and handling of periods exceeding available history. No mention of permissions, rate limits, or destructive actions, but these are less critical for a read-only calculation 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 well-structured with a clear initial statement, followed by details on behavior and edge cases, and a parameter list. It is slightly verbose but each sentence adds value without redundancy.

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

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

Given the absence of an output schema and the moderate complexity (4 parameters), the description covers return behavior, row structure, and parameter details comprehensively. It does not specify the exact column naming convention but sufficiently informs about output.

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

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

The input schema has 0% description coverage, but the description adds meaning for all parameters: code is a stock code, start_date and end_date are in YYYY-MM-DD format, and periods is a list of integers ≥1 with a default common set. This fully compensates for the schema's lack of descriptions.

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

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

The description clearly states that the tool calculates SMA and EMA for multiple periods over a date range. This is a specific verb and resource, and it distinguishes itself from sibling tools that address other financial calculations or technical indicators.

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

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

The description does not explicitly state when to use this tool versus alternatives, such as get_technical_indicators which might also cover moving averages. Usage is implied through the tool name and context, but no direct guidance or exclusions are provided.

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

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

With no annotations, the description fully discloses behavior: the conservative estimate, the formula, a known overstatement issue, data source (EastMoney via akshare), and return contents.

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-structured with purpose, formula, caveat, and args. However, the caveat paragraph could be slightly condensed without losing clarity.

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?

Despite no output schema, the description explains what is returned (net_debt value, component breakdown, report date). The caveat and data source are appropriately detailed for a single-parameter tool.

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

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

The only parameter 'code' is documented with format ('baostock format') and an example ('sh.600519'), adding value beyond the bare schema. Return fields are also described.

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

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

The description clearly states the tool 'compute[s] net debt from the latest balance sheet' with a specific formula. It distinguishes from siblings like get_balance_data by focusing on a derived metric.

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 is given. The caveat about lease-heavy firms implies a limitation, but alternative tools or contexts are not mentioned.

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

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

No annotations are provided, so the description carries full burden. It discloses output fields for each kind but does not discuss limitations, data latency, authentication needs, or whether results are a list or single object. It is partially transparent.

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

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

The description is structured with clear sections: a one-sentence purpose, then details for each kind, then args. While fairly detailed, it remains focused and includes only necessary information.

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

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

With no output schema, the description partially explains return fields but does not specify the overall return format (e.g., list of records, single record). It omits details like whether multiple reports can be returned per date range or the structure of the response.

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

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

With 0% schema description coverage, the description compensates well by explaining each parameter: code, kind (with enum meanings and associated fields), and date formats (YYYY-MM-DD). This adds significant value beyond the schema.

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

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

The description clearly states it fetches performance express or forecast reports for a stock, explaining the difference between the two kinds with specific data fields. This distinguishes it from sibling tools like get_financial_indicators or get_financial_statement.

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

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

The description does not explicitly state when to use this tool versus alternatives, nor does it provide context about when not to use it. It only describes the tool's function without guidance on selection 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?

No annotations are provided, so the description carries full burden. It does not disclose any behavioral traits such as side effects, authentication requirements, rate limits, or return format. It only states the basic fetch operation.

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

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

The description is concise and uses a docstring format with parameter details. It is well-structured and front-loaded with the core purpose. No wasted words.

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

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

While parameter semantics are covered, the description is incomplete for a tool with 3 optional parameters, no output schema, and no annotations. It lacks information about return values, error handling, and use cases, which 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 adds meaning by specifying date format ('YYYY-MM-DD') and explaining the year_type parameter ('0' announcement date, '1' effective date). This compensates well for the lack of schema descriptions.

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

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

Clear verb+resource: 'Fetch required reserve ratio data.' It specifies the data type and distinguishes from many other data-fetching tools in the sibling list, though it could be more specific about the source.

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

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

No explicit guidance on when to use this tool versus alternatives. There is no mention of when-not or preferred contexts. The sibling list includes many similar data tools, but the description offers no differentiation.

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

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

No annotations are provided, so the description carries full burden. It does not disclose behavioral traits such as read-only nature, authentication requirements, rate limits, or potential side effects. The description only lists output fields without behavioral context.

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

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

The description is very concise: one line for the purpose and one line for the parameter with example. Every sentence is necessary and adds value. No wasted words.

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

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

For a simple tool with one parameter and no output schema, the description adequately covers the purpose and expected input, and lists the returned fields. It could mention whether the output is a single object or list, but overall it is sufficient.

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 'code' has no schema description (0% coverage). The description adds an example format ('e.g. 'sh.600519''), which provides meaningful context beyond the schema. This clarifies the expected input format clearly.

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

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

The description clearly states the action ('Fetch') and resource ('basic info') and lists the specific fields returned (code, code_name, ipoDate, outDate, type, status). It is distinct from sibling tools that provide other types of stock data, but could be improved by explicitly differentiating from similar tools like get_stock_snapshot.

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

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

No guidance is provided on when to use this tool versus alternatives, such as get_stock_snapshot or get_stock_industry. There is no mention of prerequisites, limitations, or scenarios where the tool should not be used.

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

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

No annotations are present, and the description does not disclose any behavioral traits such as read-only status, authentication requirements, or potential side effects. The description is purely functional.

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

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

The description is extremely concise, with a single sentence and a clear argument list. No wasted words.

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

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

Given the low complexity and absence of output schema, the description is adequate but does not explain the return format or data structure. It meets minimum viability.

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

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

The description adds meaningful detail beyond the schema property names, including an example for 'code' and format for 'date'. With 0% schema coverage, the description compensates adequately.

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

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

The description clearly states it fetches industry classification data for a stock code, optionally on a date. The verb 'fetch' and resource 'industry classification data' are specific and unambiguous.

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

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

No guidance is provided on when to use this tool versus alternatives. There is no mention of context, prerequisites, or exclusions.

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

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

With no annotations provided, the description fully carries the burden. It details data source combination, fallback behavior for indices, and critical nuances about profit period types, cumulative reporting, and revenue null 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?

Well-structured with front-loaded purpose, data sources, special behavior, and detailed caveats. Every sentence adds value, but the length might be slightly dense; a bit more conciseness could be achieved.

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 one parameter, no output schema, and no annotations, the description provides comprehensive context: input, data sources, behavior for different inputs, meaning of output fields, and important usage caveats.

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 description adds a minimal arg description 'Stock code.' This is adequate but not exceptional; the description compensates slightly but could add more detail (e.g., format examples).

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

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

The description clearly states it's a 'one-call snapshot' combining data from multiple sources, listing the specific fields. It distinguishes itself from siblings by being a composite tool, and the name reinforces its purpose.

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

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

Explicitly says designed for individual stocks, explains behavior for indices (null fields but still returns). Implicitly suggests when to use instead of multiple individual calls, but lacks explicit when-not or alternatives compared to 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 fully discloses behavior: volume indicators cause an extra network round-trip due to baostock limitations, and warmup is auto-prefetched to avoid nulls. This is rich detail beyond what annotations would typically provide.

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 primary purpose. While it includes technical details about volume indicators, these are valuable for transparency. The structure is logical but slightly verbose; a slightly more concise version could exist without losing 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?

The description explains return format (one row per day) and warmup behavior. However, it does not explicitly state the columns in the output (e.g., date, indicator values), which is a minor gap given no output schema. Overall, it is fairly complete for the complexity.

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

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

Schema description coverage is 0%, so the description carries full burden. It documents all four parameters: code, start_date (date format), end_date, and indicators (list of valid strings with default). This adds necessary meaning beyond the raw schema.

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

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

The description clearly states 'Calculate technical indicators for a stock' with a specific verb and resource. It distinguishes itself from sibling tools like get_moving_averages by explaining the types of indicators and the data handling for volume indicators.

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 mentions the extra cost for volume indicators and the auto-prefetched warmup, providing context. However, it does not explicitly state when not to use this tool or recommend alternative tools (e.g., get_moving_averages for simple moving averages).

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 provided, so description carries full burden. It accurately describes the output format and that the tool is a fetch (read) operation. While it does not explicitly state non-destructiveness, the name and description make it clear. Could mention rate limits or authentication but not necessary for this simple 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?

Extremely concise: one sentence for purpose, then a brief args section. No unnecessary words. Front-loaded with key information. Every sentence earns its place.

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

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

Given no output schema, description explains return rows. It does not cover edge cases (e.g., invalid dates), but for a simple calendar tool with two optional parameters, it is sufficiently complete. Could mention what happens if no dates provided, but implied by 'optional'.

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% (schema descriptions are empty), but the tool description adds parameter semantics: 'start_date: Optional YYYY-MM-DD' and similarly for end_date. This provides format and optionality beyond the bare schema. Adds meaningful context.

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

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

Description clearly states 'Fetch trading calendar' with specific output columns (calendar_date, is_trading_day). Distinguishes from sibling tools like get_latest_trading_date by indicating it returns a range. Purpose is unambiguous.

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

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

Description implies usage for obtaining a trading calendar within a date range, but does not explicitly state when to use this tool versus alternatives like get_latest_trading_date. No exclusions or prerequisites are mentioned. Only implied context.

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

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

With no annotations, the description fully discloses behavioral traits: independent metric reporting, as_of dates, percentile computation over positive values, null handling for non-positive current, and period.last_trading_date separate from metric as_of. This is highly transparent.

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

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

The description is front-loaded with the core purpose and then details behavioral nuances. While somewhat verbose, each sentence adds necessary context, making it appropriately sized.

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?

Despite no output schema, the description thoroughly explains return values (current, as_of, percentile_pct, sample_size, period.last_trading_date) and parameter defaults. It covers all edge cases and behavioral details, making it fully complete for an agent to invoke correctly.

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

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

Schema coverage is 0%, but the description adds an 'Args' section explaining each parameter (code as stock code, start_date defaulting to 1 year ago, end_date defaulting to today). This adds meaningful context beyond the schema 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?

The description clearly states it fetches valuation metrics history and current snapshot (PE/PB/PS/PCF). It uses a specific verb and resource, but does not explicitly differentiate from sibling tools, which are mostly different calculation or data retrieval functions.

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

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

The description does not explicitly state when to use this tool versus alternatives. It implies usage by describing the data, but lacks direct guidance on context or exclusions.

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