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

Goes well beyond the annotations (readOnlyHint=false, openWorldHint=true): it names both delivery sinks with concrete shapes, discloses that webhook targets are restricted to operator-allowed prefixes, warns that events are not replayed, explains the evaluation mechanism, and states nothing is ever traded. That is exactly the security/retention disclosure the annotations omit.

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

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

Front-loads the core action in the first sentence, then layers delivery, lifecycle and safety caveats in short clauses. Dense but each sentence carries information; only the awkward multi-line `action` formatting slightly hurts scannability.

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 create tool with a nested schema and no output schema, the description covers the lifecycle (evaluation by run_hooks/cron), delivery, and safety scope. Gaps remain around ticker/period meaning and what happens on name collision or re-creation, which matter for repeated calls.

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?

Top-level schema coverage is 0%, so the description must carry the load; it does well for `action` (with both target shapes and examples) and implies `condition` via the firing sentence, and nested $defs illustrate condition/series/indicator shapes. But `ticker`, `period`, `series` and `indicators` are never explained in the description, leaving half the required surface to inference.

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 ('Save a condition hook') plus the trigger semantics ('when the condition fires on a new bar, a JSON event is delivered'). This clearly separates it from lifecycle siblings list_hooks, run_hooks and delete_hook, which create nothing.

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?

Tells the agent that the hook does nothing until run_hooks or the broker-analysis-hooks cron command evaluates it, and that past events are not replayed — essential context for deciding whether to create one. It does not explicitly say when to prefer this over, say, custom_analysis, but the operational context is strong.

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?

Beyond the readOnlyHint/openWorldHint annotations, it discloses what the conditions block actually computes (active now, event count and dates, forward 5/20-session returns with a t-statistic vs all bars) and what comes back (JSON last values + condition reports, plus PNG when chart is true). That is real behavioral context an agent cannot get from the schema. It stops short of describing failure modes or data-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 a one-line purpose, then labeled blocks (indicators:, series:, conditions:, levels:) that let an agent jump to the relevant parameter. The multi-line JSON examples are long but each demonstrates a distinct concept; minor trimming would still earn its keep.

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 an 8-parameter tool with nested specs and no output schema, the description supplies both the composition grammar and the return shape, which covers the hardest gaps. Missing only secondary details like the default period window and the chart/title interaction.

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

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

With 0% schema description coverage, the description carries the burden and mostly succeeds: it supplies worked examples with concrete shapes for indicators, series, conditions, and levels, and notes that chart controls PNG emission. It leaves period's accepted formats and title's effect unexplained, and the condition mode ('edge' vs 'state') distinction is only in the nested schema, not the description.

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

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

The description opens with a specific verb + resource + scope: 'User-defined technical analysis on one ticker, with an optional chart.' The word 'user-defined' distinguishes it from the preset-oriented sibling technical_indicators, and it names list_indicator_catalog as the discovery path. An agent can tell this is the escape hatch for arbitrary indicator/condition composition.

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 sequencing rule: 'Call list_indicator_catalog first to see indicators, parameters and functions,' which prevents blind guessing at fn names. It does not state when to prefer this over technical_indicators or risk_metrics, so the alternative-selection guidance is implicit rather than explicit.

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

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

Annotations already declare destructiveHint=true, idempotentHint=true, and readOnlyHint=false, so the agent knows this is a destructive but idempotent write. The description adds only "saved" and "by id" and does not explain consequences such as whether deletion is permanent, what happens with an invalid id, or whether confirmation 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?

The description is a single, front-loaded sentence with no wasted words. It immediately conveys the operation and the required identifier.

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?

This is a simple one-parameter deletion tool whose annotations already cover the destructive and idempotent behavior. However, the description does not explain the hook_id source, expected return behavior, or deletion consequences, leaving some gaps for an agent invoking it correctly.

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

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

Schema description coverage is 0%, so the description must compensate for the undocumented hook_id parameter. It says only "by id," without indicating where the id comes from, its format, or how to obtain it from list_hooks. This adds marginal meaning beyond the schema's type declaration.

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: "Delete a saved hook by id." This clearly identifies the operation as deleting a stored hook. It does not explicitly distinguish itself from siblings like create_hook or list_hooks, but the action is unambiguous.

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

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

