FinzData market data

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

Annotations already declare read-only/idempotent/non-destructive, so the bar is lower, yet the description adds real value: it returns (path, encoding, content) plus load_code and tells the agent to write files at their paths and then run load_code. That side-effect protocol is essential and is not inferable from annotations. It does not state file sizes, rate limits, or what happens if paths already exist.

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 what the tool produces, then the framework list, then the return protocol and clipping rules — no filler. The framework enumeration is dense but earns its place because the enum values are the selection choice; only minor tightening is possible.

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

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

With no output schema, the description correctly takes on the burden by describing the return payload and the load_code handoff. What is missing is minor but real for a file-export tool: symbol format expectations, behavior on existing file paths, and whether end is inclusive.

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 only 20% (only as_of is documented), so the description must compensate and largely does: it names the valid framework values, explains that output is "clipped to as_of," and supplies the undocumented default that start is 365 days before end. It still says nothing about the symbol format or what end defaults to.

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 ("Daily OHLCV bars for one symbol packaged as ready-to-load files") and enumerates the target frameworks, which cleanly separates it from the raw-bar sibling get_bars and from run_backtest. An agent knows exactly what artifact it gets back.

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 purpose implies the when (you need on-disk files for a specific framework rather than raw JSON bars), but no sibling is named: get_bars and run_backtest are never referenced, and the description gives no explicit exclusion or precondition beyond the framework 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?

Beyond the annotations (readOnlyHint false, idempotent, non-destructive), it discloses real behavioral detail: weekly default rebalance, equal weighting up to top_n, 10 bps costs, point-in-time delisted-inclusive universe, and a metered cost of one backtest. It does not say what happens with invalid scan syntax or whether a failed run still consumes the credit.

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 dense, front-loaded paragraph that leads with the verb and universe, then mechanics, then return shape. Efficient, though the run-on semicolon-free phrasing makes the methodology clauses slightly harder to parse than necessary.

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

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

No output schema exists, and the description compensates by naming what comes back: the translation plus the same stats, benchmark and equity curve as run_backtest, which lets an agent plan downstream use. Missing only date-range semantics and failure behavior for malformed scan text.

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 57% schema coverage, the description adds meaning for symbols (optional universe restriction, e.g. a ChartList), rebalance (weekly default) and top_n (cap). However start/end have no schema descriptions and get no explanation here either, and as_of is only handled by 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 (backtest a StockCharts.com scan) plus scope: point-in-time US stocks since 2000 with delisted names included. It also implicitly separates itself from translate_stockcharts_scan (this returns the translation AND results) and from run_backtest (same stats/benchmark/equity curve, but driven by a scan).

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: you use it when you have StockCharts scan text and want portfolio results. The 'Costs one backtest' note gives a useful budget signal, but there is no explicit 'use translate_stockcharts_scan first to validate syntax' or any when-not guidance against run_backtest or compare_runs.

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 give the safety profile (non-read-only, idempotent, non-destructive), and the description adds genuinely useful context beyond them: the first-claimant-wins rule and an escalation path for disputes. It does not say what happens on a re-claim or what a successful response contains, so it falls short of full 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?

A single front-loaded sentence covering action, outcome, exclusivity rule, and dispute path with no filler. The dispute contact is slightly peripheral to invocation but justifies its place as an edge-case escape hatch.

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 mutation tool with no output schema, the description covers the action and the exclusivity semantics but omits permission requirements, re-claim behavior, and failure modes (e.g., already claimed). Adequate but with clear gaps an agent would want before invoking.

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

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

Schema coverage is 0% for the single 'slug' parameter, so the description must carry parameter meaning. 'Claims a listing' implies the slug identifies that listing, but no format, casing, or source (e.g., from search_mcp_servers results) is given.

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 ('claims') and resource ('a listing') scoped to the calling API key, and explains the downstream purpose (enabling price-accuracy checks). It distinguishes itself from get_mcp_server and search_mcp_servers by being a write/ownership 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?

There is no explicit when-to-use or when-not-to-use guidance, and no alternative is named despite get_mcp_server and search_mcp_servers being obvious related siblings. 'First claimant wins' hints at the competitive nature of the action but does not tell an agent when claiming is appropriate versus just looking a listing up.

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 a non-read-only, open-world, non-idempotent mutation. The description adds that the comment is public, capped at 1-2000 characters, and attributed to the user's handle, which are meaningful traits beyond the annotations. It does not cover auth/permissions or moderation, but with annotations the bar is lower.

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 sentences, front-loaded with the action and key constraints; no wasted text. The examples are compactly integrated.

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 mutation with no output schema, the description supplies the essential visibility, length, and attribution context. It leaves response/failure and permission details implicit, so it is not fully exhaustive.

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 neither parameter is described in the schema. The description compensates by defining body as a 1-2000 character public comment and implying slug identifies the Hub strategy, though slug format is omitted.

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 ('Posts') and resource ('a public comment ... on a Hub strategy') and clarifies content types. It does not differentiate from siblings such as fork_strategy or publish_strategy, but the core 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?

Examples ('a question, a result from a fork or a suggested change') imply when commenting is appropriate, but there is no explicit when-not guidance or named alternative for related actions like forking or publishing. Selection remains inferable 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?

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is covered. The description adds the exact return columns and the error behavior ('Unknown run_id -> not_found'), which is useful context beyond annotations, though it does not discuss ordering, limits, or empty results.

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 front-load the return shape, then the error behavior. Every sentence earns its place with no filler.

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

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

For a simple, read-only comparison tool with rich annotations and no output schema, the description is nearly complete: it enumerates the returned columns and states the not_found behavior. It falls short only on edge cases like empty run_ids or duplicate handling.

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

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

