TickDB Market Data

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

With no annotations, the description carries the full burden and does substantial work: it discloses the auth source, that the upstream response envelope is preserved, the exact returned fields, and the rule to preserve nulls rather than coerce to zero. It stops short of error behavior or rate limits, but the read-only nature is clear from 'Query'.

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 clause, followed by operational details. The enumerated field list is longer than typical but earns its place because no output schema exists to document the return shape elsewhere.

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-arg, no-output-schema read tool, the description covers everything needed to call it correctly: credential sourcing, absence of arguments, the returned field set, and how to interpret expiration via server_time/remaining_seconds. Nothing essential for correct invocation is missing.

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

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

The tool takes zero parameters, so the baseline is 4. The description reinforces that no arguments are required and that the credential comes from the request/server environment rather than a parameter.

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

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

The description states a specific verb and resource ('Query API key subscriptions and expiration information') and is instantly distinguishable from all siblings, which are market-data tools. It also clarifies the auth context (X-TickDB-Key / TICKDB_API_KEY) so the agent knows which credential scope applies.

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 establishes clear context for invocation: no website login is needed, no arguments are required, and the current request key is used automatically. It does not name when-not or alternative tools, but no sibling overlaps this capability, so the missing exclusion costs little.

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 pagination via 'Follow pagination.total', case-insensitive market, and dynamic product counts, but it omits auth requirements, rate limits, and the overall return shape. Adequate but incomplete for a tool with no 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?

The description is front-loaded with the purpose and uses three concise sentences. 'Product counts change over time' is a minor caveat that earns its place; the formatting is slightly awkward 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 4-parameter read-only discovery tool with no output schema or annotations, the description covers invocation essentials: usage context, pagination behavior, case-insensitivity, and symbol format examples. Auth and rate-limit details are missing but likely non-critical for this tool.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaning beyond the schema by noting that 'market is case-insensitive' and by giving a concrete symbol format example for type=futures, which helps interpret the type and market parameters.

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

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

The description states a specific verb ('Query') and resource ('supported trading symbols with pagination'), and its role ('discover and verify codes before other calls') clearly distinguishes it from sibling tools that fetch data for already-known symbols.

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

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

It explicitly says to use this tool before other calls and gives a concrete example for futures ('Query CN or HK with type=futures for futures, e.g. BU2609 or HSI8888'). No when-not or alternative tools are named, but the context is clear.

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

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

No annotations are provided, so the description carries the full disclosure burden. It says nothing about whether results are historical vs upcoming, what time window is covered, whether the call is read-only, or what the response contains — 'related events' is undefined.

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

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

A single front-loaded sentence with zero filler. It is efficient, though so terse that it borders on under-specification rather than true conciseness.

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

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

With no annotations, no output schema, and a mutation-free but non-trivial retrieval, the description should clarify result scope (upcoming plans vs past executions) and any caveats. As written, it leaves the agent guessing about what data actually comes back.

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

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

Schema description coverage is 100%, and both parameters (symbol, type) are documented in the schema with formats and examples, so the baseline is 3. The description adds no parameter meaning beyond the schema (e.g., no detail on how 'type' interacts or what a missing type returns).

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

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

Specific verb 'Get' plus a concrete resource set (buyback plans, executions, related events), which is distinguishable from dividend/split/corporate-action siblings. No explicit sibling differentiation, 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 when-to-use statement, no conditions, and no mention of alternatives such as get_corporate_actions or get_dividends. The agent must infer that this is a per-symbol retrieval tool 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 exist, so the description carries the full behavioral burden. It does disclose a genuinely important gotcha — timestamps are Unix seconds here versus milliseconds in most market tools — and describes the shape of the result (intraday timeline plus order-size breakdown). It omits auth/permission needs, rate limits, and any freshness or history-window 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 with the one-line purpose, followed by return-shape and timestamp notes in a compact block. No filler sentences, though the phrasing is slightly loose and could be tightened.

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 does the work of describing the return (intraday timeline and large/medium/small breakdown) and flags the unit discrepancy. Supported markets are covered. Missing only edge behavior such as empty results, history depth, or rate limits for a live-data endpoint.

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

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

Schema description coverage is 100%, so both parameters are already documented (symbol format '700.HK'/'AAPL.US', type disambiguation list). The description adds nothing about parameters beyond the implicit stock context, making the baseline 3 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 and resource: 'Get capital flow (money flow) analysis for a stock,' and even supplies the synonym 'money flow' to aid matching. It also enumerates what comes back (intraday flow timeline, inflow/outflow by order size). However, it never contrasts itself with close neighbors like get_intraday or get_order_book, so the agent must infer the distinction.

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?

'Supported: US stocks, Hong Kong stocks, A-shares' gives a clear applicability constraint on the input. There is no explicit when-to-use guidance or named alternative for overlapping tools (intraday, order book, recent trades), so usage is implied rather than directed.

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

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

No annotations are provided, so the description carries the full burden of behavioral disclosure, and it says nothing about freshness ('current' is the only hint), whether results are a snapshot or historical, response shape, or any permission constraints. For a read tool this is thin but not misleading.

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 efficient sentence with the resource front-loaded and zero filler. It is arguably too terse given the missing behavioral context, but nothing in it is wasted.

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

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

For a simple two-parameter read tool with no output schema, the description covers the essentials of what is returned but omits return-value context, data freshness, and any relationship to get_company_profile. Minimum viable but with 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 description coverage is 100%, so both parameters (symbol and type) are already fully documented in the schema, including accepted symbol formats and the 'stock'-only type value. The description adds no parameter meaning beyond that, so the baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('company executives, directors, and key personnel'), so an agent knows exactly what data comes back. It does not, however, differentiate itself from the overlapping sibling get_company_profile, which likely also surfaces personnel 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?

There is no when-to-use or when-not-to-use guidance, and no alternative tool is named despite get_company_profile being an obvious candidate for overlap. Usage is only implied by the resource 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 burden. It discloses the return scope (which fields are included and which are not) and routes the agent to the detail tool for bodies, but it does not explicitly state that the operation is read-only or mention any authentication, rate-limit, or pagination behavior. For a straightforward read-only news listing, that is a minor gap.

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

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

Three short, front-loaded sentences with no filler. The return fields come first, the excluded content and alternative tool second, and the date constraint last.

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 list tool with a fully documented input schema and no output schema, the description gives the agent everything needed: what is returned, what is excluded, which sibling to use for bodies, and the date-pairing constraint.

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

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