The description gives no guidance on when to use this tool versus alternatives such as list_hooks or run_hooks. There are no exclusions, prerequisites, or conditions for use beyond the implied action of deletion.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered. Beyond that the description adds genuinely useful behavior: the benchmark is converted to the fund's currency, and tracking difference is defined as fund minus benchmark on an annualised basis — details an agent could not infer from structured fields.

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 tight sentences that front-load the metric list before the benchmark advice. Nothing is padded, though the parenthetical definition adds a clause that could be trimmed without loss.

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 telling the agent what comes back (TER, tracking difference, tracking error) and in what convention. The main omission is the period parameter's accepted values, which leaves one of three inputs underspecified.

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

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

Schema description coverage is 0%, so the description carries the burden. It explains the benchmark parameter's semantics well (currency conversion, total-return preference) and implies ticker meaning, but 'period' is left completely undocumented — its default '3y' and accepted formats/values are nowhere stated, which is a substantive gap for a 3-param tool.

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

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

Names a specific resource (ETF cost and replication quality) and enumerates the exact metrics produced: TER, tracking difference (fund minus benchmark, annualised) and tracking error versus a benchmark ticker. This is clearly distinguishable from siblings like risk_metrics or fundamental_ratios, though it never explicitly positions itself against 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?

The final sentence gives real guidance on benchmark selection ('prefer a total-return index or a reference ETF on the same index'), which is a meaningful usage constraint. However, there is no statement of when to choose this tool over risk_metrics or peer_comparison, nor any prerequisite or exclusion, so 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?

Annotations already declare readOnlyHint and openWorldHint, so the description is not carrying the safety burden; it instead adds real substantive behavior: data provenance (latest annual statements, USMx sheet), beta defaulting to Yahoo's, analyst-supplied decimals for the risk-free rate and ERP, and null semantics for non-meaningful ratios. That is meaningful context beyond the structured fields.

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

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

A single dense paragraph, front-loaded with the resource and immediately followed by the enumerated ratio families, so an agent scanning the first clause already knows what it gets. It is long but nearly every clause carries distinct information; only the DuPont formula restatement is arguably filler.

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

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

For a read-only, four-parameter analytics tool with no output schema, the description covers what is returned, the key exceptional cases (nulls, banks/insurers excluded from score models), and the meaning of the optional inputs. Missing only any note on period fallback when no annual statement exists.

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

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

Schema coverage is 0%, so the description must compensate, and it largely does: it explains that beta defaults to Yahoo's and that risk_free_annual/equity_risk_premium are decimals supplied by the analyst, and it implies the ticker identifies the company. It still does not state the units/convention for beta itself or whether the optional risk inputs are required as a pair.

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 the exact resource — ratios derived from the latest annual statements — and enumerates the families returned (valuation, DuPont, turnover, liquidity, leverage, payout, plus F-scores/Z-scores/M-score). That enumeration makes it easy to separate from siblings like technical_indicators or risk_metrics. It never explicitly names an alternative tool, 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?

Usage is implied: call it with a ticker to get annual-statement fundamental ratios. There is partial conditional guidance — CAPM/WACC/EVA only appear when risk_free_annual and equity_risk_premium are supplied, and Piotroski/Altman/Beneish are not computed for banks and insurers — but there is no explicit 'use this instead of X' routing.

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

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

Annotations already declare readOnlyHint=true and openWorldHint=true, so the safety profile is covered. The description adds that each entry carries its condition, action, and last delivered event, which is useful payload context beyond the annotations, but it says nothing about whether all hooks are returned or how delivery history is bounded.

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

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

A single compact clause with no filler, front-loaded with the resource. It is arguably terse rather than wasteful, and the returned-field list is placed where it does the most work.

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

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

With no output schema, the description partially compensates by naming three returned fields, but it omits scope (all hooks vs. filtered), ordering, and any pagination or size limits. For a zero-argument read tool that is adequate but leaves real gaps for an open-world listing.

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 and the schema is an empty object, so there is no parameter semantics to explain. Baseline 4 applies; the description's field list describes output rather than inputs.

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 identifies the resource (saved condition hooks) and enumerates the fields surfaced (condition, action, last delivered event), but it is a noun phrase with no verb, so the listing action is only inferred from the tool name. It does not explicitly contrast with run_hooks or create_hook, leaving sibling differentiation to the names.

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 call this versus run_hooks, create_hook, or delete_hook, and no stated preconditions. An agent must infer that this is the inspection path for existing hooks purely from the word 'Saved'.

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?