Schema description coverage is 0%, so the description must compensate. It does clarify that run_ids refer to 'previously run backtests in this session' and that unknown IDs produce not_found, but it leaves ambiguity around array ordering, duplicate IDs, and maximum length. This is partial compensation for undocumented 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 ('Returns a table') and resource (backtest metrics) and scopes it to 'previously run backtests in this session', which implicitly distinguishes it from run_backtest. It does not explicitly name an alternative sibling, but the scope is clear enough for an agent to understand what it does.

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 'for previously run backtests in this session' implies when the tool is applicable, and the not_found behavior gives a hint about input validation. However, there is no explicit guidance on when to prefer this over run_backtest or other comparison tools, and no exclusion conditions are given.

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

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

Annotations already declare readOnly, idempotent, non-destructive and closed-world, so the safety profile is covered. The description adds genuine value beyond them by disclosing the return contents (schema, coverage, field definitions) and the not_found error for an unknown id — useful pre-call knowledge. It stops short of noting auth or rate-limit behavior.

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

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

Two sentences, zero filler, with the payoff (what is returned) front-loaded and the failure mode relegated to sentence two. Nothing to cut.

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

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

For a single-parameter read tool with no output schema, the description covers both the return shape and the error case, which is enough to call it correctly. It would be complete at a 5 if it sourced the dataset id (e.g. from search_datasets).

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

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

Schema coverage is 100% and the single parameter's schema text ('Dataset id.') matches what the description implies. The description adds nothing about id format, case sensitivity, or where such an id comes from, so the baseline 3 is correct.

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

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

States a specific verb (returns) and resource (schema, coverage and field definitions of one dataset), so an agent knows exactly what it gets back. It does not name or differentiate itself from the obvious sibling search_datasets, which is the only thing keeping it from a 5.

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

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

Usage is only implied: the 'one dataset id' framing suggests it follows a search, but the description never says when to call this versus search_datasets, nor what to do if the id is unknown beyond the error. No exclusions or alternatives are stated.

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

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

Annotations already declare readOnlyHint=false, idempotentHint=false and openWorldHint=true; the description goes beyond them by disclosing the mutation chain (a fork is published and parent-linked) and, valuably, that each call consumes one backtest credit. It stops short of stating explicitly that repeated calls create separate forks, which is the practical consequence of non-idempotency.

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

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

A single dense sentence front-loads the verb chain and parenthetical only where it earns space (the merge example). 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?

For a non-idempotent mutation with a nested-object parameter and no output schema, the description covers the workflow and cost but says nothing about the result — what identifier the new fork returns or how to reference it afterward — nor what happens on slug mismatch or validation failure.

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 only 25% — only as_of is documented — and the description compensates for exactly one parameter, explaining `changes` as a nested-merge patch with a concrete example. `slug` and `title` remain unexplained in both schema and description, so an agent must infer that slug is the source strategy identifier and title the fork's name.

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

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

The description gives a precise verb chain (copies, applies changes, re-runs, publishes) on a named resource (a published Hub strategy), and the parent-link detail makes it clearly distinct from publish_strategy or run_backtest. An agent can predict the side effects from the first clause alone.

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

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

Usage is implied by the operation sequence — this is the tool for deriving a new strategy from an existing published one — but no alternative is named (e.g. why not get_strategy + register_strategy + publish_strategy, or run_backtest for a trial run). The 'Costs one backtest' note gives useful cost context but not a when/when-not decision rule.

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 read-only, idempotent, non-destructive, and closed-world behavior. The description adds useful behavioral context beyond annotations by explaining the point-in-time cutoff, the default of today, and that filings after as_of are hidden, which prevents look-ahead bias.

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 text. It efficiently conveys the core behavior and temporal filtering rule.

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 tool with annotations and no output schema, the description covers temporal behavior well. However, it leaves the required query parameter's semantics unexplained, which is a meaningful gap given the 50% schema description coverage.

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 only 50%. The as_of parameter is already well documented in the schema, while the required query parameter has no schema description and the tool description adds almost nothing beyond 'matching a query', leaving its expected syntax or matching semantics undefined.

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 ('Returns') and resource ('13F holdings') along with point-in-time scope. The purpose is clear, but it does not explicitly differentiate itself from related sibling tools such as get_fundamentals_pit or get_cot.

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 when to use the tool via 'matching a query' and the as_of cutoff, but it provides no explicit alternatives, exclusions, or guidance on when another sibling tool would be more appropriate.

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 readOnly/idempotent/non-destructive and openWorldHint=false. The description still earns credit by disclosing the as_of clipping rule that prevents look-ahead bias and the 5000-row page ceiling. It loses a point for referencing next_cursor, which does not appear in the schema, leaving the agent unsure how to actually page.

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 dense sentences, both front-loaded: the core behavior first, then the operational constraint (pagination). No filler.

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

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

For a 5-param data tool with no output schema, the description should sketch the returned shape and tighten parameter formats. It also promises a next_cursor parameter the schema omits and says 'daily' where intraday bars are supported, leaving small but real ambiguities.

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 only 40%, and the description adds real meaning for as_of (default today, prevents future leakage), but start and end get no format or inclusivity guidance and symbols/bar are only touched on via the mismatched 'daily' wording. Partial compensation for a low-coverage schema lands at the 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 (returns OHLCV bars) plus scope (symbols between start and end, point-in-time clipped). The word 'daily' is slightly at odds with the schema's intraday bar options, so an agent wanting 1m/1h bars gets a mildly misleading signal, but the core purpose is unmistakable.

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

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

Explains pagination mechanics (5000-row page, next_cursor) and implies fitting into a point-in-time workflow, but gives no guidance on when to choose this over sibling tools like get_fundamentals_pit, get_crypto, or get_futures that likely also surface price 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?

Annotations already establish readOnly, idempotent, non-destructive, closed-world behavior, so the description's added value is the pagination cap of 5000 rows and the as_of clipping semantics. The page limit is genuinely useful planning information not present in annotations, though it omits ordering and what the rows contain.

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

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