Schema description coverage is 100%, so all five parameters are already documented in the schema. The description only reinforces the date-pairing rule and mentions the returned news_id for the sibling tool; it adds no new parameter semantics beyond what the schema already provides.

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

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

The description states a specific verb+resource ('Get company news') and enumerates the exact fields returned (IDs, titles, summaries, publication times, has_body). It explicitly distinguishes itself from the sibling get_news_detail by noting that article bodies are not included.

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

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

It explicitly names the alternative tool and the condition that selects it: 'Article bodies are not included; use get_news_detail with a returned news_id.' It also states a non-obvious usage constraint ('Supply both dates or neither'), which prevents incorrect date filtering.

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 data is a 'current' (point-in-time) profile and what categories it contains, but says nothing about authentication, rate limits, freshness/latency, or failure behavior for an invalid symbol.

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

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

A single front-loaded sentence with no filler; the resource and payload scope come first. It is arguably too terse to carry the sibling-differentiation burden, but nothing in it is wasted.

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

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

For a simple read-only lookup with a fully documented two-parameter schema, the description is minimally adequate. It is missing only the sibling disambiguation (get_stock_info vs. this tool) and any note on output fields, which, with no output schema present, would have been useful.

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

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

Schema description coverage is 100%, so both the symbol format examples and the 'type' disambiguation parameter are already fully documented in the schema. The description adds no additional parameter meaning, making the baseline 3 the correct score.

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 the current company profile') and enumerates the content scope ('listing and industry information'). It does not, however, differentiate itself from the sibling get_stock_info, which a caller could reasonably confuse it with.

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

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

There is no guidance on when to use this tool versus the many sibling lookups (get_stock_info, get_industries_tree, get_industry_peers). No prerequisites, no exclusions, no alternatives named — the agent must infer usage entirely 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?

No annotations are provided, so the description carries the full behavioral burden. It usefully clarifies that is_recent marks recency and not the event date, which is a meaningful disclosure, but it does not cover auth requirements, rate limits, or return/pagination behavior for a read 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 short and front-loads the tool's purpose before adding a caveat. Both sentences are brief, though the second sentence refers to an is_recent field that is not present in the schema, which slightly reduces clarity without adding verbosity.

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 4-parameter read tool with no annotations and no output schema, the description lists the action categories and one behavioral caveat. It does not explain return structure, date-range defaults, or when to prefer it over related tools, leaving material gaps for an 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 100%, so the schema already documents symbol, type, from_date, and to_date with clear descriptions. The description adds no additional syntax or format details for those parameters, and its is_recent note refers to a field not present in the input schema. Baseline 3 is appropriate.

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

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

The description gives a specific verb (Get) and resource (corporate actions), then enumerates concrete action types: splits, consolidations, rights issues, symbol changes, and other actions. It is clear what data the tool returns, but it does not explicitly distinguish itself from close siblings such as get_split_calendar, so it misses the top score.

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 like get_split_calendar or get_dividends. The only usage-like sentence concerns is_recent semantics, not tool selection. The agent must infer the intended scenario from the purpose 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 and does reasonably well: it discloses the return shape (data.events plus top-level page), that empty events means no matches, and the exact pagination contract. It omits auth/rate-limit behavior beyond what the schema already says about market-restricted keys.

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 one-line summary then adds three tightly scoped sentences about the return shape and pagination. Little waste, though the indented multi-line layout is slightly noisier than plain 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 6-optional-parameter, no-output-schema tool, the description compensates by explaining the returned fields and pagination flow, which an agent needs to chain calls correctly. Introducing the return contract in prose covers the absent output schema adequately.

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

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

Schema description coverage is 100%, so the schema already documents defaults, ranges (1–500), formats (YYYY-MM-DD), and symbol limits. The prose adds only the cursor verbatim rule, which is marginal on top of the structured fields, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get dividend events') plus its filtering and pagination scope, so the agent knows what it returns. The word 'calendar' implies a date-oriented listing, which separates it from get_dividends/get_dividends_ttm, but the description never explicitly names or contrasts 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?

Gives clear operational guidance for the follow-up call: keep filters unchanged, pass page.next_cursor verbatim, reuse data.from/data.to if dates were omitted. What is missing is when to choose this tool over the sibling dividend endpoints (get_dividends, get_dividends_ttm).

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 that future (known) dividends are included, that 'amount' is per-share cash as a decimal string or null for non-cash distributions, and that the cursor and filters must be preserved across pages. However it says nothing about ordering, permissions, or rate limits, so coverage is partial.

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

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

Three short paragraphs, front-loaded with the purpose, then response semantics, then the pagination contract. Every sentence carries information, though the 'amount' note concerns the response shape rather than invocation and slightly dilutes focus.

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 partially compensates by explaining the amount field and the page.next_cursor contract. For a 7-parameter financial-data tool it still omits result ordering, how future vs historical rows are distinguished, and any call prerequisites, leaving it merely 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?

Schema description coverage is 100% and every one of the 7 parameters is documented in the schema itself (symbol formats, date format, dividend_type values, limit range, cursor semantics). The description adds no parameter-level detail beyond restating that filtering is by date/type, so the baseline 3 applies.

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

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

States a specific verb and resource ('Get historical and known future dividends') plus the filtering scope (date/type) and pagination, so the agent knows exactly what it returns. It does not explicitly differentiate itself from nearby siblings like get_dividend_calendar or get_dividends_ttm, so it falls 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 statement of when to reach for this tool versus alternatives such as get_dividends_ttm or get_dividend_calendar, nor any prerequisites. The only procedural guidance is pagination-related ('preserve the top-level page.next_cursor and unchanged filters'), which is not tool-selection 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 exist, so the description carries the full disclosure burden, and it does substantial work: it names the grouping key (currency), the returned components (normal/special/total cash DPS plus event counts), and explicitly warns that DPS is not dividend yield. It omits pagination behavior and does not state permissions, but for a read-style 'Get' tool this is well above average disclosure.

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

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

Front-loaded with the core purpose in the first clause, followed by two short supporting sentences. The 'DPS is not dividend yield' clarification earns its place; only the stray line-break punctuation slightly hurts readability.

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 compensates reasonably by naming returned fields, but it still leaves an agent without pagination/response-shape or auth context, and its silence on the get_dividends sibling is a real gap given the near-identical name.

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

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

Schema description coverage is 100%, with all three parameters documented including as_of and symbol formats, so the baseline is 3. The description adds only the ex_date window semantics, which is scope rather than parameter syntax; no additional per-parameter meaning is supplied.

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

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