readOnlyHint and openWorldHint already cover the safety profile, so the description's contribution is payload disclosure: it tells the agent the catalog includes typed parameter metadata (default/min/max), outputs, pane assignment, permitted expression functions, and syntax rules. That is meaningful context beyond the annotations, though it doesn't say whether results are paginated or how large the catalog is.

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

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

A single dense sentence with the workflow anchor ('building blocks for custom_analysis and create_hook') front-loaded, then a semicolon-delimited list of contents. Every clause earns its place, though the semicolon chaining is slightly harder to scan than separate sentences would be.

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

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

With no parameters and no output schema, the description carries the burden of explaining what comes back, and it does so by naming the five content categories an agent will encounter. What is missing is any hint of response shape or volume, which matters for an open-world catalog tool, keeping it below 5.

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

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

The tool takes zero parameters, so the baseline is 4 and no parameter explanation is required. The description's mention of 'typed parameters (default, min, max)' correctly refers to properties of the returned indicators, not to inputs, and does not confuse the agent.

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 enumerates the resource contents precisely: catalog indicators with typed parameters (default, min, max), outputs, pane, allowed expression functions and syntax. It clearly reads as a reference/catalog lookup rather than a computation, and it ties itself to the custom_analysis and create_hook siblings. It never states the verb ('list'/'returns') and doesn't explicitly distinguish itself from technical_indicators, 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?

The phrase 'building blocks for custom_analysis and create_hook' implies the workflow (consult this before authoring an analysis or hook), but there is no explicit when-to-use statement, no condition for choosing it over technical_indicators or list_hooks, and no exclusions. Usage is inferable rather than 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?

Adds real behavioral context beyond the readOnly/openWorld annotations: partial results are surfaced ('Failed tickers are reported, not dropped silently') and the response deliberately omits score components and their inputs, pointing elsewhere for those. It stops short of describing output layout or latency/cost characteristics, which matters somewhat given there is no output 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?

Four short sentences, front-loaded with what the tool returns and its scope, then failure behavior, then the sibling route. Every sentence carries a distinct, non-redundant fact.

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

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

For a one-parameter, read-only, open-world tool with no output schema, the description covers scope, cardinality, partial-failure handling, and sibling routing. The remaining gap is that it never sketches the shape of the returned comparison (scores vs. ratios, ordering), which an agent must infer.

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

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

Schema coverage is 0% and the schema is a bare array of strings with no minItems/maxItems, so the description carries the constraint load: it supplies the 2-10 cardinality bound and the implicit requirement that all tickers belong to one sector. It does not specify ticker format (exchange suffix, case), leaving one residual ambiguity for a single-parameter tool.

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 concrete verb and resource ('Fundamental ratios and scores for several companies side by side') plus the cardinality bound (2 to 10 tickers) and the intended purpose (relative valuation within one sector). It also explicitly contrasts with the sibling fundamental_ratios for the single-company case, so an agent can choose between them 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?

Gives an explicit use condition ('for relative valuation within one sector') and an explicit alternative ('call fundamental_ratios for one company'), which is the main routing decision for this tool. The 2-to-10 ticker bound further rules out degenerate single-ticker or bulk-universe calls.

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

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

Annotations already declare readOnlyHint and openWorldHint, so the description's job is lighter and it delivers: it enumerates the full metric set returned, notes benchmark currency conversion, specifies the Bloomberg-style beta convention (2y weekly, 0.67 raw + 0.33 adjusted) and the Morningstar-style monthly capture. Missing: data source/rate limits or behavior for invalid or delisted tickers, which is the main residual 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?

Front-loaded with purpose in the first sentence, then outputs, then the conditional benchmark branch, then parameter conventions. Dense but every sentence adds information; the middle output-enumeration sentence is long but each metric name earns its place since no output schema exists.

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

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