A single compact sentence with the scope stated first and the volume constraint last; every clause carries information and nothing is padded.

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

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

No output schema exists, so the description should say more about the shape of returned rows (columns, aggregation levels) and it mentions a 5000-row page cap without any offset/cursor parameter being available. Adequate for basic invocation but leaves real gaps 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 coverage is only 25%: as_of is documented but start, end, and market are bare strings with no format guidance in either schema or description. The description only restates that start/end bound the range and that market selects a market, adding nothing on expected formats or identifiers.

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 ('Returns') and a specific resource ('CFTC Commitments of Traders rows') scoped by market and date range. The resource is distinctive from siblings like get_futures or get_bars, though the description never explicitly names the boundary between them.

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

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

No statement of when to use this versus alternatives such as get_futures or get_macro_vintage, and no prerequisites or exclusions. The agent must infer usage entirely from parameter names.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), and the description adds genuinely new context: history depth since 2015, clipping to as_of to prevent look-ahead, and that free keys are limited to daily bars over the last 12 months. That entitlement disclosure is exactly the kind of thing annotations cannot express.

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 resource and data shape, then interval, then temporal clipping, then tier limits. No filler, though the order puts a breadth statement ('and more') slightly ahead of the more actionable constraints.

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

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

For a 5-parameter tool with no output schema, stating the OHLCV shape is a solid substitute. Still missing: row-count or pagination behavior, start/end semantics and their default range, and what an empty or tier-blocked response looks like — all relevant for a tool an agent will call repeatedly.

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 40% schema coverage, the description meaningfully supplements interval (enum values plus default) and reinforces as_of clipping, and gives a symbol format example. However, start and end — the two undocumented parameters — receive no explanation of format, defaults, or interaction with as_of, leaving the coverage gap partly unaddressed.

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?

Opens with a specific verb+resource ('OHLCV bars for crypto pairs') and scopes the asset class with concrete examples and a start year. It never names the adjacent get_bars (equities) sibling, so an agent must infer the crypto-vs-equity split from the name alone.

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

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

It does give practical selection guidance for the interval parameter (four valid values, 1day is the default) and states a tier-based constraint, which implicitly tells the agent when results will be limited. There is no explicit when-to-use/when-not framing and no pointer to get_bars or other siblings for non-crypto 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?

Annotations already cover read-only, idempotent, non-destructive, closed-world behavior, so the description is not carrying the safety burden. It adds genuine context beyond them: the as_of clipping that prevents look-ahead bias and a hard 'Max 5000 rows per page' ceiling, which is the kind of operational limit annotations do not express.

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 dense sentences with no filler: scope first, then the kind semantics, then the row-limit constraint. Every clause carries information an agent would otherwise have to infer.

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 read-only tool with no output schema, the description plus annotations are nearly sufficient. The one loose end is 'Max 5000 rows per page' when no pagination or offset parameter exists in the schema, so the agent is told a limit without being told how to page past it.

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

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

Schema coverage is only 40% — start, end and kind have no schema descriptions — and the description compensates well: it supplies the YYYY-MM-DD format for the date bounds, defines both enum values for kind with concrete examples, and explains what as_of clips. It does not say whether 'end' is inclusive or what happens when it is omitted, leaving a residual gap.

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

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

States a specific verb and resource ('Returns events of one kind between start and end') and then enumerates the two kinds with concrete content examples ('earnings' = company report dates with symbol and timing; 'macro' = CPI, payrolls, FOMC). That enumeration distinguishes it from data-retrieval siblings such as get_macro_vintage or get_bars, which return values rather than event dates.

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

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

The description clarifies the two kind values and the point-in-time role of as_of, which implicitly tells the agent when the tool is appropriate. However, it never names an alternative or an exclusion — an agent cannot tell from the description alone whether to reach for this or get_macro_vintage / get_cot for macro-related questions.

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 cover readOnly/idempotent/non-destructive/closed-world, so the bar is lower; the description earns credit by disclosing the no-look-ahead guarantee, which is a genuine behavioral trait not encoded anywhere in the schema or annotations. It does not say what data classes (income statement, ratios, etc.) come back, 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?

Two short sentences, zero filler, with the point-in-time constraint front-loaded before the default. Every clause earns its place.

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

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

For a 2-parameter read tool with no output schema, the PIT semantics and the default are covered, but the description never indicates what "fundamentals" actually contains. With no output schema to fall back on, an agent cannot predict the return shape.

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?

Coverage is 50%: as_of is fully documented in the schema and the description only restates its default, while symbol has no schema description and the description adds nothing beyond "one symbol." Baseline 3 is appropriate since the schema carries most of the weight.

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 ("Returns fundamentals for one symbol") and pins the temporal semantics with "as known on as_of (no restatements from the future)." It is clearly distinct from siblings like get_bars or get_macro_vintage, though it never explicitly routes against an alternative.

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?

"as_of defaults to today" implies the usage context (point-in-time, backtest-safe lookups) but never states when to choose this tool over a sibling or when a caller would want a non-default as_of. Usage is implied rather than guided.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the bar is lower, and the description still adds real behavior: point-in-time clipping that prevents look-ahead bias, the 2007 history horizon, and a paywall (free keys get recent days, full history from $49/market). It doesn't discuss pagination or row limits, which keeps it from 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 data scope, then the two calling modes, then the paywall note; each sentence carries information. Slightly dense and example-heavy, but the examples (ES, NQ, CL …) do real work for the root parameter.

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

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

With no output schema and six parameters, the description should say more about what comes back (column set, whether open interest is a separate field) and about start/end range semantics. Coverage and paywall are well handled, but these gaps leave an agent guessing at the response shape.

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 67%, so baseline is 3. The description adds useful semantics beyond the schema for root (leading '/' tolerated, many examples) and the continuous-vs-contract interaction ('default true when no contract'), but it says nothing about start or end, the two undocumented 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?