States a specific verb and resource with scope ('trailing-12-month cash dividends per share, grouped separately by currency'), so an agent knows exactly what it retrieves. However, it never distinguishes itself from the sibling get_dividends, leaving the two plausible candidates for the same request ambiguous.

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

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

The description gives the inclusion window (ex_date > window_start_exclusive and ex_date <= as_of_date), which is definitional scope rather than guidance on when to pick this over get_dividends or get_dividend_calendar. No prerequisites, no when-not, no named alternative.

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 disclose meaningful behavior beyond structure: the response envelope location (data.data.{symbol}), the forward vs backward application semantics (oldest-first vs newest-first), and the factor math. It does not mention permissions or rate limits, but for a read-style 'get' tool the returned-data semantics are well covered.

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

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

It is front-loaded with the resource and scope, then the formula, then application semantics, then the alternative routing. Dense but each sentence adds information; the 'in the response envelope' phrasing is slightly awkward 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?

There is no output schema, so the description must convey return semantics, and it does explain where factors appear and how to apply them. Combined with full schema coverage on the inputs, an agent has enough to call and interpret it, though auth/safety context is absent.

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

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

Schema description coverage is 100%, so all four parameters are already documented in the schema. The description adds no per-parameter meaning (e.g., what 'type' or the time bounds do beyond the schema text), so the baseline 3 applies.

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

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

It states a specific verb and resource (get stock adjustment factors) and clarifies the concept with the formula adjusted = raw * factor_a + factor_b. It also distinguishes itself from the sibling tools get_kline and get_kline_latest, so an agent can tell them apart without opening a schema.

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

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

It gives clear routing guidance: 'For ordinary adjusted candles, use get_kline or get_kline_latest with adjust instead,' which names the alternative and the condition that selects it. It stops short of stating explicitly when this tool IS the right choice, but the contrast makes the intended use inferable.

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 genuinely non-obvious behavior — that n counts fiscal years rather than rows, and that period_type is normally 'af' but can be 'q4' at fiscal year-end — but it says nothing about permissions, rate limits, or the shape of the returned rows.

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 tight sentences with the core purpose front-loaded and zero filler. The second sentence is somewhat cryptic given period_type is not an input parameter, but the overall structure is efficient.

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

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

With no output schema and no annotations, the description should explain what a 'row' of financial metrics actually contains and how period_type factors in, but it never does. An agent knows how to call it but not what comes back, leaving a meaningful gap for a data-retrieval tool.

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

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

Schema description coverage is 100%, so the schema already documents n, kind, type, and symbol; baseline is 3. The description adds real value by clarifying the counting semantics of n (fiscal years, not rows), but it also references a period_type field that does not appear among the input parameters, which muddies rather than clarifies.

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 annual financial metric rows'), and the word 'annual' inherently distinguishes it from siblings get_financials_latest and get_financials_ttm. It stops short of explicitly naming those alternatives, so it lands at 4 rather than 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?

Usage is only implied by 'annual' — there is no explicit statement of when to choose this over get_financials_latest or get_financials_ttm. The note that n counts fiscal years and that period_type may be 'q4' at fiscal year-end is a useful operational hint, but it is not a when-to-use guideline.

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

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

With no annotations, the description carries the full behavioral burden. It does add genuine value by clarifying that 'n counts periods, not rows' and that rows carry field names and display names, which hints at return contents. It says nothing about auth, rate limits, or how 'latest' is determined, so the disclosure remains 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?

Two compact sentences plus a fragment, front-loaded with the core action and the most error-prone parameter note. Nothing is padded, though the final clause is terse enough to be slightly telegraphic.

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 financial tool with no output schema and no annotations, the definition covers parameter mechanics and row contents but omits how it differs from annual/TTM variants and gives no indication of the returned shape or row count relative to periods. Adequate but with 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 100%, so the baseline would be 3. The description goes slightly beyond the schema by disambiguating n ('counts periods, not rows') and by stating that field names and display names appear in rows, which is a mapping aid the schema does not provide.

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

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

States a specific verb and resource ('Get field-level financial rows') with a scope ('up to 20 periods'), so the agent knows it returns statement line items. However, it never distinguishes itself from the siblings get_financials_annual and get_financials_ttm, so the 'latest' positioning is left to inference.

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?

'Use one kind per call' is an invocation constraint, not usage guidance. There is no statement of when to pick this tool over get_financials_annual or get_financials_ttm, nor any prerequisites, so the agent has no routing signal.

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 meaningful behavior: rows are aggregated from four valid standalone quarters, and each row exposes field_name, value, and period_end. It says nothing about authentication, currency/units, or failure behavior when fewer than four standalone quarters exist, which are the real risks for a TTM endpoint.

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

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

Two short sentences, no filler, with the core scope statement front-loaded before the return-shape detail. The line break and indent are cosmetic noise 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, the description steps in to name the returned row fields (field_name, value, period_end), which is the key missing piece for an agent consuming results. It stops short of units, currency, or what happens when fewer than four valid quarters exist, but is adequate for a read-only financials fetcher.

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

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

Schema coverage is 100%, so the schema already documents kind (IS/CF), symbol formats, and type. The description only adds the negative constraint that BS is unsupported for kind, which is genuinely additive but marginal. Baseline 3 is appropriate when the schema does the heavy lifting.

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

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

States a specific verb ('Get') and resource ('TTM income/cash-flow rows') plus the aggregation rule (four valid standalone quarters). This clearly separates it from siblings like get_financials_annual, get_financials_latest, and get_dividends_ttm, and the scope limit 'kind=BS is unsupported' sharpens the boundary further.

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 one useful when-not signal ('kind=BS is unsupported'), which implies balance-sheet data must come from a different tool. However, it never names the alternative sibling (e.g., get_financials_annual) or states prerequisites such as needing a resolvable symbol, so usage is only implied rather than directed.

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 that holdings reflect disclosure dates rather than today and gives a concrete pagination protocol (top-level page, keep filters unchanged, pass next_cursor verbatim). It omits other behavioral traits like authentication or rate limits, but covers the most operationally important caveats.

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 states purpose and pagination; the next two add critical caveats. There is no redundant or filler text, and the information is front-loaded.

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

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

For a tool with no annotations and no output schema, the description covers what data is returned and how to paginate, but it does not describe the response shape or provide usage guidance against siblings. It is adequate but leaves 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?