With no output schema, the description compensates by enumerating return values and clarifying the benchmark-conditional extras. Five parameters are largely covered, defaults for period are implied, and the only meaningful gap (confidence semantics) is minor for a read-only analytical call.

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

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

Schema coverage is 0%, so the description must carry the load, and it documents 4 of 5 parameters well: period enumerates all valid values (1y, 2y, 3y, 5y, 10y, max), risk_free_annual gives the decimal convention (0.03 = 3%), benchmark explains its effect and currency handling, and ticker is implicit in the opening sentence. The 'confidence' parameter (default 0.95) is never mentioned, leaving its role in the VaR/ES computation undocumented.

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-scope ('risk and performance of one security or index') and the data source ('daily total-return prices'), which distinguishes it from siblings like fundamental_ratios or peer_comparison that operate on accounting or comparison data. It does not explicitly name an alternative, but the resource and computation type are 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?

Usage is implied rather than stated: an agent can infer it should pass a ticker for a single-asset risk report, and the benchmark sentence describes a conditional mode (add a benchmark to get beta/alpha/capture). There is no explicit when-to-use/when-not, and no naming of sibling tools such as technical_indicators or etf_analysis that might also be candidates.

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 declare readOnlyHint=false and openWorldHint=true, so the agent knows state is mutated and external side effects are possible; the description's 'newer than each hook's last one' adds useful context about a per-hook cursor. However, it never states whether events are consumed/acknowledged (i.e., whether a second call re-delivers the same events), nor does it warn about outbound calls, latency, or partial failures — the key behavioral facts for a non-read-only, open-world 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?

One front-loaded sentence with no filler; the scope ('every saved hook') and the incremental semantics land immediately.

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 zero parameters and no output schema, the description carries the burden of explaining the response — and it only says 'deliver the events'. It does not indicate the shape of the result (per-hook grouping vs flat list), what happens for hooks with no new events, or how errors on individual hooks are reported.

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

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

The tool takes no parameters, so there is nothing to disambiguate; the description correctly implies the operation is global across all saved hooks with no filtering argument.

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 ('evaluate') plus resource ('every saved hook') plus the effect ('deliver events newer than each hook's last one'), which is far more informative than the bare name. It implicitly distinguishes itself from list_hooks/create_hook/delete_hook by being an execution action, 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 phrase 'now' hints at an on-demand trigger and 'newer than each hook's last one' hints at incremental polling, but there is no explicit when-to-use/when-not or guidance such as 'use list_hooks to inspect configuration instead'. Usage 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?

Annotations already declare readOnlyHint and openWorldHint, so the safety profile is covered; the description adds that the result is a point-in-time snapshot and that keys are period-suffixed (sma50, rsi14, atr14), which is real behavioral context. It stops short of saying what happens when the period is too short for the slow SMA (error vs. omitted key) or how the values are unit-typed beyond ATR.

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 payload contents, then key naming, then the usage constraint, then the alternative-tool pointer -- roughly five dense sentences with no filler. Every sentence adds information an agent would otherwise have to guess.

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

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

Because there is no output schema, the description's enumeration of returned fields and key naming convention does the heavy lifting well, and the sibling pointer closes the main ambiguity. The notable remaining gap is the 'period' string parameter, whose accepted formats are undocumented in both schema and description.

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

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

With 0% schema description coverage across 11 parameters, the description must carry the load and only partly does: it maps to the SMA fast/slow pair, the RSI/MACD/Bollinger/ATR groups, and explains the period-embedded key naming. It says nothing about bollinger_k vs bollinger_n, macd_fast/slow/signal roles, the string format of 'period' (default '1y'), or expected ticker format, leaving several parameters undocumented anywhere.

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 artifact (a snapshot of standard technical indicators) and enumerates exactly what it contains: close, two SMAs with distance from price, RSI, MACD, Bollinger bands, ATR in currency and percent, and 52-week high/low with distances. It also distinguishes itself from the sibling custom_analysis, so an agent can pick it without opening the schema.

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

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

It states the routing condition explicitly: for custom indicators, expressions, conditions, or a chart, use custom_analysis instead. It also gives a positive usage constraint -- the requested period must be long enough for the slow SMA -- which is precisely the kind of precondition an agent would otherwise get wrong.

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