States a specific verb and resource (daily OHLCV and open interest for futures) with unusually precise scope: 139 markets, named exchanges, coverage since 2007, individual contracts vs. continuous back-adjusted series. Any agent can tell this is the futures-bars tool and not the equity get_bars sibling.

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

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

Explains the two invocation modes clearly — pass root for the continuous series, or contract (e.g. ESZ26) for a single contract — and notes that output is clipped to as_of. It never explicitly excludes alternatives (e.g. 'for equities use get_bars'), so it stops short of a 5.

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

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

Annotations already cover read-only/idempotent safety, but the description adds genuinely non-obvious context: coverage of 139 markets since 2007, the exact back-adjustment relation (adjusted = raw + back_adjustment), and the caveat that the current front month's next roll date is estimated rather than actual. That estimate caveat is the kind of disclosure an agent needs and could not infer from annotations.

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 resource and coverage, then the field list, then the formula, then the invocation instruction. It is a dense paragraph, but every clause carries information an agent would otherwise have to guess; minor cost is the slightly run-on field enumeration.

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 correctly carries the burden of describing the returned record fields and does so in detail, plus the estimation caveat. The remaining gap is the two undocumented date parameters, which leaves the agent guessing about the time-filter contract.

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 only 33% — root is described in-schema and the description reinforces it with examples and the ALL sentinel, which is useful. But start and end are bare strings with no explanation in either place; the description's 'since 2007' hints at a date-range scope without stating format, defaults, or whether they filter by roll date or contract date.

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 (roll calendar for futures markets) and enumerates exactly what each record contains: first/last front-month dates, expiry, next contract, roll date, trading days before expiry, and back-adjustment. This clearly separates it from the sibling get_futures, which returns price data rather than contract-roll metadata.

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 closing instruction 'Give root (ES, CL, GC ...) or ALL' guides invocation but is really parameter usage, not when-to-use guidance. Nothing tells the agent when to prefer this over get_futures, or whether it should be used alongside a bars request to build a continuous series.

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 read-only annotations already covering safety, the description adds substantial behavioral context: knowledge_time stamping, as_of look-ahead protection, hidden rows after as_of, free-key 30-day limits, and upgrade meta behavior. It also explains that ticker series return a summary with regime and wall distances.

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

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

The description is front-loaded with purpose and output shape, then gives invocation modes, point-in-time behavior, and tier limits. Despite being dense, every sentence carries operational information for selection or correct invocation.

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 carries the full return-value burden, and it does: it enumerates columns, explains summary output, describes cross-section ranking, and discloses entitlement limits and upgrade metadata. An agent has enough to call it correctly without opening further docs.

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

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

Schema coverage is 50%, so the description must compensate, and it does for most parameters: ticker and start/end imply time series, date alone selects cross-section mode, and as_of is explained as a point-in-time cutoff. The summary flag is only indirectly covered via the returned summary block, and start/end are not richly specified, so it is not a 5.

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

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

The description states a specific verb and resource: point-in-time dealer gamma exposure for US stocks and ETFs, with one row per ticker per session. It also names the exact output columns, making the tool's scope unmistakable and distinct from generic bars or fundamentals siblings.

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

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

It clearly explains the two invocation modes: ticker plus optional start/end for a time series, or date alone for a cross-section ranked by absolute net gamma. It does not explicitly compare against sibling tools or state when not to use it, keeping it just short of a 5.

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

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

Annotations already declare readOnlyHint, idempotentHint, destructiveHint=false and openWorldHint=false, so the safety profile is fully covered. The description's vintage/as-of framing restates what the as_of schema field already says ('preventing look-ahead bias', 'Defaults to today (UTC)'), adding little beyond it; nothing is said about output shape, pagination, or what happens if as_of predates the series.

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, front-loaded sentences with no filler; the core vintage concept leads. 'Optional start' is terse to the point of being uninformative, but nothing is padded.

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

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

For a simple three-parameter read tool with no output schema and rich annotations, the missing piece is the required 'series' identifier format and any hint of return shape. The description is adequate for the temporal semantics but leaves a genuine gap on the one required input.

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 only 67%, and the undocumented parameter is the required one: 'series' has no description anywhere, so the agent has no idea what identifiers are valid. The description mentions 'as_of' (already fully documented in the schema) and dismisses 'start' as merely 'Optional start', adding essentially no semantics over 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 (returns) and resource (a macro series) and pins down the distinguishing semantics: the data as actually published as of a date, with no future revisions. An agent can tell this is a point-in-time macro fetch, though it never names the neighbouring point-in-time tool (get_fundamentals_pit) that could be confused with it.

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

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

The phrase 'as it was actually published ... no revisions from the future' implies the backtest/look-ahead-avoidance use case, but there is no explicit when-to-use, when-not-to-use, or alternative named among the many siblings. The agent must infer the selection rule.

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?

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is clear. The description adds useful context about the returned content categories (tools, probe history, issues, verified-data status), but it does not mention missing-server behavior, auth requirements, or result structure.

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

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

A single front-loaded sentence with no filler. It immediately names the verb, the resource, and the key content returned.

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 rich annotations and no output schema, the description gives a reasonable summary of the returned data categories. However, it omits the meaning of the required slug input and does not clarify result shape or not-found behavior, leaving an important gap for correct invocation.

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

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

The only parameter is slug, and schema description coverage is 0%, so the description must explain it but does not. The description gives no indication that the required input is a server slug, leaving the schema to carry the entire parameter burden.

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: retrieves a financial MCP server listing. It also names the included data categories, but it does not explicitly differentiate this tool from the sibling search_mcp_servers, leaving the singular-vs-search distinction implicit.

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

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