The schema fully documents all four parameters, setting a baseline of 3. The description adds a meaningful pagination rule for cursor and filters (keep filters unchanged and pass next_cursor verbatim), which goes beyond the schema's static 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 names the exact resource (disclosed fund holdings and portfolio weights) with a clear verb. It does not reference any sibling tool (e.g., get_shareholders_latest) to help an agent disambiguate, so it stops short of the top score.

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 pagination mechanics but never states when this tool should be chosen over other holdings or shareholder endpoints. There are no exclusions, prerequisites, or alternative-tool references.

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 does not state the ordering/direction of the ranking, what metric drives it, whether the list is truncated by the limit, or how results are returned. For a ranking tool with zero structured behavioral hints, this is a notable gap.

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

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

It is a single front-loaded sentence with no wasted words, which is structurally clean. But the brevity is under-specification rather than effective conciseness given the unstated ranking semantics.

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

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

For a simple two-parameter read tool with full schema coverage and no output schema, the description is still too thin: the definition of the ranking and its ordering are omitted, which are the details an agent needs to interpret or present results. It is not adequate for the tool's modest complexity.

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

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

Schema description coverage is 100%: the market parameter documents allowed values (US, HK, CN) and case-insensitivity, and limit documents its 1–200 range and default. The description adds no parameter meaning beyond the schema, so the baseline 3 applies.

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

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

The description names a verb ("Get") and a resource ("industry ranking") scoped to a market, so the broad intent is inferable. However, it never says what the ranking is ranked by (performance, valuation, market cap) and does not distinguish it from siblings like get_industries_tree, get_industry_distribution, or get_industry_peers. That ambiguity in ranking metric leaves purpose only partially clear.

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 mention of alternatives such as get_industries_tree or get_industry_distribution, and no stated prerequisites. The agent must guess which industry-related sibling to pick from context 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?

There are no annotations, so the description carries the full behavioral burden. It does disclose something structural, namely that the response is recursive with child categories, which is useful. It says nothing about permissions, response shape, or whether the tree can be deep/truncated, leaving meaningful gaps.

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

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

Two short sentences, zero filler, with the core capability stated first and the parameter-sourcing hint second. Nothing redundant.

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 full schema coverage and no output schema, the description covers purpose and parameter origin adequately. The main residual gap is return-shape detail (how nodes/children are structured), which is not covered elsewhere.

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

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

Schema description coverage is 100%, so both parameters are already documented in the schema. The description adds a small amount of meaning by tying industry_counter_id back to the get_industries_rank output and constraining it to the same market, which is why it sits at the baseline rather than higher.

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

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