The description provides no guidance on when to use this tool versus search_mcp_servers or other MCP-related siblings. It implies retrieval but does not state prerequisites, exclusions, or alternative routing conditions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, and destructiveHint=false, so the safety profile is covered. The description adds valuable context beyond annotations: it names data sources, lists the tables and their contents, and discloses that free keys only return race totals and national/regional/state donor geography, with deeper tables requiring a paid PoliSpend subscription. It does not mention rate limits or return pagination, but the paywall detail is a meaningful behavioral 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?

The description is front-loaded with the core purpose and then densely lists table contents, all of which earn their place by clarifying the required 'table' parameter. The run-on sentence structure and semicolon-heavy list are less scannable than a bulleted format, but there is little wasted text.

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

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

Given four parameters, no output schema, and a complex multi-table dataset, the description does a good job explaining what each table contains and the cycle/free-tier limits. It omits explicit return formatting (e.g., rows vs. aggregated JSON) and filter interaction details, but the table descriptions give an agent enough to call it correctly.

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

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

Schema coverage is 50%, with descriptions for cycle and state but none for table and office. The description compensates substantially by explaining each table enum value (e.g., 'races (per House/Senate race: candidate receipts, outside spending for/against)' and 'donor_geo (donations by city/state/division/region)') and by naming cycle values (2026 plus 2022 and 2018). Office is only indirectly covered via 'House/Senate race', so a small gap remains.

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

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

The description clearly identifies the resource as US election money data from FEC and state/city filings, and enumerates the tables available (races, candidates, donor_geo, etc.). It does not differentiate from siblings, but no sibling covers political spending, so the purpose is unambiguous.

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

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

The description implies usage by listing the dataset's contents and cycles (2026, 2022, 2018), but it never states when an agent should call this tool versus another, nor does it give explicit exclusions or prerequisites. The free-vs-paid tier note adds context but is not framed as usage guidance.

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

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

Annotations already declare readOnly, idempotent, closed-world and non-destructive, so safety is covered. The description adds genuine behavioral context beyond them: results are point-in-time with no future revisions, and the stress probability uses a 2-state Markov-switching model, which tells the agent how to interpret the numbers.

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?

Lead sentence front-loads the resource and the point-in-time cutoff, then the parenthetical enumerations spell out the label set. The lists are dense but each item is a distinct returned field, so they earn their place; the methodology parenthetical is only marginally necessary.

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 carries the return-value burden itself and does so by enumerating every label group plus the nowcast and stress probability. Combined with the point-in-time caveat and single optional parameter, an agent has everything needed to call and interpret it.

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

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

Single parameter with 100% schema coverage, which the schema already documents fully (format, default, look-ahead rationale). The description still reinforces the semantics by framing the whole output as 'as known on as_of' and stressing no future revisions, adding interpretive value rather than repeating 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 ('The FinzData Quantitative Model as known on as_of') and then enumerates exactly which readings are returned: regime labels, quadrant, nowcast, and stress probability. No sibling tool covers macro regime labels, so the agent can route here without ambiguity.

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 three concrete example questions it answers ('what macro regime are we in', 'are financial conditions tightening', 'condition a backtest on regime'), which is strong situational guidance. It stops short of naming alternatives — get_macro_vintage and get_fundamentals_pit exist and are not explicitly contrasted, so the boundary between this and vintage macro data is left implicit.

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

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

Annotations already cover safety (readOnly, idempotent, non-destructive, closed-world), so the description earns credit for the additive part: the 'public' qualifier tells the agent private strategies will not be returned, and it names the four payload components in the absence of an output schema. It does not say what happens when the slug does not resolve or refers to a private strategy.

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 the return payload enumerated in a compact list. 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?

Reasonable for a one-parameter read: payload composition and the public-only constraint are stated despite no output schema. However, the required slug is left entirely undefined and the not-found/private-access behavior is absent, which an agent needs in order to retry or fall back to search.

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% for the single parameter, so the description must compensate and it does not: the word 'slug' never appears and no format, source (e.g. from list_strategies) or casing rules are given. The only hint is the singular 'one ... strategy' framing.

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

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

Specific verb+resource ('Returns one public Hub strategy') with an enumeration of what the record contains (spec, backtest result, forward-tracking, fork lineage). The word 'one' distinguishes it from the bulk sibling list_strategies, though no sibling is named 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?

Usage is only implied by 'one public Hub strategy' – an agent can infer this is a single-record lookup keyed by slug. There is no explicit when-to-use or when-not (e.g. list_strategies for browsing, fork_strategy/publish_strategy for mutations), and no prerequisites 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?

Annotations already declare readOnly/idempotent/non-destructive, so the description rightly spends its words on semantics instead: survivorship-free construction, the $5 price floor and 63-day dollar-volume ranking behind index mode, the 500-row page size, and the today default. It does not state a total row count or whether offset paging terminates, which would have pushed this to 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?

Three dense sentences, front-loaded with the default behavior before the alternate index mode and paging. Every clause carries information, though the index-mode sentence is long and packs ranking method, price floor, and disclaimer together.

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 adequately conveys what is returned (symbol lists, survivorship-free, point-in-time) and how to paginate. Only the absence of row-count/termination guidance keeps it from fully covering a listing tool whose results are paginated.

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 earns above that by explaining what 'index' actually returns (most-traded names priced at least $5, ranked by 63-day dollar volume) — meaning the enum label alone does not convey. It also documents the 500-row page size tied to 'offset', adding a concrete value the schema omits. 'prefix' is left entirely to 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 ('Returns every US symbol that was trading on as_of') with the critical qualifier 'including companies that later delisted (survivorship-free)'. It also explicitly separates the two modes (full universe vs. liquidity-ranked index subset), so an agent can distinguish it from data-fetching siblings like get_bars or get_fundamentals_pit.

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?

Clearly explains the two selectable modes and when each applies, plus the paging procedure ('Pages of 500; pass offset'). It flags the caveat that index mode is a point-in-time large-cap proxy rather than official index membership. It stops short of explicit when-not-to-use guidance or naming an alternative tool, but for a universe-listing tool 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?

The annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds only the retrieval verb and 'verified' qualifier; it provides no additional behavioral context such as error behavior when the ID is missing, permission requirements, or what a verified record represents.

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. Its brevity is efficient, though it omits necessary differentiation rather than being structurally poor.

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 low-complexity read-only getter with rich annotations, the description is minimally sufficient to invoke the tool when a record_id is known. However, it leaves unresolved what a 'verified strategy record' is relative to get_strategy and does not explain what happens if the ID is invalid.

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% for the single required record_id parameter. The description mentions 'by its ID' but adds no format details, examples, or source for the ID, so it does not compensate for the missing schema documentation.

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: retrieve a verified strategy record by ID. This clearly identifies the operation, but it does not distinguish the tool from nearby siblings such as get_strategy or verified_board, nor does it explain what 'verified' means in context.

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_strategy, verified_board, or verify_chain. The phrase 'by its ID' implies a lookup precondition, but no explicit selection criteria or exclusions are given.

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

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

Annotations already declare readOnly/idempotent/non-destructive, so the safety profile is covered. The description adds genuine value beyond that: it defines what 'robust' (deflated Sharpe) and 'forward' (forward Sharpe with 63+ days of out-of-sample record) actually mean, which the agent cannot infer from the bare enum.

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 dense sentences with the resource stated first and the option semantics following; zero filler and no repetition of structured fields. The telegraphic style is compact but still parseable.

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 should say what a strategy entry contains and how pagination via 'limit' behaves; it says neither. For a discovery/list endpoint feeding downstream calls like get_strategy or fork_strategy, that is a meaningful gap, though the sort/family semantics it does provide cover the main selection logic.

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 must carry parameter meaning, and it does for two of three: it glosses every sort value and enumerates family values (momentum, expr, ma_cross, factor). However, 'limit' is never mentioned and no default sort is given, leaving one parameter and one behavior 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 and resource ('Lists public FinzData Hub strategies') and implicitly scopes to public strategies only, which separates it from get_strategy (singular) in the sibling list. It does not explicitly name an alternative, but the resource 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?

Usage is implied by the sort options ('robust', 'forward', 'new', 'forks') and the family filter, but there is no explicit when-to-use vs. alternatives guidance (e.g., when to use this instead of get_strategy or verified_board). No prerequisites or exclusions are stated.

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

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

Annotations only say readOnly=false, openWorld=true, idempotent=false, destructive=false; the description adds substantially more: results become public at a URL, tracking starts today and runs daily, only server-computed results are stored (no client tampering), it consumes one backtest credit, and free accounts are rate-limited to 3/day. It also discloses the private-visibility escape hatch, so the agent knows the default exposure is public.

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 sentences, front-loaded with the action and its public consequence, then the tracking behavior, then cost/rate/visibility constraints. Every clause carries information an agent needs; nothing is redundant with the schema or annotations.

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

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

No output schema exists, and the description implies a slug/URL result without stating the actual return shape (slug, url, run id). Everything else an agent needs for a mutating, publicly-visible, credit-consuming operation — cost, limits, exposure, idempotency implications — is 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 already 80%, but the description still adds meaning: the 'spec' parameter is the same format as run_backtest, and visibility='private' is explained as 'keeps it unlisted', clarifying the enum's real effect. as_of, title, and description semantics are left entirely to the schema, so it does not fully compensate for the remaining gap.

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

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

States a specific verb+resource ('Runs a backtest spec ... and publishes it to the FinzData Hub') plus the concrete outcome: a public, reproducible strategy page at data.finzdata.com/s/<slug>, forward-tracked daily. It also distinguishes itself from the sibling run_backtest by noting the spec format is shared but the effect (publication) is new.

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

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

Gives clear context for when this applies — you have a backtest spec and want a published, forward-tracked page — and names run_backtest as the format reference. It also adds operational guidance (costs one backtest, 3/day on free accounts) but does not explicitly contrast with register_strategy or fork_strategy, which an agent could plausibly confuse with publishing.

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 only convey non-read-only, open-world, non-idempotent, non-destructive. The description adds genuinely important behavior the agent cannot get elsewhere: evaluation uses only post-registration data, the record is immutable, ranking does not begin for 63 trading sessions, and the platform never trades the signal. That is exactly the kind of consequence disclosure this dimension rewards.

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, front-loaded with the action and then the consequences, with no filler. It is dense with four comma-separated clauses, but each clause carries distinct decision-relevant information.

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

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

For a mutation tool with no annotations covering safety detail and no output schema, the description does well on consequences and commitment semantics but says nothing about the six required inputs, notably the free-text 'signal' parameter and top_frac semantics. That is a meaningful gap in an otherwise complete framing.

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% across six required parameters, so the description carries the compensation burden and it provides essentially none: no meaning, format, or constraint for agent_name, signal, universe, rebalance, side, or top_frac. The schema does supply types, three enums, and a 0-0.5 bound, which is why this is not a 1.

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

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

The first sentence names a specific verb and resource ("Register a new strategy signal"), which cleanly separates it from siblings like fork_strategy, publish_strategy, and retire_strategy. It does not, however, explicitly say what distinguishes registration from those alternatives in the description text itself.

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

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