The description names a specific verb (get) and resource (an industry's top-level classification plus recursive child categories), which distinguishes it from flat-list siblings like get_industries_rank. It stops short of explicitly differentiating itself from adjacent tools such as get_industry_distribution or get_industry_peers.

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

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

It gives a concrete chaining directive: use industry_counter_id from get_industries_rank for the same market, which tells the agent the prerequisite call. It does not state when to prefer this tool over related sibling tools (distribution, peers), so no exclusion 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 behavioral burden. It implies a read via 'Get' but says nothing about required permissions, whether the response is scoped to peers or the whole industry, sampling method, or pagination/size limits.

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

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

A single efficient sentence with the resource front-loaded and no wasted words. It is concise, though brevity here borders on under-specification rather than tightness.

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 an abstract term like 'distribution', the description should explain what is returned and how it differs from sibling valuation tools. It does not, leaving significant gaps for a 2-parameter analytics tool.

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

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

Schema description coverage is 100%, so both 'type' and 'symbol' are fully documented in the schema including the market-suffix format. The description adds no additional parameter meaning, which is acceptable given the schema already does the heavy lifting (baseline 3).

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

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

The description names a verb ('Get') and a resource ('industry valuation distribution and sample statistics'), so the basic action is clear. However, 'distribution' and 'sample statistics' are vague, and it does not distinguish itself from close siblings like get_industry_peers, get_industries_rank, or get_valuation_latest, leaving the agent to guess which peer-comparison tool applies.

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 and no alternative named. With roughly a dozen industry/valuation siblings, an agent gets no help deciding between this tool and get_industry_peers or get_valuation_history.

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 does not say how peers are determined (industry classification? market?), whether the data is a live snapshot or cached, what the response contains, or any rate/permission constraints beyond the word 'current'.

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

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

A single front-loaded sentence with zero filler. However, its brevity is partly under-specification rather than disciplined conciseness given how little behavior it conveys.

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

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

For a simple two-parameter read tool with fully documented schema, the description covers the essentials of what it returns at a high level. With no output schema and no annotations, it should at least sketch the response (peer list plus valuation metrics) and how peers are selected, which it does not.

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

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

Schema description coverage is 100%, so the schema already documents both 'symbol' (with format examples) and the optional 'type' parameter. The description adds no meaning beyond the schema, so the baseline 3 applies.

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

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

States a specific verb (get) and resource (the company's industry peers) plus a content hint (valuation cross-section). It is distinguishable from siblings like get_industries_rank or get_industry_distribution, though the description never explicitly contrasts 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?

No when-to-use guidance, no prerequisites, and no mention of alternative tools. The agent must infer that this is a per-company peer lookup rather than an industry-level aggregate, with nothing in the text to confirm that.

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 the return shape (minute-start timestamp in ms, price, volume, turnover, average price), warns that data may be present or empty outside trading hours, and scopes supported markets (US, HK, A-shares). It doesn't state read-only nature explicitly or address rate limits, keeping it short of a 5.

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

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

Front-loaded with the core purpose in the first sentence, followed by return fields, a timing caveat, and coverage scope. No filler sentences; the indentation artifacts are cosmetic rather than wasteful.

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

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

There is no output schema, so the description appropriately explains the returned fields and the empty-data edge case. Combined with a fully documented input schema and low parameter count, an agent has what it needs to invoke this correctly; only cross-tool routing guidance is absent.

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

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

Schema coverage is 100%, so both parameters are already documented in the schema. The description adds only the supported-market list, which indirectly constrains symbol format, but does not clarify the 'type' disambiguation parameter or symbol syntax. Baseline 3 is appropriate.

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

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

States a specific verb and resource ('Get today's intraday minute-level price data for stocks') and even enumerates the returned fields. It is clearly distinguishable from sibling tools like get_kline, though it never names an alternative to contrast against.

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 'today's intraday minute-level' data and the supported-markets note, which tells the agent this is a same-day granularity tool. However, it gives no explicit guidance about when to prefer this over get_kline, get_kline_latest, or get_recent_trades, and offers no 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, the description carries the full burden and discloses useful behavioral details: return keys (data.events, top-level page), empty-result semantics, cursor pagination rules, and date-omission fallback behavior. It stops short of covering auth, rate limits, or explicit read-only guarantees, but 'Get' strongly implies a read 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?

Front-loaded with the main purpose, followed by return shape and pagination instructions. Three compact sentences with no filler; every sentence provides actionable guidance.

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

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

Given six optional parameters, 100% schema coverage, and no output schema, the description adequately explains return keys, empty results, and pagination. It omits deeper detail about event fields or authentication constraints, but covers the essentials needed to call and paginate correctly.

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

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

Schema description coverage is 100%, so the baseline would be 3, but the description adds cross-parameter workflow meaning: keep filters unchanged across pages, pass page.next_cursor verbatim, and use data.from/data.to from the first response when dates were omitted. This is useful semantics beyond individual parameter descriptions.

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

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

States a specific verb and resource: 'Get IPO events' with date/symbol/market filters and cursor pagination. This clearly distinguishes it from other calendar siblings like dividend, split, and report calendars, though it does not explicitly name those 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?

Provides invocation guidance by describing pagination behavior and how to handle omitted dates, but it does not explicitly state when to choose this tool over sibling calendar tools or when not to use it. Usage is implied by the IPO-specific purpose.

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 well: discloses that the last candle may still be forming, that adjusted history shifts after corporate actions, and that futures omit quote_volume. It does not state auth/permission needs or rate limits, which is the remaining gap.

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

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

Five short sentences, each carrying a distinct operational fact, with the core purpose front-loaded. The odd line wrapping is cosmetic and no sentence is filler, though the limit/time rules could be grouped more tightly.

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

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

For a 7-param, no-output-schema read tool, the description covers the return shape (OHLCV plus optional open_interest/quote_volume), staleness, and the limit/time constraints. Missing only guidance on the 'type' disambiguation parameter and sibling routing.

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

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

Schema coverage is already 100%, so baseline is 3, but the description adds semantics beyond the schema: non-positive limits resolve to 100 (a fallback the schema doesn't document) and the start_time<=end_time constraint. It adds little on 'type' and 'adjust' 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?

States a specific verb and resource: 'Get historical OHLCV candles', and adds the futures open_interest detail. It distinguishes itself from get_kline_latest implicitly via 'historical', but never names the sibling explicitly, so the 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?

Adds useful context about backtests ('record query time and adjustment mode'), which implies analytical/replay usage, and the start_time<=end_time rule. However there is no explicit when-to-use guidance versus get_kline_latest or get_intraday, so selection between them is left to inference.

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

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 one genuinely useful behavioral trait — the returned candle is live/incomplete and therefore mutating in value — but says nothing about auth requirements, rate limits, whether data refreshes, or what fields a candle contains.

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

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

A single front-loaded sentence with no filler; every word contributes to describing the operation and its distinguishing characteristic.

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 data-returning tool with no output schema and no annotations, the description covers the input side adequately but leaves the return shape wholly unexplained — an agent cannot tell what fields a 'candle' contains (OHLCV, timestamp, symbol grouping for multiple symbols). It stops at minimum 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 description coverage is 100%, with symbols, interval, type, and adjust all documented inline (including examples and valid interval values), so the schema does the heavy lifting. The description adds nothing about parameter semantics, so the baseline of 3 is appropriate.

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

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

States a specific verb and resource ('Get the most recent ... K-line candle') and scopes it to one or more symbols. The '(live/incomplete)' qualifier implicitly distinguishes it from the historical get_kline sibling, but it never names that alternative, so the differentiation is implied 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?

The phrase 'most recent (live/incomplete)' hints at the right context (real-time/latest snapshot rather than historical retrieval), but there is no explicit 'use this when' guidance and no mention of the sibling get_kline to route between them. Usage is implied, not stated.

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

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

No annotations are provided, so the description carries the full behavioral burden. It discloses the returned field set and supported markets, but says nothing about permissions/auth, rate limits, error behavior for unsupported symbols, or that the tool is read-only — gaps that matter 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?

Front-loaded purpose followed by a returns list and a supported-markets note. The field enumeration is long but justified as a substitute for the absent output schema, and there is 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?

With no annotations and no output schema, the description supplies the return values and market coverage, which partly offsets those gaps. However, it omits usage context, auth/limit behavior, and how unsupported types are handled, leaving it only minimally 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 100%, with the schema documenting both the symbols format (comma-separated, max 50, example given) and the type disambiguation values. The description's only added parameter context is the supported market list, so baseline 3 is appropriate.

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

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

States a specific verb and resource ('Get comprehensive market metrics and valuation data for stocks') and enumerates the fields returned. It is clear, but it never explicitly distinguishes itself from narrower siblings such as get_valuation_latest or get_capital_flow, so sibling differentiation is left to inference.

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

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

The description gives no when-to-use guidance and names no alternatives. 'Supported: US stocks, Hong Kong stocks, A-shares' is a coverage note, not usage direction, leaving the agent to guess when this tool beats its many 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 discloses that there is no market/symbol filter, that the response keys are market, market_time and trade_status, and that values are current status rather than a schedule. It omits auth/rate-limit behavior, but for a read-only status endpoint the scope and shape disclosure is substantial.

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 tight sentences with the capability front-loaded and the disambiguating constraint immediately after. No filler, no restatement of the title.

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

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

There is no output schema, so the description must convey the return shape, and it does by naming the returned fields and their codes. A zero-argument read tool whose response keys are enumerated needs nothing further.

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. The description reinforces this by stating 'No market or symbol filter', which prevents the agent from inventing filter 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 (Get) and resource (CN/HK/US trading status plus RFC3339 market-local time) with scope explicitly defined as three markets. The contrast with get_trading_sessions ('this is current status, not the trading-session schedule') lets an agent disambiguate it from its closest sibling without opening either schema.

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

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

Explicitly carves out a when-NOT-to-use case by stating this is current status rather than the trading-session schedule, which routes the agent away from get_trading_sessions. It does not name the alternative tool directly, but the condition that selects it is clear.

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

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

With no annotations, the description carries the full behavioral burden and does solid work: it warns that body may be null for pending/blocked/failed statuses, that excerpt is not full text, and that HTML content is external data to sanitize before display (a useful prompt-injection caution). It omits auth requirements, rate limits, or pagination 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?

Three compact sentences, front-loaded with what is returned, followed by the null/truncation caveat and the safety note. Every sentence carries distinct, non-redundant 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?

Though there is no output schema, the description enumerates the returned fields (text/HTML, detail_status, content_scope) and the null-body condition, which is exactly what an agent needs to handle the response correctly. Nothing material is missing for a single-parameter read tool.

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

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

Schema description coverage is 100% for the single news_id parameter, including its pattern and origin, so the schema already does the heavy lifting. The description adds no parameter meaning beyond what the schema provides, making 3 the correct baseline.

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

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

States a specific verb (Get) and resource (news text/HTML, detail_status, content_scope) keyed by article ID. It is distinguishable from the get_company_news list sibling, though it never names that sibling explicitly as the list/detail counterpart.

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 — fetch the full article for a given ID — and the routing hint ('ID from get_company_news') lives in the schema rather than the description. There is no explicit when-to-use vs. when-not or named alternative in the description itself.

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 a good job: it discloses the return format ([price, quantity] arrays, best price first), timestamp units (ms), market-specific depth limits, that actual depth may be lower, and that no limit parameter exists. It omits auth/rate-limit context, but for a read-only market data call this is solid disclosure.

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

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

Front-loaded with the core purpose, then structured into compact lines covering return format and depth constraints. It is efficient, though the depth enumeration is dense and could be slightly tightened.

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 or annotations exist, so the description must supply return-format context — and it does, including array shape, ordering, timestamp units, and depth variability. It does not mention data freshness/real-time nature or error semantics, leaving minor gaps for a 2-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?

Schema description coverage is 100%, so the schema already documents both parameters. The description adds marginal value by explaining that depth is market-defined and no limit parameter exists, but it does not elaborate on the optional 'type' parameter beyond what the schema says.

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 order book (market depth)') with bid/ask price levels. None of the sibling tools provide order book data, so the purpose is unambiguous without needing to name 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 explains what the tool returns but never states when to use it versus nearby siblings like get_recent_trades, get_ticker, or get_kline. No when-to-use or when-not-to-use guidance is provided.

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

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

No annotations are provided, so the description carries the full behavioral burden. It usefully discloses the return shape ('data.events and top-level page'), empty-result semantics ('empty events means no matches'), and cursor stability rules for later pages. However, it does not state read-only intent explicitly, auth requirements, rate limits, or error behavior, so meaningful 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 compact and front-loaded: purpose first, then return values, then pagination instructions. Every sentence contributes, though 'other financial events' is vague enough to slightly weaken the opening.

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 seven parameters, no annotations, and no output schema, the description does well to explain return shape and pagination. It still leaves out required-category orientation and sibling differentiation, which are important for correct invocation. The schema covers parameter details, but the description is not complete enough to guide selection 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?

Schema description coverage is 100%, so the schema already documents all seven parameters, including the required category enum and cursor/date defaults. The description adds only high-level filter mention ('date/symbol/market filters') and repeats cursor pagination behavior already present in the schema, so the baseline of 3 is appropriate.

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

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

The description names a specific verb and resource ('Get other financial events') and mentions filters and pagination. However, 'other' is vague and does not distinguish this tool from the many specialized calendar siblings such as get_dividend_calendar, get_ipo_calendar, or get_buyback. It also omits the required category parameter, which is central to what the tool actually returns.

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

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

The description gives pagination mechanics ('For later pages keep filters unchanged...') but never explains when to use this tool instead of a sibling calendar tool. There are no exclusions, no alternative names, and no context for choosing this endpoint over the specialized ones.

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 does disclose the return shape (trade id, price, quantity, side, timestamp ms) and futures-only extras with their value enumerations, which is genuinely useful. However, it says nothing about rate limits, data freshness/latency, market-session dependence, or permissions — meaningful gaps for a no-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 core purpose in the first sentence, then enumerates returns compactly. The parenthetical enumeration of position_effect values is slightly heavy but earns its place since 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?

With no output schema, the description usefully documents the returned fields and futures-specific extensions, which an agent needs. It falls short only on operational context such as pagination beyond limit, data freshness, and error/empty-result behavior.

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

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

Schema description coverage is 100%, so symbol, type, and limit (default 100, max 1000) are already fully documented in the schema. The description adds no parameter-level meaning beyond that, so the baseline of 3 applies.

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

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

States a specific verb and resource (get recent executed trades) scoped to a single symbol, which clearly separates it from quote-style siblings like get_ticker or get_kline. It does not explicitly name an alternative tool, so the differentiation is implied rather than asserted.

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

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

The description gives no guidance on when to use this instead of related siblings (get_ticker, get_intraday, get_order_book, get_kline). There is no mention of prerequisites, data availability, or the conditions under which recent trades are the right choice.

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 reasonably well: it discloses the response envelope (data.events, top-level page), what an empty events list means, and required pagination discipline. It omits auth/permission requirements and rate-limit behavior, which are the remaining behavioral gaps.

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

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

Front-loads the core purpose, then layers return shape and pagination rules. Every sentence carries information and nothing is redundant, though the multi-clause pagination sentence is slightly dense.

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

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

No output schema exists, so the description correctly compensates by explaining the return shape, the empty-result meaning, and how to chain pages. Date-default fallback is also covered, leaving only auth/permission context unaddressed.

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

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

Schema description coverage is 100%, so the schema already documents limit, cursor, market, symbols and both dates with formats and defaults. The description adds only the cursor-verbatim and filter-stability rules, which is modest value beyond the schema, so baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('earnings and results events') plus the filter dimensions and pagination nature. This adequately separates it from siblings like get_dividend_calendar, get_ipo_calendar and get_split_calendar, though it never names a sibling explicitly to sharpen 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?

Provides real usage mechanics for pagination (keep filters unchanged, pass page.next_cursor verbatim, reuse data.from/data.to when dates were omitted) and the empty-result case. However, it offers no guidance on when to prefer this tool over the other calendar tools, so context selection is only implied.

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

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

No annotations are provided, so the description carries the full behavioral burden, and it delivers almost nothing: no statement about read-only nature, no pagination behavior despite a limit parameter, no auth requirements, and no indication of what the response contains. For a data-fetch tool with zero annotation coverage this is a significant gap.

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

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

A single front-loaded sentence with no wasted words. However, its brevity reflects under-specification rather than tight economy, and it arguably leaves too much unsaid for a five-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?

Five parameters, no output schema, and no annotations mean the description should carry more weight than one sentence. It never explains what a segment record looks like, how 'report' periods map to results, or how results are ordered or limited.

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

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

Schema description coverage is 100%, so the schema already documents symbol, type, limit, report, and category fully. The description adds no syntax, format, or defaulting information beyond what the schema provides; baseline 3 applies.

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

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

States a specific verb ('Get') and resource ('historical business or regional revenue segments'), and the word 'historical' implicitly contrasts with the sibling get_segments_latest. It stops short of explicitly naming that sibling, so an agent must infer the distinction.

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

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

Usage is only implied by the word 'historical' and the presence of get_segments_latest among siblings. There is no explicit when-to-use guidance, no mention of prerequisites, and no stated exclusion.

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 full behavioral burden. It implies a read-only operation via "Get" and freshness via "latest," but says nothing about permissions, rate limits, data source, or whether the call has any 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 a single, front-loaded sentence with no filler or repetition. Every word contributes to stating the tool's purpose, and nothing is wasted.

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

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

For a simple read tool with a fully described input schema and no output schema, the description covers the core purpose but leaves key gaps. It does not clarify what "latest" means in terms of period or how it differs from get_segments_history, which an agent needs for correct routing.

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

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

Schema description coverage is 100%, so the schema already documents all three parameters in detail. The description's mention of "business or regional" maps to the category parameter but adds no syntax or 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?

The description states a specific verb ("Get") and resource ("revenue segments") with a clear scope ("latest business or regional"). It does not explicitly differentiate from the sibling get_segments_history, though the word "latest" hints at the distinction.

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. The sibling get_segments_history is never mentioned, and the description does not explain that this is for the most recent period while that tool is for historical data.

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 states what is retrieved but omits whether the operation is read-only (though 'Get' implies it), any authentication or rate-limit requirements, and what the returned data includes beyond a high-level label.

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

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

The description is a single, front-loaded sentence with no wasted words. It efficiently conveys the core purpose, though it is minimal and could benefit from one more sentence of context without harming conciseness.

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

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

Given no output schema and no annotations, the description is incomplete. It does not explain what 'holdings and trading details' encompasses, nor does it state the prerequisite that the object_id must come from a prior get_shareholders_top call, leaving the agent to infer this from the schema alone.

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

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

Schema description coverage is 100%, so the schema fully documents all three parameters, including the prerequisite for object_id. The description adds no additional parameter meaning beyond what the schema already provides, which is the baseline expectation when coverage is high.

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 ('Get'), resource ('holdings and trading details'), and scope ('one shareholder object'). It implies differentiation from list-oriented siblings like get_shareholders_top and get_shareholders_latest, but does not name them 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?

The description provides no when-to-use guidance or alternatives. While the schema's object_id parameter description mentions a prerequisite (from get_shareholders_top with detail_available=true), the main description itself offers no context for selecting this tool over 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?

Annotations are absent, so the description carries the disclosure burden. It usefully clarifies that the report date reflects the disclosure period rather than the current moment, which is meaningful data-semantics context. It still omits return format, pagination, and whether auth is required.

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

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

Two tightly written sentences with zero waste, leading with the core action and following with the one semantic caveat that matters.

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

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

For a simple two-parameter read tool with a fully documented schema, the description covers the essential semantic caveat. It is adequate but thin: no sibling differentiation, no return-shape hint, and no safety/permission context despite the absence of annotations.

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

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

Schema description coverage is 100%, so both 'symbol' and 'type' are fully documented in the schema and the baseline is 3. The description adds no parameter-specific syntax or format detail 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 specific verb and resource ('Get the latest disclosed shareholder structure snapshot'), so the agent knows it retrieves a current ownership breakdown. However, it does not differentiate from close siblings like get_shareholder_detail or get_shareholders_top, leaving the agent to guess which shareholder 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?

There is no explicit when-to-use guidance and no mention of alternatives such as get_shareholder_detail or get_shareholders_top. The note about the report date is a data caveat, not usage 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 does disclose useful output behavior: results are grouped by period with normalized members, object_id is only valid where detail_available=true, percentages may be null, and *_raw preserves source text. These quirks are helpful and not derivable from the schema, though pagination/limits are unmentioned.

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

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

Compact and front-loaded: scope first, then return-shape notes. Every sentence carries information, though the object_id note is slightly ambiguous since it references an output field the agent has not yet seen.

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 describe the return grouping and null/raw caveats, which is valuable. However, it leaves gaps: whether results are paginated, how many periods are returned, and what 'normalized members' concretely contains.

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

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

Schema description coverage is 100%, so both parameters (type, symbol) are already documented in the schema. The description's mention of object_id pertains to a return field, not an input parameter, so it adds no parameter meaning beyond the schema baseline.

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

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

States a specific verb and resource (major shareholder holdings) and clarifies scope: 'across reporting periods, not only the top ten.' This meaningfully distinguishes it from get_shareholders_latest and get_shareholder_detail, though it never names those siblings 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?

The phrases 'across reporting periods' and 'not only the top ten' implicitly signal when to prefer this over a latest-only or top-ten-only variant, but no alternative tool is named and no explicit when/when-not condition is given. Usage must be inferred from the sibling list.

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 the return structure (data.events and top-level page), the meaning of empty events, the pagination protocol, and default date behavior when dates are omitted. It does not cover rate limits, auth requirements, or error conditions, but for a read-only fetch tool this is largely sufficient.

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

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

Front-loaded with purpose and filters, followed by return shape and pagination steps. Three sentences with no filler, though the pagination sentence is packed and could be slightly tighter.

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

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

Given six optional parameters, pagination behavior, and no output schema, the description supplies enough detail about return fields and cursor flow for correct invocation. It could mention market-restricted API key requirements, but that is covered by the parameter schema, so the omission is minor.

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

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

Schema description coverage is 100% with detailed per-parameter descriptions (limit range, cursor source, market values, symbol format, date defaults). The description adds pagination context but no new syntactic or semantic meaning beyond what the schema already provides, so the baseline 3 applies.

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

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

States a specific verb (Get) and resource (split events) with filter dimensions, clearly distinguishing it from sibling calendars like get_dividend_calendar, get_ipo_calendar, and get_report_calendar. An agent can identify the tool's domain 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?

Provides operational guidance for pagination (keep filters unchanged, pass cursor verbatim) and date defaults, which implies usage. However, it never states when to choose this tool over alternatives or any exclusions, leaving the when-to-use decision to inference from the name and description.

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 behavioral context: fields vary by market and may be omitted. However it says nothing about permissions, rate limits, pagination, or failure behavior for unsupported symbols, so the safety/operational profile is incomplete.

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

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

Front-loaded with the core purpose, followed by the field inventory and the omission caveat; every sentence earns its place. The odd indentation is cosmetic but the information density is good.

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 correctly compensates by listing the return fields and warning that they may be absent. It lacks error/edge-case behavior, but for a read-only lookup the essentials are covered.

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

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

Schema coverage is 100%, so both parameters are already documented (including the comma-separated symbol format and 500 cap). The description adds only market-scope context, which is already partially covered by the 'type' enum values in the schema.

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

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

States a specific verb+resource ('Get fundamental stock information') and enumerates the exact returned fields (company name, exchange, currency, lot size, shares, EPS, BPS, dividend yield, A-share board), which lets an agent separate it from siblings like get_company_profile or get_valuation_latest. It does not explicitly name an alternative, 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?

It declares the covered markets (US stocks, Hong Kong stocks, A-shares), which is useful scoping context, but gives no explicit when-to-use/when-not guidance and never routes the agent to a competing sibling for overlapping fundamental data.

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

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

With no annotations, the description carries the full burden and does so well: it declares the guaranteed fields (symbol, last_price, millisecond timestamp), flags which fields are conditional, and explains that crypto uses a rolling 24h window while traditional markets use the trading day/session. It omits auth/rate-limit and error behavior, but the return-shape and time-window semantics are meaningful behavioral disclosure beyond the schema.

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

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

Front-loads the core purpose in the first sentence, then layers return fields, then timing semantics, then supported assets. Every sentence carries information, though the return-field enumeration is somewhat list-like and could be tightened.

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 rightly explains the return values, and with no annotations it covers read semantics and market-specific time windows. It is nearly complete for a snapshot tool; a note on invalid symbols or rate limits would fully close the 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 description coverage is 100%, so the schema already documents both 'symbols' (comma-separated, max 50) and 'type' (disambiguation values and the 000001 example). The description adds no parameter-level detail beyond this, so baseline 3 applies.

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

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

States a specific verb and resource: 'Get real-time price snapshots for one or more symbols.' This clearly distinguishes it from siblings like get_kline (historical candles) and get_order_book. However, it never names a sibling explicitly, so the differentiation is inferential 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?

No when-to-use guidance and no alternatives are named. It lists supported markets (stocks, forex/metals, indices, crypto, futures) which hints at applicability, but an agent gets no help choosing between get_ticker, get_intraday, get_kline_latest or get_recent_trades.

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 usefully discloses the return content, including the half-day distinction, but says nothing about permission requirements, error behavior, or the range/recency constraints (which live only in the schema). Adequate but with clear gaps.

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

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

A single sentence with zero waste that front-loads the verb, resource, and payload. Nothing extraneous.

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

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

For a simple 3-parameter read tool with full schema coverage and no output schema, the description conveys the essential return content. It omits when-to-use context and sibling differentiation, and with no annotations there is nothing covering auth or failure modes, leaving it merely 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?

Schema description coverage is 100%, so the schema already documents market, beg_day, and end_day in detail. The description adds no parameter-level meaning beyond the schema baseline.

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

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

States a specific verb and resource ('Get the trading calendar') and even specifies the payload ('trading days and half-days'). However, it does not distinguish itself from near siblings like get_other_calendar or get_trading_sessions, 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 and no mention of alternatives or exclusions. The reader gets what the tool returns but nothing about when this tool is the right choice over the calendar/session 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 disclose the return encoding: market-local hhmm begin/end times plus a trade_session code mapped to regular/pre-market/after-hours/overnight. That is genuinely useful behavioral context and compensates for the absent output schema. It stops short of stating timezone handling details or whether schedules vary by date.

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 tool's purpose, then the return-value convention in two compact lines. The inline enumeration of session codes is dense but earns its place since no output schema exists. Minimal 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 single-optional-parameter lookup with no annotations and no output schema, the description supplies the return format, value semantics, and the all-markets default, which is largely sufficient. Date/range behavior and any calendar dependency are the only notable omissions.

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

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

Schema description coverage is 100% and the single market parameter is fully documented in the schema (uppercase US, HK, or CN; omit for all). The description adds only the same all-markets behavior, so baseline 3 applies.

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

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

States a specific verb and resource — retrieving trading session schedules per stock market — and clarifies the scope is one market or all. It does not, however, differentiate itself from similar siblings such as get_market_status or get_trade_days, 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?

The description implies usage by noting the market parameter can be omitted for all markets, and the schema repeats this. There is no explicit when-to-use or when-not-to-use guidance relative to sibling tools like get_market_status or get_trade_days.

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, and it does useful work: it discloses the return shape (points of [RFC3339 time, value] pairs), that values may be string/number/null, and the exact not-found error 40405. It omits auth/permission or rate-limit context, so not a 5.

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

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

Brief and front-loaded, with the core purpose stated in the first clause followed by return/error details. Slightly awkward indentation and line breaks, but no wasted sentences.

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

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

With no output schema, the description usefully fills the gap by describing the points structure and error behavior, and the schema covers the date/granularity defaults. Adequate for a 5-parameter read tool, though date-range interaction with granularity could be spelled out more.

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

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

Schema description coverage is 100%, so the baseline is 3; the schema already documents symbol, type, dates and granularity. The description adds only a marginal note (no metric parameter) rather than new parameter semantics.

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

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

States a specific verb+resource ('historical PE values') and implicitly distinguishes itself from the sibling get_valuation_latest by stressing history. It does not explicitly name the alternative, 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?

Clarifies a constraint ('no metric selector is supported') which preempts a likely wrong expectation, but gives no positive when-to-use guidance or explicit routing to get_valuation_latest. Usage is only implied.

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

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

No annotations are provided, so the description carries the full burden. It usefully discloses that unavailable values/range statistics may be null and must not be read as zero, which is genuine behavioral context, but it omits anything about auth needs, rate limits, or the tool being 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?

Two tightly scoped sentences with the tool's output and its null caveat front-loaded; nothing is redundant. Only the odd indentation slightly mars the structure.

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 small read-only tool with no output schema and no annotations, the description covers what is returned (PE and its one-year range) and the null handling, which is adequate. However it leaves the return structure and any error/permission 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 description coverage is 100%, so both the 'type' and 'symbol' parameters are already fully documented in the schema (including symbol format examples). The description adds no meaning beyond that, so the baseline 3 applies.

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

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

It states a specific verb ('Get') and resource (current PE plus one-year low/median/high) and pins the field path (metrics.PE). The 'current' qualifier implicitly separates it from the sibling get_valuation_history, though it never names that alternative explicitly.

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

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

The description offers no guidance on when to use this tool versus alternatives like get_valuation_history or get_market_metrics. There is no mention of prerequisites or conditions that select this tool over a sibling.

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