There is no explicit when-to-use/when-not-to-use statement and no sibling is named as an alternative. However, the constraints given (irreversible record, scoring only begins after registration, 63-session ranking delay) implicitly tell the agent this is a one-way commitment that should not be used iteratively.

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 destructiveHint=true already declared, the description does real work by scoping the destruction: forward accrual stops, but history is preserved and the record stays public, merely marked retired. That is exactly the kind of context annotations can't express. It does not address reversibility (can a retired record be re-activated?) or that idempotentHint=false means a second call will likely fail.

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 well-formed sentence, front-loaded with the action and immediately followed by the three consequences. No filler and nothing buried.

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 mutation with no output schema, the description covers the essential question an agent will have -- what does retiring actually change -- and does so precisely. The remaining gap is failure/reversal semantics for a non-idempotent destructive call, which would be nice but is not blocking.

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

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

Schema description coverage is 0% and the single record_id field has no schema-level explanation, so the description is the only source. It implies the identifier must refer to "one of your verified strategy records," which is useful, but adds no format, source, or lookup guidance 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?

"Retire one of your verified strategy records" gives a specific verb (retire) plus a specific resource type (verified strategy record), and the effects clause (stops accruing, keeps history, stays public) further fixes what "retire" means. It never names a sibling (e.g., publish_strategy/register_strategy/fork_strategy), so the differentiation from related tools is left to the agent.

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?

"one of your verified strategy records" supplies a clear precondition for use (must be yours and verified) and the effect description implies the intent (stop tracking without deleting). There are no explicit exclusions or pointers to alternatives, so the agent must infer that this is not the way to delete or unpublish a strategy.

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?

The description goes well beyond the annotations by disclosing determinism, point-in-time price handling, caching behavior, no-look-ahead guarantees, overfitting diagnostics, and the exact categories of returned results. These details materially help an agent understand the tool's behavior.

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

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

The description is front-loaded with the core action and then organized into useful details, but it is a very dense single paragraph. Most content earns its place because the nested spec is otherwise undocumented, though the density reduces 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?

For a complex backtesting tool with a nested spec object, no output schema, and partial annotation coverage, the description is complete enough to call correctly. It covers required spec semantics, key behavioral guarantees, and the broad shape of returned results.

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?

Although the schema only labels spec as 'Backtest spec.', the description richly documents the nested spec fields: universe semantics, rebalance values, signal types, expression functions, fundamentals variables, side, blind, top_n, and costs_bps. This is substantial added meaning beyond the schema.

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

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

The description clearly states a specific verb and resource: it runs a deterministic backtest from a JSON spec. It distinguishes the core action from siblings like backtest_export or compare_runs by implication, but it does not explicitly name alternatives or sibling tools.

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

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

The description gives extensive guidance on how to construct the spec, including universe choices, rebalance frequencies, signal types, and expression functions. However, it does not explicitly say when to use this tool versus siblings such as compare_runs, backtest_export, or survivorship_audit.

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, idempotentHint=true, and destructiveHint=false. The description adds meaningful context beyond those: it clarifies that the operation is free of look-ahead concerns and requires no as_of parameter, and it states what is returned (dataset ids and descriptions).

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 focused sentences with no wasted words. The purpose is front-loaded, and the return plus as_of note follow efficiently.

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

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

For a simple one-parameter search tool with rich annotations, the description is nearly complete: it covers purpose, return values, and the as_of exemption. It only lacks explicit usage guidance relative to sibling tools like describe_dataset.

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 there is only one parameter, so the schema already defines 'query' as search text. The description does not add any formatting or filtering details beyond the schema, 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?

The description states a specific verb and resource: 'Full-text search over the dataset catalog,' and adds the return shape ('matching dataset ids and descriptions'). It distinguishes itself from most siblings by the dataset catalog scope, but does not explicitly contrast with describe_dataset, which would be needed for a 5.

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

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

The description says 'Free of look-ahead concerns; no as_of needed,' which is a behavioral note rather than usage guidance. It does not say when to use this tool versus alternatives like describe_dataset, nor does it provide any when/when-not conditions.

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

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

Annotations already cover the safety profile (readOnly, idempotent, non-destructive, closed-world), so the description's job is to add context — and it does: grading cadence (nightly), grading dimensions (health, protocol conformance, prompt-injection risk), and that install URLs come back. It stops short of describing ordering, pagination, or result shape.

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

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

One front-loaded sentence carrying purpose, data provenance, quality dimensions, and a return-value hint with zero filler. There is no sentence an agent must skip.

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 zero parameter documentation, the description should carry more of the burden — yet it explains nothing about how the four filters combine, what a grade means in practice, or what the result set looks like beyond install URLs. Adequate as a blurb, insufficient as a calling contract.

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% across four parameters, and the description never mentions q, limit, category, or min_grade. Only indirectly does 'graded' hint at min_grade; the query, cap, and category facets are left entirely to the enum values and the agent's guesswork.

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 ('finds financial MCP servers') plus the differentiator that makes this catalog special (nightly FinzData grading). It is clearly a discovery tool distinct from fetch-style siblings like get_mcp_server, though it never names that sibling explicitly.

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

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

Usage is only implied: the word 'finds' plus 'results include install URLs' signals a discovery/browse step before get_mcp_server or claim_mcp_server. There is no explicit when-to-use, no exclusion, and no mention of the sibling tools that serve the follow-up steps.

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 this is a non-read-only, idempotent, non-destructive, open-world mutation. The description adds meaningful context beyond that: it distinguishes star from unstar behavior, clarifies that stars feed the Trending list, and — critically — that rankings are unaffected and remain based on deflated Sharpe and forward record. It does not cover permission requirements or what the response returns, but for a simple toggle the added behavioral context is solid.

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, front-loaded with the primary action and immediately qualifying the unstar variant. Every clause carries information — the Trending/ranking distinction is not 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 two-parameter toggle with no output schema, the description covers the key gaps: mutation semantics, the inverse operation, and the effect on Trending vs. rankings. Missing only minor details such as auth requirements or return state, which keeps it from a 5.

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

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

Schema description coverage is 0%, so the description must compensate. It fully explains the optional unstar parameter ('with unstar=true removes your star'), but says nothing about slug format or how to obtain a valid slug beyond implying it identifies a public Hub strategy. Partial compensation for one of two parameters justifies a 3.

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

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

States a specific verb (Stars) and a well-scoped resource (a public Hub strategy), and explicitly defines the inverse operation via the unstar parameter. An agent can tell exactly what this does without opening the schema.

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

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

The description implies usage: only public Hub strategies can be starred, and unstar=true toggles the removal. But it never states when an agent should star vs. use a sibling like comment_strategy or fork_strategy, nor any prerequisites such as authentication or ownership. Usage is implied rather than specified.

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 cover the safety profile (readOnlyHint=false, idempotentHint=true, destructiveHint=false), so the description earns credit for what they can't say: it discloses that two backtests are executed internally, what is returned (both stat sets plus the delta), and the cost of one backtest. It stops short of explaining side effects such as whether runs are persisted or how long it takes.

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 sentences, no filler, with the core two-run mechanism front-loaded and the universe options and cost trailing as supporting detail. Every sentence carries operational information.

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

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

For a compute-heavy tool with a nested spec parameter and no output schema, the description supplies the essentials: execution model, returned metrics, universe options, and cost. It leaves the nested spec contents mostly to run_backtest rather than spelling them out, which is a reasonable but not complete handoff.

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, but the description adds real meaning beyond the schema by naming the accepted universe values ('top500'|'top1000'|'top3000' or a symbol list) — information the schema's opaque nested 'spec' object does not provide. The as_of cutoff is left entirely to 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 — running a backtest spec twice under two universes — and defines the contrast precisely (point-in-time vs. still-trading names). An agent can distinguish this from run_backtest or compare_runs purely from the text, since the output (CAGR/Sharpe inflation) is also named.

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

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

The use case is explicit (measuring survivorship-bias inflation) and it references run_backtest for the spec format, plus notes the 'costs one backtest' budget. It does not state when to skip this tool or how it differs from compare_runs, so a small inference remains.

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 readOnly, idempotent, non-destructive, closed-world, so the safety profile is covered. The description adds real behavioral context beyond that: it discloses that unsupported clauses are reported rather than guessed, that the return set is expr/universe/notes/unsupported-clauses, and that no data is fetched — telling the agent this is a pure parse/compile step.

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: purpose plus syntax example, then return contents, then the no-fetch caveat. Front-loaded with the core action and zero filler; every clause carries information the agent needs.

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 naming the return fields (expr, universe, notes, unsupported clauses) and the fidelity guarantee. Minor gaps remain: it does not say what happens on wholly invalid scan text (error vs. empty notes) or how the returned spec is consumed downstream.

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 and the baseline would be 3. The worked example goes beyond the schema's bare "StockCharts scan text" by showing the actual authoring syntax (bracket clauses, rank by, ROC) an agent must supply, which materially reduces format guessing.

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 ("Translates a StockCharts.com scan") and names the two deliverables (FinzData signal formula, ready-to-run backtest spec). The concrete scan example makes the domain unambiguous, and "No data is fetched" draws a usable boundary against execution-oriented siblings like backtest_stockcharts_scan or run_backtest, though no sibling is named 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?

Usage is strongly implied: this is the translation step that produces a spec you would then backtest, and "never guessed" signals it is safe on partially supported input. But there is no explicit statement of when to pick this over backtest_stockcharts_scan (which presumably translates and runs) or run_backtest, and no stated prerequisites or exclusions.

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

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

Annotations already declare readOnlyHint=true, idempotentHint=true, destructiveHint=false, so safety is covered. The description adds nothing beyond them: it doesn't explain ranking criteria (what orders the leaderboard), whether results are truncated, or how the limit affects the ranking.

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 waste. It is appropriately short, though brevity here edges into under-specification since the leaderboard's ordering and size semantics go unstated.

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 should explain what a leaderboard entry contains and how it is ranked; it does neither. With an undocumented limit parameter and no return-shape detail, an agent cannot predict the response.

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

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

One parameter (limit) with 0% schema description coverage — no text explains that it caps the number of leaderboard entries or that the default is 50 and max 200. The description never mentions the parameter, so it fails to compensate for the coverage gap.

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

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

States a specific verb+resource: 'Get the leaderboard of verified strategies.' An agent knows the resource and that only verified strategies appear. It does not distinguish this from siblings like get_verified_record or list_strategies, which is the only gap.

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

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

No guidance on when to use this versus list_strategies, get_verified_record, or get_strategy. Nothing tells the agent what 'verified' means as a selection criterion or when the board is preferable to listing strategies.

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, idempotentHint, destructiveHint=false, and openWorldHint=false, so the safety profile is fully covered. The description adds genuine value by stating the check is permissionless ('anyone can') and that it detects editing and back-dating specifically. It stops short of saying whether the result is a pass/fail verdict or a full chain listing, which matters with 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?

One sentence with no padding, but it front-loads the least useful clause ('Anyone can check') and spends its only content on what is verified rather than what the tool returns. Brevity here reads as under-specification rather than economy.

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 full burden of explaining the result — is it a boolean integrity verdict, a chain of records, or a failure report? It also never scopes which records or chain are being verified. For a zero-arg tool that an agent must call blind, this leaves real gaps.

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

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

The tool takes zero parameters, so the baseline is 4. There is nothing for the description to disambiguate at the argument level.

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 an action (check) and a property being verified (no record was edited or back-dated), which conveys tamper-evidence verification. But it never says what 'the chain' is, what records are covered, or how this differs from siblings like get_verified_record, verified_board, or survivorship_audit. An agent can guess the intent but cannot confidently separate it from adjacent verification tools.

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

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

There is no when-to-use trigger, no prerequisite, and no named alternative. 'Anyone can check' hints at permissionless access but gives no condition that selects this tool over get_verified_record or verified_board. The agent is left to infer invocation context entirely.

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