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

Discloses caching (~1hr), manual content revision, and hand-verified entries; no annotations, so description effectively communicates read-only nature and update 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 with essential details, no redundant information; front-loaded with core purpose and key attributes.

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?

Sufficient for a no-parameter tool; covers content, freshness, and caching; only minor gap is lack of mention of output format or size limit.

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

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

No parameters; description adds meaning about the returned data (chain, status, eligibility) beyond the empty 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 the tool returns curated active and upcoming crypto airdrops, distinguishing it from sibling tools focused on market stats.

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?

Context is clear for fetching airdrops, but no explicit when-not-to-use or alternatives; sibling differentiation is implied by distinct tool purposes.

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

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

With no annotations provided, the description carries the full burden of behavioral disclosure. It covers the non-mutating, public, read-only nature ('public', 'archive', 'historical') and informs about pagination and the 1-year cap. It also adds useful behavioral context for the analystId choices. It does not disclose rate limits or ordering, but for an archive read tool the information is sufficient.

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

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

The description is long but every segment earns its place: the core purpose is front-loaded, the variant rationale is concise, and the analyst ID list adds decision-relevant context not present in the schema. The structure is a bit run-on with heavy dashes, but it is well organized and not redundant.

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

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

For a 5-parameter tool with 100% schema coverage and no output schema, the description covers the return type, time horizon, pagination, filters, and the distinguishing query-param behavior. The main gap is that it never explains how this differs from the similarly purposed siblings analysts_signals and analysts_signals_all, which would help an agent choose more confidently.

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

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

Schema coverage is 100%, so the baseline is 3. The description goes beyond the schema by providing human-readable context for each analyst ID (e.g., 'ChainHawk, BTC & macro on-chain') and by framing period=365d as 'up to 1 year of history.' This adds meaning beyond the raw enum values, justifying a 4.

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: 'Returns a paginated archive of signals attributed to a single analyst, covering up to 1 year (365 days).' It also distinguishes itself from the path-param version by explicitly noting it is the MCP-tool-compatible variant. However, it does not differentiate from similarly named siblings like analysts_signals or feed_archive, so it falls just short of a 5.

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

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

The description provides clear context on when to use this tool: it is the MCP-compatible version that uses query params instead of path params, so AI agents can call it directly without resolving a URL template. This is actionable guidance for selection. It does not name alternatives or exclusions explicitly, so it earns a 4 rather than 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?

With no annotations, the description carries the full transparency burden and succeeds: it discloses generation model, generation time, input data sources, caching, rate limit, empty-array behavior, and the exact output fields including nullability. This goes well beyond a basic 'returns summary' statement.

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 opening repeats the same idea twice ('Get today's AI-generated commentary' and 'Returns today's AI-generated daily commentary'), adding minor redundancy. Overall, however, the description is front-loaded and every subsequent sentence contributes concrete, useful 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 zero-parameter endpoint with no output schema and no annotations, this description is exceptionally complete: it covers generation cadence, input data, output field names and types, value ranges, auth requirements, caching, failure-before-9 behavior, and rate limits. An agent has everything needed to call and interpret the result 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?

The input schema has zero properties, so parameter semantics are not applicable; the baseline of 4 is appropriate. The description instead documents the response fields and their meanings, which is the relevant semantic information for this endpoint.

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

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

The description clearly states the verb, resource, and scope: 'Get today's AI-generated commentary for all 10 analysts.' It also specifies short 2-sentence summaries and distinguishes the result from the fuller authenticated Pro endpoint, making its purpose unambiguous relative to sibling summary/history 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?

It explicitly identifies this as a public endpoint with no authentication required, notes that only shortSummary is returned, and points to the authenticated Pro endpoint for full commentary. It also gives operational boundaries such as empty results before 9:00 UTC and a 30-minute cache, which helps an agent decide when to call.

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

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

With no annotations, the description carries the full transparency burden. It discloses the exact time-window enforcement (DATE_TRUNC('month')), the guaranteed presence of all 10 analysts, empty-array behavior, null conditions for winRate and avgReturn, and the data source (signal_history table). This is comprehensive behavioral disclosure beyond the name alone.

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 dense but every sentence earns its place. It front-loads the core summary, then precisely explains edge cases (null values, empty arrays, month bucketing). Despite its length, there is no redundancy or filler.

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

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

For a zero-parameter tool with no output schema, the description fully explains the return semantics: metrics, null conditions, analyst coverage, and time-window guarantees. An agent has everything needed to interpret results and route queries correctly, even amid many sibling analyst tools.

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

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

The tool has zero parameters, so there is nothing for the description to add. Baseline for 0 params is 4; the description correctly adds no parameter information because none exists.

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

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

The description clearly states the tool returns a monthly performance summary for all analysts over the last 6 months. It names the exact metrics (win_rate, avg_return, total_signals) and distinguishes itself from sibling analyst tools by specifying the fixed window, canonical analyst list, and empty-array behavior.

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 explicitly gives example use cases: answering 'How did WhaleWatch perform in May?' or 'Who was the best analyst last month?'. It does not name alternatives or state when not to use this tool, so it does not fully earn a 5, but the use 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?

With no annotations provided, the description carries the transparency burden, and it delivers meaningful context: stats are '100% real', computed from the live signalHistory table, winRate is a fraction, and avgReturn is a percentage. It also explains the non-human attribution model. It could explicitly state it is a read-only listing, but the 'Returns...' framing and data-source disclosure cover the most important 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 statement and the persona enumeration is useful rather than filler. However, it is lengthy and ends abruptly with a stray 'B' (likely truncation), which breaks the structure and leaves an incomplete trailing thought.

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 zero-required-parameter listing tool with no output schema, the description explains what is returned, lists all expected personas, and defines the two key stat formats. The optional filter is fully covered by the schema, so nothing essential is missing for calling the tool 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?

The schema already documents the optional analyst enum filter with 100% coverage, so the baseline is 3. The description adds persona display names that roughly map to enum slugs, but does not discuss the filtering behavior or parameter format, so it neither helps nor hurts 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 names a concrete resource and action: it 'Returns all 10 pseudonymous ... analyst personas' and enumerates every persona with its domain, so an agent knows exactly what this tool provides. The 'all 10' phrasing also sets it apart from sibling analyst tools like analysts_top or analysts_signals even without naming them.

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

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

The description implies the tool is for getting the full analyst roster with live performance stats, and clarifies the analysts are algorithmic identities rather than humans. However, it never explicitly says when to use this over sibling tools such as analysts_signals, analysts_top, or analyst_archive, leaving selection to inference.

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

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

With no annotations provided, the description carries the full burden and does so well. It discloses that no authentication is required, that depth is free-tier limited to 7 days and 200 signals per analyst, and it gives response shapes and signal field semantics.

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

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

The description is long but dense, with the core behavior and id syntax front-loaded before response details. Minor extras like 'MCP-compatible' and the repeated analyst id list keep it from being maximally concise.

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

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

For a one-parameter, no-output-schema public read tool, the description covers authentication, data limits, response structure, and signal fields. The truncated 'create' field list and lack of error-handling or invalid-id guidance are the only notable gaps.

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

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

The schema already documents the id parameter at 100% coverage, so the baseline is satisfied. The description adds meaningful value by explaining comma-separated multi-analyst usage, concrete id examples, analyst identities, and the response difference between single and multi-id calls.

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: it 'Returns the last 7 days of signals' for one or more analysts. It also differentiates from the sibling all-analysts endpoint, making its scope 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?

It explicitly explains when to use a single id versus a comma-separated list, and tells the agent to use the 'all' endpoint to fetch all 10 analysts at once. It does not contrast with every analyst-related sibling, but the core single/multi decision is clearly covered.

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

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

With no annotations, the description carries full behavioral disclosure: public/free-tier, no auth, no parameters, last 7 days, 200-signal cap per analyst, grouping by analystId, and null semantics for outcome/returnPct. It even documents the response envelope, so an agent can predict the 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?

The description is organized and front-loaded, moving from purpose to limits to response shape to alternative routes. It contains minor redundancy ('last 7 days' and 'free-tier' appear twice), but every sentence earns its place.

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

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

Given zero annotations and no output schema, the description covers everything needed to select and invoke the tool: scope, limits, auth, response fields, and the subset alternative. The only omitted details are rate limits, which are nonessential for this simple no-parameter endpoint.

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

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

There are zero parameters and the schema is empty, so the baseline is 4. The description explicitly confirms 'No query parameters needed,' which is sufficient; no per-parameter detail is possible or required.

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

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

The description opens with a specific verb and resource: 'Returns the last 7 days of signals for all 10 analysts grouped by analystId in a single response.' It also names the alternative subset endpoint, which distinguishes this aggregate tool from analysts_signals and similar sibling endpoints.

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

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

It explicitly identifies when to use the tool ('ideal for AI agents that need a cross-analyst comparison without 10 round-trips') and when not to ('To fetch a subset of analysts, use GET /api/public/analysts/signals?id=...'). It also states the operational conditions: free tier, no authentication, no query parameters.

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

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

With no annotations provided, the description carries the full disclosure burden and meets it thoroughly. It discloses the 5-resolved-signal minimum, the free 7-day window, the ~10 minute cache, the null-result edge case, and the exact units for winRate and avgReturn. It also maps analyst IDs to names and chains, leaving little hidden 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 dense and front-loads the core result, then adds constraints, use case, null behavior, mappings, units, and cache. It is slightly redundant, as the opening phrase mentioning 'min 5 resolved trades required' repeats the later 'at least 5 resolved signals,' but every other sentence contributes unique useful detail.

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

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

For a no-parameter tool with no output schema, this description is exceptionally complete: it specifies the exact selection rule, the edge-case return value, field semantics, analyst ID mapping, and caching behavior. An agent can invoke the tool and interpret the result correctly without consulting any external documentation.

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

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

The tool has zero parameters, so there is nothing for the description to explain about inputs; baseline 4 applies. It still adds useful output semantics such as analyst ID mapping and field units, but those are output-oriented rather than parameter-oriented.

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

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

The description opens with a specific verb and resource: 'Get the highest win-rate analyst right now' and defines the exact selection criterion (at least 5 resolved signals) and payload (win rate, avg return, last 3 signals). This clearly separates it from siblings like analysts and analysts_signals by emphasizing the single top result rather than a list.

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

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

Explicitly states the intended use: 'surface the best-performing signal source without iterating over all 10 analysts.' It identifies the alternative (iterating over all analysts) and the value of this shortcut, though it does not provide hard exclusion conditions for when a caller should prefer the full list.

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

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

With no annotations, the description carries the full disclosure burden, and it does so thoroughly: pagination, Pro-only full commentary, no auth required, 60 req/min rate limit, and a list of returned fields. This gives an agent accurate expectations about behavior and restrictions.

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 information-dense and front-loaded with the core action, followed by query modes, limits, restrictions, and field details. The opening phrase is slightly redundant with "Returns a paginated history...", but the overall structure remains efficient.

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

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

Despite having no output schema and no annotations, the description covers query usage, limits, authentication, rate limiting, the Pro restriction, and all returned fields. An agent has enough context to invoke the tool correctly and interpret its 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?

The input schema is empty, but the description documents the meaningful query parameters: date with YYYY-MM-DD format, analystId with a concrete example, days, and the 90-day maximum. Since the schema provides zero parameter information, this fully compensates and adds clear semantics.

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

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

States a specific verb and resource: "Get historical daily AI analyst summaries" with two explicit query modes. It also names the sibling alternative analyst_daily_summary for today's data, making the distinction clear.

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

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

Provides explicit when-to-use guidance: query by date or by analyst+days, with a 90-day cap and a direct pointer to analyst_daily_summary for today's data. This gives an agent concrete conditions for selecting this tool over a sibling.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden and does so substantively: it reveals the 90-day window, the ≥3 resolved-signal filter, the total vs. resolved distinction, and the statistical rationale for the threshold. It is truncated mid-sentence and does not cover behavior when analystId is omitted or whether results are sorted other than implied by 'top by win rate,' so it is not fully exhaustive.

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 front-loads the core purpose and includes useful analyst mappings, but it is wordy and repetitive: 'last 90 days' appears twice, 'single analyst' is restated, and the 'MCP-compatible' tag adds little. The description also appears truncated, which weakens the overall structure.

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

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

The tool has only one parameter and no output schema, so the description bears the burden of explaining return values. It begins to do so with 'token (symbol string), total (all signals in window including pending), resolved (signals with a win/loss ou', but the sentence is cut off and no win-rate field name or complete field list is given. The analyst guidance is strong, but the output documentation is incomplete.

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

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

The schema already documents analystId at 100%, so the baseline is 3; the description adds genuine value by providing human-readable names and focus areas for each enum value, such as 'chain_hawk (ChainHawk, BTC & macro on-chain).' This helps the agent choose among otherwise opaque slugs, though the schema lists the parameter as not required while the description strongly implies it should be supplied, creating mild ambiguity.

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

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

The description clearly states the action and resource: 'Returns the top 5 tokens (by win rate) attributed to a single analyst over the last 90 days.' It includes a concrete inclusion rule (≥3 resolved signals), which makes the tool's purpose easy to grasp. However, it does not explicitly distinguish this from sibling tools like analysts_top or analysts_signals, leaving some differentiation to the reader.

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 concrete invocation guidance by instructing 'Use ?analystId=' and enumerating all valid analyst slugs with their specialties, which helps the agent select the right analyst. It does not explicitly state when to prefer this tool over related siblings or when not to use it, so it stops short of full exclusion guidance.

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

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

No annotations exist, so the description carries the full burden. It discloses the cron-based data source, 180-day automatic purge, lack of auth, 60 req/min rate limit, and 5-min cache, plus the exact response shape. This is substantial behavioral context.

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

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

Front-loaded with the core purpose, then compactly gives response format and operational constraints. Every sentence adds information; no filler except perhaps the ambiguous 'MCP-compatible' label.

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 endpoint with no output schema, the description covers purpose, response structure, days control, retention, auth, rate limiting, and caching. No critical information an agent needs to call it correctly is missing.

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

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

The schema already describes days with default, min, max, and description, so coverage is 100%. The description only repeats this (e.g., '?days=7 (default 7, max 180)') without adding new field-level meaning, earning baseline 3.

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

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

Clearly states a specific resource ('daily history of the top 5 cross-exchange arbitrage opportunities') and a concrete return verb ('Returns'). The 'top 5 per day' qualifier distinguishes this daily history from sibling history endpoints such as arbitrage_monthly.

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

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

Provides explicit use cases with example AI questions ('which tokens appear most frequently in arbitrage?') and gives the default/max days. It does not explicitly name alternatives or say when not to use it, so it stops short of a full 5.

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

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

With no annotations, the description fully discloses behavioral traits: data never deleted, grows indefinitely, excludes months <5 records, rate limit (60 req/min), cache (1-hr), data source, and authentication requirements.

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 key purpose and details, but it is somewhat verbose with a wall of text. Each sentence earns its place, but could be more concise.

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 zero parameters and no output schema, the description thoroughly explains return fields, filtering condition, data source, rate limits, and caching, making it complete enough for an agent to use.

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 has zero parameters. The empty schema means no parameter info is needed; baseline 4 is appropriate as the description cannot add meaning beyond 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 the tool returns 'permanent monthly archive of cross-exchange arbitrage opportunities' with specific verb 'Returns' and resource. It distinguishes from siblings by focusing on historical aggregated data, unlike real-time tools like 'live_stats' or 'recent_whales'.

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 explicit use case ('answer historical questions') and an example question, but does not explicitly state when not to use it or which sibling to use as an alternative.

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

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

With no annotations, the description carries the behavioral disclosure burden, and it does a good job: it reveals the data source (LI.FI API, 9+ protocols), DB-backed storage, 5-minute cache, 365-day retention, permanent monthly archive, and the exact one-row-per-day shape. It stops short of documenting failure modes or rate limits, but for a simple read-only history endpoint it discloses the relevant operational 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 content is front-loaded and logically ordered, but the first portion repeats itself: the summary of fields is given twice, once in the opening dash phrase and again in the 'One row per day' sentence. A single consolidated sentence plus the caching/retention note would be more compact without losing information.

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

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

For a tool with one parameter and no output schema, the description is complete: it explains what data is returned, what each row contains, how fresh the data is, where it comes from, and how long it is retained. An agent has enough context to invoke the tool correctly and interpret the result. No critical operational detail is missing.

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

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

The only parameter, days, is already fully described by the schema (1–90, default 30), and schema coverage is 100%, so the baseline is 3. The description adds only the redundant 'up to 90 days' phrase and does not contribute new meaning beyond what the schema already states.

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

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

The description opens with a specific verb-resource combination: 'Get daily cross-chain bridge flow history', and immediately specifies the return fields, granularity ('One row per day'), and max window ('up to 90 days'). The 'history' framing and daily aggregation distinguish it from the sibling 'bridge_flows' tool, even though the sibling is not 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?

The description says it is 'useful for tracking cross-chain capital flow trends', which implies a use case, and provides context like 5-minute caching and 365-day retention. However, it does not explicitly say when to reach for this tool over bridge_flows or the many historical siblings, nor does it state exclusions or edge cases.

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

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

With no annotations, the description carries the burden and does disclose meaningful behavioral traits: the free preview is capped at top 3 flows plus 2 bridge summaries, full history is gated behind a subscription, and data is cached ~10 minutes. It could add return-format details, but it already provides useful non-obvious 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 repeats itself: 'Get recent large cross-chain bridge transfers' appears twice in different wording, and the free-preview limitation is mentioned both in the parenthetical and in the explicit 'Free preview' sentence. The useful facts could fit in one tight sentence, but the redundancy makes it harder to scan.

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

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

For a zero-parameter tool with no output schema, it covers the important context: source, free limits, subscription requirement, caching, and a capital-rotation signal. But it does not describe the returned fields/shape and does not explicitly differentiate from the sibling bridge_flow_history, leaving the definition only moderately complete.

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

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

The tool has zero parameters and an empty input schema at 100% coverage, so there is nothing for the description to explain. The baseline of 4 for no-parameter tools applies.

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

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

The description names a specific resource ('recent large cross-chain bridge transfers'), names the source protocols (Stargate Finance, Socket/Bungee via LI.FI), and adds per-bridge volume summaries. It does not explicitly name or contrast with the sibling bridge_flow_history, so it stops short of full sibling differentiation.

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

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

It implies use for current, recent bridge activity and clearly conveys the free vs. paid boundary ('top 3 flows + 2 bridge summaries... full flow history requires a Weekly Alpha subscription'). However, it never tells the agent when to choose this over bridge_flow_history or any other alternative, so usage guidance is only implicit.

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

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

With no annotations, the description carries the burden, and it discloses caching behavior ('Cached ~5min', 'no per-request AI cost'), subscription gating, and source aggregation across Etherscan, Blockchair, and Solana RPC. It doesn't specify output structure or rate limits, so 4 rather than 5.

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

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

The opening line repeats itself: it first lists events/history/sources, then restates the same content with parenthetical detail, and the final two cache notes could be merged. Front-loaded but redundantly structured.

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

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

For a zero-parameter cache-backed data tool, it covers purpose, sources, data freshness/caching, preview limits, and subscription requirement. Absence of an output schema is mitigated by the description naming the returned event/history concepts, though exact fields are still unspecified.

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

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

The input schema has zero properties, so there are no parameters needing explanation; the 100% schema coverage baseline combined with 0 params supports a 4.

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 action and resource: 'Get token burn events and 14-day burn history' for ETH, SOL, and BNB, naming data sources. This makes it clearly distinct from the other data/history siblings, even though no sibling is explicitly contrasted.

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

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

Provides practical context for invoking it: free preview is limited to top 3 events, full list requires Weekly Alpha subscription, and responses are cached. It doesn't contrast with sibling tools or state exclusions, 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?

With no annotations, the description carries full burden for transparency. It discloses caching behavior ('Cached ~5min') and lists output components (score, label, factors, history). It does not mention rate limits or authentication, but given the tool's simplicity, this is adequate.

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 two sentences: the first front-loads the purpose and key components, the second adds detail. Every word earns its place; no redundancy or fluff.

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

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

Given no parameters and no output schema, the description fully covers the tool's functionality: what it returns (score, label, factors, history), caching behavior, and a pointer to an alternative tool for different use cases.

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

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

The input schema has 0 parameters and 100% coverage. Baseline is 4. The description adds value by detailing what the output includes, which helps the agent understand the return format 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 states 'Get the Crypto Fear & Greed index' with specific components: composite 0-100 score, label, 7-factor breakdown, recent history. It distinguishes from the sibling tool 'fear_greed_monthly' by mentioning long-term trends.

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 explicitly provides an alternative: 'use fear_greed_monthly for long-term trends', guiding the agent on when to use which tool. However, it does not provide explicit when-not-to-use conditions or other context.

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

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

With no annotations, the description must carry behavioral weight, and it does disclose useful traits: one row per day, source from a 7-factor composite index, DB-backed, and 5-minute cache. However, it never describes the return shape (e.g., ordering, date format) or staleness implications beyond the cache, and the 'max 180' phrase conflicts with the schema's maximum of 90.

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 output, then adds useful context (alternative tool, use case, cache). It is slightly redundant because the first clause and the second clause both describe daily historical Fear & Greed scoring, but no sentence is wasted.

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

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

For a tool with one optional parameter and no output schema, the description gives sufficient invocation context: range, labels, granularity, data source, and cache behavior. It lacks a concrete example or output ordering, but these are minor omissions rather than blockers.

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 for the single days parameter is 100%, so the description adds little beyond the schema: it restates default 30 and max 180. The description also propagates the max-180 claim even though the schema's maximum constraint is 90, creating avoidable ambiguity for an agent choosing a value.

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

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

The description opens with a specific verb and resource: 'Get daily Fear & Greed score history,' and immediately defines the output (0-100 score plus Extreme Fear/Greed label per day). It also names a sibling (fear_greed_monthly) for longer trends, so an agent can distinguish this tool from related history 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?

It explicitly recommends fear_greed_monthly for 2-year trends and states this tool is useful for trend analysis/AI agent context, giving clear use context. It does not enumerate exclusions against other siblings such as fear_greed or sentiment_history, so it falls just short of full alternative routing.

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

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

With no annotations provided, the description carries the full burden of disclosure — and it delivers richly: never deleted/grows indefinitely, months with fewer than 20 daily records excluded, no authentication required, 60 req/min rate limit, 5-min cache, and the aggregation-from-purged-snapshots behavior. This goes well beyond a minimal description.

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

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

Well front-loaded: the purpose label opens the description, followed by the precise definition, then retention, field list, filtering rule, and operational constraints. Every sentence carries distinct information — the field list with value ranges, the exclusion threshold, rate limit, and cache all earn their 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 zero-parameter tool with no annotations and no output schema, the description fully substitutes for the missing structured data: it enumerates every returned field, the dominantClassification enum, the 20-record exclusion rule, and operational limits. Nothing an agent needs to call and interpret this tool correctly is missing.

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

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

The tool takes zero parameters, so the schema leaves nothing undocumented and the description has no input semantics to clarify; baseline 4 applies. The field enumeration (avgScore, minScore, maxScore, dominantClassification, fearDays, etc.) actually adds value by previewing what the tool returns despite not being input-related.

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 the permanent monthly archive of the Fear & Greed index — one row per calendar month.' The 'permanent monthly archive' and monthly-granularity phrasing clearly distinguish it from siblings like fear_greed (current state) and fear_greed_history (historical series), so an agent can tell them apart from the description 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?

Provides clear use-case context: 'providing AI agents with macro sentiment context across months and years' and explains the aggregation rationale ('aggregated from daily snapshots before they are purged'), which signals this is the long-term archive tool rather than a live/daily one. However, it never names alternatives explicitly or states when-not-to-use, leaving sibling routing partially to inference.

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

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

With no annotations provided, the description carries the full behavioral burden and does so admirably: it discloses that the endpoint is public and credential-free, paginated with a fixed pageSize, limited to a 30-day window, excludes whale-movement items, and returns a specific response envelope. This goes well beyond what annotations would typically provide.

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

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

The description is information-dense but verbose and somewhat redundant: 'paginated 30-day history' and 'covering the last 30 days' restate the same idea, and 'public, MCP-compatible' plus 'without any credentials' are repeated. It is structured with em-dash separators but would benefit from trimming duplicate phrases.

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

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

Despite having no output schema, the description explains the full response shape and item fields, all four optional parameters, pagination behavior, and excluded data — everything an agent needs to call the tool correctly. The only flaw is that the description is cut off mid-sentence at the end, but the provided content is otherwise complete.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds extra semantics beyond the schema: it clarifies the default type is 'all non-whale-move items', notes pageSize is fixed at 20, explains the q filter's case-insensitive matching on title and summary, and gives an example. These details genuinely help an agent construct valid calls.

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 paginated archive') and resource ('crypto news articles, analysis, and AI-generated summaries from the CryptoWhaleInsights feed'), and explicitly differentiates from siblings by calling out that whale movement events are excluded and pointing to the whale-movements endpoint. An agent can immediately tell this is the news/analysis feed tool, not a whale-tracking or market-data tool.

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

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

It explicitly says AI agents can use this to read news/analysis without credentials, and gives a clear when-not case: whale movement data is excluded, use /api/public/whale-movements instead. It also documents fixed pageSize, defaults, and filter behavior, leaving little ambiguity about when to invoke this tool over alternatives.

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

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

With no annotations provided, the description carries the full burden, and it delivers: it discloses data permanence, aggregation source ('before purge'), exclusion of months with <20 records, no-auth requirement, 60 req/min rate limit, 5-min cache, and the dominantSentiment classification rule. This is unusually transparent behavior 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 information-dense and front-loaded with the core purpose. The opening phrase 'Funding rate permanent monthly archive' repeats the tool name and 'permanent monthly archive' appears again in the next clause, adding slight redundancy. Still, every other sentence earns its place by covering fields, exclusions, auth, rate limits, and caching.

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

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

Despite having no output schema, the description enumerates the exact row fields (month, symbol, avgRate, minRate, maxRate, dominantSentiment, daysInMonth), explains data availability and filtering, and covers operational constraints. For a read-only archive tool with one optional parameter, nothing essential is missing.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds the query string syntax ('?symbol=BTC') and the filtering intent, but the schema already explains 'Omit to return all top-10 tokens.' Minimal additional semantic value, so a 3 is appropriate.

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

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

The description states a specific verb ('Returns') and resource ('permanent monthly archive of perpetual funding rates per token'), with granular detail ('one row per token per calendar month'). It clearly differentiates itself from siblings like funding_rates and funding_rates_history by emphasizing 'permanent monthly archive' and 'Never deleted.'

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 clear context: monthly aggregation, top-10 token coverage, permanent retention, and an optional symbol filter. This tells the agent what kind of historical analysis this tool serves. However, it does not explicitly name alternatives or state when not to use this tool compared to funding_rates_history, so it does not reach 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?

With no annotations, the description carries the behavioral burden and does disclose meaningful details: data is aggregated from up to three exchanges, uses a 3-minute cache, exposes cache age via `meta.cacheAgeSeconds`, and reports contributing-exchange count via `meta.exchangeCount`. It could mention rate limits or error behavior, but for a read-only snapshot tool the key operational traits are covered.

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

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

The opening phrase and the following explanation repeat the same information: 'Gate.io, MEXC, Kraken' and 'derived sentiment label' appear twice. The cache details are valuable and well-placed, but the redundancy makes the description less tight than it should be.

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

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

For a parameterless, no-output-schema data tool, the description gives enough context to invoke correctly: the source exchanges, the live/aggregated nature, the cache semantics, and the key metadata fields. It doesn't fully enumerate response fields, but the low complexity and zero parameters reduce the need.

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

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

The input schema has zero parameters, so the baseline is 4. The description doesn't need to explain parameters; it instead clarifies the data scope (tokens, exchanges, sentiment), which is the relevant selection logic for this parameterless tool.

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

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

The description explicitly says 'Get live perpetual futures funding rates' and identifies the resource (top tokens across Gate.io, MEXC, Kraken) and derived sentiment label. It clearly implies a live snapshot versus the history sibling, though it doesn't explicitly name or contrast any sibling tool.

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 word 'live' and the 3-min cache imply this is for current funding-rate data, and a sibling 'funding_rates_history' exists as an alternative. However, the description provides no explicit when-to-use or when-not-to-use guidance, leaving the distinction to inference.

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

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

With no annotations, the description carries the full burden, and it delivers substantial behavioral context: data sources (Gate.io, MEXC, Kraken), snapshot methodology, sentiment thresholds, cold-start omission, and a 5-minute cache. It still does not describe the exact response structure or error behaviors, but it discloses far more than the minimum.

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 dense but well organized: it front-loads the core purpose, then covers sources, token scope, return contents, sentiment logic, usage example, and caching. Each section adds useful context, though the usage line partly repeats schema defaults.

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

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

For a two-parameter tool with no annotations and no output schema, the description covers inputs, defaults, supported tokens, output components, data availability behavior, and cache freshness. The days-bound mismatch with the schema is a notable completeness gap, but overall the agent has enough context to call the tool correctly in most cases.

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

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

Schema coverage is 100%, so the baseline is 3, but the description adds contradictory constraints: it says 'max 180' and 'days is 1–180' while the schema's days parameter has 'maximum': 90. This ambiguity can cause an agent to issue invalid requests. The symbol list adds modest value, but the conflicting range is a serious defect.

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

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

The description opens with a specific verb and resource: 'Returns the daily historical perpetual futures funding rate for a single token over the last N days.' It also defines the exact token universe and per-day contents, which distinguishes it from a simple current-rate tool like the sibling funding_rates.

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 a clear invocation example ('Use ?symbol=BTC&days=30') and practical defaults, but it never explicitly explains when this tool is preferable to alternatives or when funding_rates/live_stats should be used instead. Usage context is implied by the word 'history' rather than stated.

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

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

With no annotations, the description carries the behavioral disclosure burden. It discloses the 30s cache behavior and points to `meta.cacheAgeSeconds` for exact age, plus `meta.chainCount` for response composition. This goes beyond a bare 'get' statement, though it does not cover rate limits or exact return shape.

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

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

The description is front-loaded with the main purpose, but it repeats the chain list and fee-estimate concept twice within the first sentence, adding redundant filler. The metadata sentence is valuable, but the restatement could be removed without losing information.

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

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

For a zero-parameter tool with no output schema, the description provides enough to call it successfully: the chains covered, the USD-per-speed-tier output, and cache metadata. It does not describe the full response structure, but the tool's simplicity makes the current description largely sufficient.

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

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

The input schema has zero parameters, so the baseline is 4. The description adds useful context about response metadata (`meta.cacheAgeSeconds`, `meta.chainCount`) and the USD estimates, which compensates for the absence of any schema-level param explanations.

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

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

The description opens with a specific verb and resource: 'Get real-time gas prices across 7 chains' and enumerates the exact networks. It also includes USD fee estimates, distinguishing it clearly from the historical 'gas_price_history' sibling via the 'real-time' qualifier.

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 conveys clear context: this is for current, real-time gas fees and notes a 30-second cache. However, it does not explicitly say when to prefer it over the sibling 'gas_price_history' or mention any exclusion criteria, leaving the distinction implied.

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

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

No annotations are provided, so the description carries the behavioral burden. It discloses DB-backed storage, a 5-minute cache, 365-day retention with monthly archival, and exactly which metrics are returned per row. Minor gaps like response ordering or timezone are not disclosed, but the core behavior is well covered.

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

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

The description is two sentences and front-loads the action and scope. The em-dash summary and the subsequent row list partially duplicate the network/metric enumeration, but the overall structure is efficient and scannable.

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 tool with no output schema, the description covers the returned row structure, units, time range, data source, and caching behavior. It does not specify ordering or timezone, but those are minor omissions given the level of detail provided.

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 sole parameter `days` is already fully described in the schema with default, minimum, and maximum values. The description only repeats the 90-day cap without adding new format, syntax, or edge-case meaning, so it adds no value beyond the schema.

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

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

The description opens with a specific verb ('Get') and resource ('daily gas price history'), names the exact networks and metrics, and caps the range at 90 days. This makes it clearly distinguishable from live gas or other history 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?

It explicitly positions the tool as useful for tracking gas fee trends and identifying high/low gas periods. It does not name alternatives or exclusions, but the intended context is clear enough for an agent to choose it over live or current-price tools.

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

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

With no annotations present, the description carries the full burden and delivers richly: it reveals severity thresholds, how data is persisted and refreshed, that days with no data are omitted, and that responses are cached for 5 minutes. This goes well beyond a bare 'history' description.

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 main purpose and keeps mostly relevant detail. It is slightly redundant by stating the default/max twice and includes implementation minutiae like 'ON CONFLICT DO UPDATE', but every sentence does contribute behavioral or usage context.

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

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

Despite having no output schema and no annotations, the description tells the agent what the response contains, how severity is derived, how freshness/caching works, and how missing-data days are handled. This is sufficient for an agent to select and invoke the tool and interpret its 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?

The schema already documents the single days parameter, so the baseline is 3, but the description actively introduces a conflict: it says max 180 while the input schema sets maximum to 90. This contradiction can mislead an agent into requesting an invalid value, reducing the parameter guidance below the neutral 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?

The description opens with a specific verb and resource: 'Returns a daily summary of Golden Alerts for the last N days.' It clearly distinguishes this from sibling tools like golden_alerts_snapshot and golden_alerts_monthly by framing it as historical daily summaries.

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 clearly establishes when to use the tool: for daily Golden Alerts history over a configurable look-back window. It gives concrete usage guidance via ?days=N, but it does not explicitly name alternatives or exclusion conditions, 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?

With no annotations, the description carries the full burden and handles it exceptionally: it discloses that the archive is permanent, never deleted, grows indefinitely, excludes months with fewer than 20 daily records, lists the data source, notes no authentication, specifies the rate limit, and mentions the 5-minute cache. This provides a comprehensive behavioral profile.

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 somewhat long but almost every sentence adds value, covering aggregation, field details, exclusion rules, source, authentication, rate limit, and cache. There is minor redundancy in the opening phrase ('permanent monthly archive' repeated) but it remains well-organized and readable.

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?

Even without an output schema, the description enumerates all return fields (totalCount, severity counts, topTokens, daysInMonth, avgPerDay) and important operational context (source, auth, rate limit, cache, exclusion threshold). This is fully sufficient for an agent to invoke the tool with zero parameters and interpret the result.

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 has zero parameters, so the baseline is 4; there are no parameter semantics for the description to clarify. The schema already covers everything, and the description adds no unnecessary parameter detail.

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

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

The description uses a specific verb-return-with-resource, naming the permanent monthly archive of Golden Alert activity with one row per calendar month. It explicitly distinguishes this from a snapshot by emphasizing aggregation from daily snapshots before purging, making its scope and unique position clear.

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

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

The description clearly frames the intended use case as providing long-term trend data across months and years, which helps an agent decide when this tool is relevant. It does not explicitly name alternatives or state when not to use it, but the context is strong enough to avoid major misuse.

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

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

With no annotations, the description carries the full behavioral disclosure burden and does so impressively: it covers cache semantics, refresh timing, intentional omission of pro-only fields, severity thresholds, and the exact response shape. It also appears to begin an authentication note with 'No authentic...'. No annotation contradiction exists.

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

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

The description is long but information-dense; each section adds real value: cache source, refresh cadence, field redaction, severity mapping, alert types, and response schema. It is slightly redundant with repeated 'latest' phrasing, and the final sentence is truncated at 'No authentic', preventing a perfect structure score.

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 fully documents the return contract: top-level keys, per-alert fields with types, null behavior for refreshedAt, and omitted pro-only fields. Combined with zero required parameters and clear cache behavior, an agent has everything needed to call and parse this endpoint 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?

The tool has zero parameters, so the schema is trivially complete and there is no parameter ambiguity to resolve. The description appropriately focuses on behavior and output rather than input, matching the baseline of 4 for a no-parameter tool.

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

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

The description opens with a specific verb and resource: 'Returns the latest snapshot of CryptoWhaleInsights Golden Alerts.' It distinguishes the tool from siblings like golden_alerts_history and golden_alerts_monthly by emphasizing 'latest snapshot', the 5-minute refresh cadence, and the in-process cache read.

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 clear usage context: this is the cached, public snapshot endpoint refreshed by cron every 5 minutes, and it explicitly notes no new AI query is triggered per request. It does not explicitly say 'use golden_alerts_history for historical data' or list exclusions, so it stops just short of full sibling routing.

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

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

With no annotations, the description carries the behavioral disclosure burden. It usefully discloses 'DB-backed, 30-min cache' and the market-level limitation, which tells the agent about data freshness and scope. It doesn't cover auth or rate limits, but for a read-only history endpoint the disclosed behaviors are the most relevant.

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 a clear summary, but it is somewhat redundant: the first sentence lists the metrics and then the second sentence repeats nearly the same list as 'One row per day'. 'Market-level' and 'daily' also appear multiple times, making it longer 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?

For a simple one-parameter history endpoint, the description is complete: it explains the row structure, lists every returned field, specifies the date range, notes the caching behavior, and clarifies the scope limitation. There is no output schema, but the description compensates by enumerating the output fields in concrete detail.

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 lone `days` parameter is fully documented with type, default, minimum, and maximum. The description only restates the 'up to 90 days' aspect and adds no parameter-specific guidance beyond what the schema already provides.

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

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

The description opens with a specific verb-resource pair, 'Get daily Leverage Radar market-level history', and enumerates the exact metrics returned. It clearly differentiates from per-asset detail by stating 'market-level only' and naming the fields that are aggregated.

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

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

It gives clear context: this is for daily historical Leverage Radar market aggregates, up to 90 days, one row per day. It also states an explicit when-not ('Pro-only per-asset detail excluded — market-level only'), though it does not name a specific sibling alternative for per-asset data.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden and does so well. It explains how picks are automatically saved, the win/loss outcome resolution formula, that records are permanent, and that results are cached for 30 minutes—details that go well beyond a typical tool description.

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 opening is front-loaded and informative, but the second sentence ('Aggregate accuracy statistics...') is largely redundant with the first. The remaining behavioral details—saving cadence, outcome rules, permanence, caching—earn their place, so the redundancy is the main structural flaw.

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

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

Because there is no output schema, the description must convey what the tool returns; it names the core statistics: win rate, avg return, and total pick counts. It also covers key operational context like the 30-minute cache and Pro-only full pick list. It could be slightly more explicit about the exact response shape, but for a zero-parameter summary tool the essentials are present.

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

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

The tool has zero parameters and schema description coverage is 100%, so parameter-level documentation is not needed; baseline 4 applies. The description adds contextual meaning about what the returned statistics cover, though no parameter-specific semantics are required.

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

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

The description explicitly states the tool retrieves Leverage Radar pick accuracy summary—historical win rate, avg return, and total pick counts. The repeated 'Aggregate accuracy statistics...' reinforces that this is a summary resource, distinguishing it from sibling tools like leverage_radar that likely provide current or detailed pick data.

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

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

The description provides clear context: it is a historical accuracy archive for Best Trade Now picks, with a 30-minute cache and Pro-only full pick list. It does not explicitly name when to use this tool instead of alternatives like leverage_radar or leverage_history, but the use case is strongly implied by the summary-focused wording.

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

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

With no annotations supplied, the description carries the full behavioral disclosure burden. It explains the public nature, the 5-minute caching, that pro-only fields are stripped, and exactly what data is included. It does not explicitly say read-only or mention rate limits, but for a snapshot-fetch tool the disclosed behavior is strong.

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 resource, and it organizes output details clearly. There is mild redundancy between the opening summary and the later 'Returns...' sentence, but the extra detail about score definitions, market summary components, and pro-only exclusions 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?

There is no output schema, so the description must explain return values, and it does so thoroughly: score scales, asset categories, market summary contents, top lists, omitted pro-only fields, cache behavior, and parameter options. For a single-optional-parameter read-only snapshot tool, nothing essential for invoking and interpreting it is missing.

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

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

The schema already covers the single parameter completely with enum values, defaults, and descriptions, so the baseline is 3. The description restates 'Supports ?window=1h|4h|12h (default 4h)' and provides no additional semantic 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 uses a specific verb and resource: 'Get current Leverage Radar snapshot', and lists concrete contents (pressure scores, setup scores, top long/short setups, market summary). It is clear what the tool returns, but it does not explicitly contrast itself with sibling tools like leverage_history or leverage_picks_summary, so it misses full sibling differentiation.

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

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

The description establishes that this is a current, public real-time snapshot with a 5-minute cache, and it documents the supported window parameter. However, it never states when to prefer this tool over related history or summary siblings, leaving the 'when not to use' guidance implied rather than explicit.

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

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

With no annotations, the description carries the full disclosure burden and handles it well: it flags the data as 'estimates, not exact exchange data,' discloses the ~5-minute cache, states the derivation from 'market price action and open interest data,' and notes Binance Futures/Bybit geo-restrictions. No annotation contradiction.

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

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

The description is front-loaded with the core action, but it repeats itself: 'Get leveraged-position liquidation estimates' is followed by 'Estimated leveraged-position liquidations by token' and '5-min cache' appears twice. The caveats and use case are valuable, but the redundancy keeps it from being tight.

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

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

For a zero-param, no-output-schema data snapshot, the description explains the returned value (long/short USD liquidation amounts per token), the data source, cache behavior, and limitations. The main gap is the vague 'recently' lookback window, which the agent cannot parameterize.

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 has zero parameters, so the schema already exhaustively describes the inputs; the baseline for such a tool is 4. The description adds value by clarifying the output units (USD per token) that parameters would otherwise need to be distinguished against.

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?

Opening clause 'Get leveraged-position liquidation estimates — long and short liquidation amounts in USD per token' names a specific verb, data subject, and unit of output, making the tool's purpose immediately clear. It also distinguishes this liquidation-specific snapshot from related siblings like leverage_history or funding_rates, which address different data.

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

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

Provides an explicit use case: 'Useful for identifying tokens with high leverage risk and likely volatility triggers.' It does not name sibling alternatives or state when not to use it, so it earns the 'clear context, no exclusions' level rather than the stronger exclusion-aware level.

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

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

With no annotations, the description discloses caching behavior (~10s), data freshness ('no fabricated floors'), and response fields (meta.updatedAt, meta.cacheAgeSeconds). It does not mention any destructive behavior, which is consistent with a read-only tool.

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

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

Two sentences, each earning its place: the first lists the core data and caching, the second details response fields. No wasted words, front-loaded with key purpose.

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

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

Given no output schema, the description covers return structure (counters and meta) adequately. It could be slightly more detailed about the counter format, but it is complete enough for a simple snapshot 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?

No parameters exist, so the baseline is 4. The description adds meaning by specifying the return content (live counters) and response meta fields, which is sufficient for a parameterless tool.

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

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

The description clearly states 'Get live activity counters' and enumerates specific metrics (whale moves today, smart-money wallets active, golden alerts), distinguishing it from siblings like 'recent_whales' which likely provides more detailed whale data.

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

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

The description implies usage for a quick live snapshot but does not explicitly state when to use this tool versus siblings like 'status' or 'recent_whales'. No exclusions or alternatives are mentioned.

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

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

With no annotations provided, the description carries the full behavioral disclosure burden, and it does so well. It explicitly notes no authentication is required, explains date defaults and the 730-day limit, describes the fallback from daily snapshots to monthly archive tables after 365 days, exposes metadata.resolution and metadata.dataCompleteness, and mentions the 5-minute cache. This is substantial transparency, though it stops short of fully describing the response shape or error behaviors.

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, but it repeats the same list of sources twice in nearly identical phrasing ('Fear & Greed, whale summary, sentiment, stablecoin flows, funding rates, golden alerts, analyst summaries' vs 'Fear & Greed, whale daily summary, social sentiment, stablecoin flows, BTC funding rates, Golden Alerts daily count, analyst daily summaries'). It also ends abruptly with 'hi', suggesting truncation or an editing artifact. The redundancy undermines conciseness.

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

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

For a single-optional-parameter aggregator with no output schema, the description covers the essential operational context: what sources are aggregated, how the date parameter behaves, what archive fallback occurs, what metadata fields to inspect, and that no auth is needed. It is sufficient for an agent to invoke the tool correctly, though a fuller response-shape description would make it complete.

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

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

There is only one parameter, date, and the input schema already documents its format, default, maximum lookback, and the 365-day archive fallback with 100% coverage. The description largely restates this same information rather than adding meaningful new parameter-level guidance, so the baseline 3 is appropriate.

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

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

Description opens with a specific verb and resource: 'Get aggregated market context for a date in one call', then enumerates the 8 data sources included. This clearly identifies the tool as a multi-source aggregator and differentiates it from the many sibling endpoints that cover individual sources like fear_greed, funding_rates, or stablecoin_flows.

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 makes the use case clear: when an agent needs a single-call cross-section of Fear & Greed, sentiment, whale activity, flows, and analyst summaries for a date. It does not explicitly name alternatives or state when not to use it, but the 'single-call aggregated snapshot' framing strongly implies the choice over calling multiple sibling source-specific endpoints.

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

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

No annotations provided, but the description discloses caching (5-min), access restrictions (non-gated), and data blending (CoinGecko top markets plus emerging tokens), which adds useful behavioral context beyond a simple 'get data' statement.

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 somewhat repetitive (e.g., twice mentions top tokens and fields), and could be more concise. It front-loads the purpose but includes redundant phrasing.

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?

Without an output schema, the description adequately lists returned fields (price change, volume, market cap, chain) and ranking criteria. It lacks detail on format or pagination, but for a simple heatmap with no parameters, it is sufficiently complete.

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

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

The input schema has zero parameters, so the description need not add parameter meaning. Baseline is 4 for no 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 clearly states the tool retrieves a token market heatmap with specific fields (24h performance, volume, market cap, chain) and distinguishes from siblings like status or recent_whales by focusing on market-wide token data.

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

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

The description indicates this is for a broad market overview, is non-gated, and cached every 5 minutes, providing clear context. It does not explicitly mention when not to use, but the sibling list and content imply its scope.

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

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

With no annotations provided, the description carries the behavioral disclosure burden. It does a good job: it reveals DB-backing, a 5-minute cache, 365-day retention with a permanent monthly archive, and one-row-per-day granularity. It stops short of describing ordering, timezone, or missing-day behavior, so it is not a 5.

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

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

The description is front-loaded with the key action and resource, and the later field list adds useful detail such as enums and ranges. However, the first sentence redundantly restates 'Daily historical Market Pulse verdict and confidence', and the field list is repeated in shortened form before being spelled out. It is adequate but not tight.

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

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

For a single-optional-parameter tool with full schema coverage and no output schema, the description is mostly complete: it lists all returned fields and their domain types, the data source table, cache behavior, and retention. It does not describe the exact JSON envelope or ordering, which is a minor gap but unlikely to block 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?

Schema coverage is 100%, so the schema already fully documents the single `days` parameter, including min, max, and default. The description reinforces that `days` maps to daily rows and caps at 90 days, but adds little beyond the schema. The baseline 3 applies here.

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

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

The description opens with a specific verb and resource: 'Get daily Market Pulse history'. It then enumerates the exact signal columns (BUY/SELL/NEUTRAL verdict, confidence %, Fear & Greed, regime, whale buy ratio, leverage suggestion) and the 90-day cap, which clearly distinguishes it from sibling history tools focused on individual metrics like fear_greed_history or leverage_history.

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 makes the intended context explicit: daily historical Market Pulse data over up to 90 days, one row per day. It does not explicitly name alternatives or when-not-to-use it, but the 'history' framing and retention details make the scope clear. A small gap is the lack of an explicit exclusion pointing to live/snapshot siblings.

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

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

With no annotations provided, the description carries the full burden, and it does well: it discloses the data source (CoinGecko Categories), caching ('5-min cache'), retention rules ('365d retention, permanent monthly archive'), and output structure. It omits rate limits or auth details, but as a read-only history tool with no destructive behavior, these are less critical.

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 information-dense with a front-loaded summary, followed by output specs, filtering, use case, and technical details. There is minor redundancy between the first and second sentences ('top crypto market sectors ranked by market cap change %...' vs 'One row per day per sector...'), but every sentence contributes meaningful context.

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

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

Given no output schema, the description clearly explains the return format ('One row per day per sector: ...'), the data source, and the retention/cache behavior. It does not state ordering of rows or pagination, but for a 2-parameter, read-only history endpoint with 90-day max, the explanation is sufficient for an agent to call it correctly.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds value beyond the schema: it gives concrete sector examples (DeFi, Layer 2, AI, Meme Coins), clarifies the optional sector filter's effect ('single sector trend' vs 'all sectors'), and reinforces the days constraint ('up to 90 days').

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

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

The description opens with a specific verb and resource: 'Get daily narrative/sector history...', then enumerates exact output fields (market cap change %, strength score, token count, daily rank, top tokens). It clearly differentiates from the sibling 'narratives' by emphasizing 'history' and 'over up to 90 days', so an agent can distinguish it without opening the schema.

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

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

The description gives clear context and a use case: 'Useful for identifying which narratives are accelerating or fading.' It also explains the sector filter behavior ('Filter by ?sector= for a single sector trend'). However, it does not explicitly name alternatives like 'narratives' for current snapshots, so it lacks explicit when-not-to-use guidance.

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

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

With no annotations provided, the description carries the full burden and does meaningful work: it discloses the data source (CoinGecko Categories), caching behavior (~30min), and the free vs. subscription boundary. It does not specify the exact response structure, but the key behavioral caveats are surfaced.

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 core purpose is front-loaded, but the description is repetitive and slightly fragmented, restating the same narrative examples and mixing 'top tokens' with 'leading tokens'. It is not overly long, but tighter editing would improve it.

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

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

For a zero-parameter tool with no output schema, the description covers the essentials: what is returned (top 3 narratives, 3 tokens each), the source, staleness, and the subscription boundary. The lack of an exact output schema is a minor gap for such a simple snapshot tool.

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

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

The tool has zero parameters and an empty input schema, so the description cannot meaningfully add parameter-level detail. The baseline for no-parameter tools is 4, and relevant contextual details like the preview limit and subscription requirement are already covered.

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

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

The description opens with a specific verb and resource ('Get top trending market narrative sectors') and names concrete examples such as AI, RWA, DePIN, and memecoins. It clearly indicates the tool's function, but it does not explicitly differentiate it from sibling tools like narrative_history or trending.

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 context through 'Cached ~30min' and 'Free preview: top 3 narratives', suggesting this is a current-snapshot endpoint with access limitations. However, it offers no explicit when-to-use guidance or alternatives compared with related tools.

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

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

With no annotations present, the description carries the behavioral burden and does disclose useful traits: results are cached for about 60 seconds, and the response includes `meta.updatedAt` as an ISO timestamp. It does not discuss rate limits or side effects, but this is a simple read-oriented getter and the caching caveat is the most relevant behavioral detail.

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 redundant: 'canonical platform metrics' appears twice, and tracked wallets, chains, win rate, and BTC benchmark are listed in both sentences. The first sentence reads like a partial duplicate of the second, making the text wordier and harder to parse than a single consolidated list would be.

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

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

For a zero-parameter tool with no output schema, the description provides a solid inventory of response content and a freshness signal via `meta.updatedAt`. It could be more explicit about the exact structure of the 'safe aggregate performance subset,' but an agent still has enough context to select and invoke the tool 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?

The tool has zero parameters, and the rubric assigns a baseline of 4 for zero-parameter tools. The description appropriately focuses on response content rather than parameter semantics, so no further parameter information is needed.

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 begins with a specific verb and resource: 'Get canonical platform metrics' and then enumerates concrete content areas such as tracked wallets, chains, tokens, tools, languages, supported chain list, and performance metrics. This clearly distinguishes it from many sibling tools focused on narrower domains like liquidations, funding rates, or whale movements.

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 'canonical platform metrics' plus 'safe aggregate performance subset' gives clear context that this is the high-level platform overview rather than a live or event-specific feed. It does not explicitly name an alternative or state when not to use it, so it stops short of a 5, but the intended use is reasonably evident.

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

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

No annotations are provided, so the description carries the burden. It discloses 10-min cache, meta fields (cacheAgeSeconds, chainCount, signalCount), and that it returns top-3 slice. Does not mention potential latency or data staleness beyond cache, but is fairly transparent.

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

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

Front-loaded with key message, but the description is somewhat lengthy with multiple clauses. Every sentence adds value, but could be slightly more concise. Still clearly structured.

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

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

Given no output schema and no parameters, the description adequately explains output fields (meta) and the 3-transfer limit. It provides context about chains and verifiable references. Enough for an agent to understand what to expect.

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

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

No parameters, so baseline is 4. Description compensates by detailing output structure (meta fields) and behavior. It adds value beyond the empty 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 'Get the latest 3 whale transfers right now' with specific verb and resource. It distinguishes from siblings by mentioning whale_activity (counts) and whale_movements (archived paginated data), ensuring no confusion.

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

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

Explicitly tells when to use alternatives: 'use whale_activity for counts, whale_movements for paginated archive'. Also clarifies it's a live snapshot, guiding appropriate usage.

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

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

With no annotations provided, the description carries the full burden and does so thoroughly. It discloses authentication requirements, a 1-hour cache, a 60 requests/min rate limit, and the fact that reports are generated weekly, all beyond what the schema or annotations could convey.

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 core statement is front-loaded, and the supporting details (response shape, caching, rate limit) are all relevant. It is slightly redundant with 'without any authentication' and 'No authentication required' both appearing, but overall it is well-organized and each sentence earns its place.

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

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

For a zero-parameter, no-output-schema, no-annotation tool, the description is fully complete. It covers the result structure, field types, limits, authentication, caching, and the boundary with the Pro-only endpoint, leaving no practical gap for an agent deciding to call it.

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

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

The input schema has zero parameters, so the baseline is 4 and the description adds no parameter confusion. It compensates further by documenting the exact response shape and field formats, which is useful given there is no output 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 action and resource: returns a public index of the last 12 weekly Alpha reports, with fields enumerated (title, summary, publishedAt, weekOf). It clearly differentiates itself from the Pro-only full-content endpoint, so an agent can tell exactly what this tool provides.

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

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

Explicitly says AI agents can use this endpoint to inform users about recent report topics and dates without authentication, and explicitly says full report content remains Pro-only on GET /api/content/weekly-reports. This gives both a when-to-use and a when-not-to-use signal with a named alternative.

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

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

With no annotations provided, the description carries the full burden and does well: it discloses the data source, the daily snapshot frequency, that cold-start days are omitted, and that results are cached for 5 minutes. However, it contains an internal inconsistency with the schema (text says max 180 days while schema says maximum 90), which slightly undermines trust in the behavioral information.

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 its core purpose and then provides dense, useful details. It is longer than minimal because of the supported-symbol list, but nearly every sentence adds operational value such as source, caching, thresholds, and query format.

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

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

For a two-parameter tool with no output schema, the description explains what is returned, the score scale, the date range behavior, and the data source. It does not specify the exact response shape (e.g., array of date/value objects), but the absence of an output schema makes that more important; the inconsistency around the days maximum is the main completeness gap.

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

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

Schema description coverage is 100%, so the baseline is 3. The description adds value with an example query, supported token names, and score thresholds, but it directly conflicts with the schema on the days maximum (description 'max 180' vs schema 'maximum 90'), which could mislead an agent into supplying an invalid value.

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

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

States a specific verb+resource: 'Returns the daily historical social-sentiment score for a single token over the last N days.' This clearly differentiates it from sibling history/summary tools by emphasizing single-token daily sentiment snapshots, so an agent can identify the intended tool without opening schemas.

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

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

Provides clear invocation context: 'Use ?symbol=BTC&days=30', states symbol is required and days is optional 1–180, and lists supported symbols. It does not explicitly contrast this with alternatives like social_summary or sentiment_monthly, so exclusions are not covered, but the usage context is otherwise clear.

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

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

With no annotations, the description carries the full burden and does it well. It discloses that data is aggregated before purge, never deleted, excludes months with fewer than 20 daily records, requires no authentication, has a 60 req/min rate limit, and is cached for 5 minutes. This is far beyond typical transparency.

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

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

The description is dense but front-loaded with the tool's identity and immediately explains the return format, filtering, constraints, and operational traits. The slight redundancy of repeating 'archive' could be trimmed, but every other sentence earns its place.

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

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

Given no output schema and no annotations, the description fully compensates: it names every returned field, explains the aggregation, exclusion rule, filtering option, coverage, authentication, rate limit, and cache behavior. An agent has enough to invoke and interpret the tool 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?

The schema already documents the optional symbol parameter and its behavior, and the description reinforces it with a concrete example ('BTC'). Since schema coverage is 100%, the description adds marginal but not essential value beyond the schema, warranting the baseline score.

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

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

The description states a clear verb ('Returns'), a specific resource ('permanent monthly archive of social sentiment per token'), and the exact row granularity ('one row per token per calendar month'). It also distinguishes itself from sibling daily/history tools by emphasizing 'permanent' and 'Never deleted', making its purpose 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 makes the intended use clear: it is a monthly aggregate view filtered by optional symbol, with no authentication and a 60 req/min limit. It does not explicitly name sibling alternatives or state when not to use this tool, so it stops 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?

With no annotations provided, the description carries the full burden, and it delivers: the archive is permanent and never deleted, rows are aggregated, months with fewer than 5 signals are excluded, no authentication is required, the rate limit is 60 req/min, and responses are cached for 5 minutes. This is unusually thorough 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 dense and informative, front-loading the core purpose and then listing fields, exclusions, and operational details. It loses a point for the redundant opening: 'Analyst signal performance permanent monthly archive — Returns the permanent monthly archive of analyst signal performance.'

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?

Even though there is no output schema, the description fully compensates by listing the exact row fields, winRate format, avgReturn basis, analyst IDs, exclusion threshold, authentication requirements, rate limit, and cache policy. An agent has everything it needs to decide whether and how to call the tool correctly.

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

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

Schema description coverage is 100%, and the schema already explains that analystId is an optional filter and omitting it returns all analysts. The description adds a concrete example (?analystId=chain_hawk) but does not meaningfully extend the parameter semantics beyond what the schema already states.

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

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

The description clearly states the tool returns a permanent monthly archive of analyst signal performance with a precise one-row-per-analyst-per-month structure. It is specific about the resource and aggregation source, but it does not explicitly name sibling alternatives or explain how it differs from tools like analyst_monthly_performance or analyst_archive.

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 context suggesting this is the historical monthly view, aggregated after signal_history ages out, and explains the optional analystId filter and the minimum-signal exclusion. However, it does not explicitly state when to use this tool versus the many sibling history/archive tools, and no exclusions or alternative routing 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?

With no annotations, the description carries the full behavioral burden and covers it well: no auth/non-gated access, served from cache, no per-request AI cost, and ~5min caching. It also discloses that AI insight text is excluded unless a subscription is held. It does not mention response envelope or rate limits, but for a simple cached public summary the key operational traits are present.

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

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

The description is front-loaded and informative, but it contains redundancy: 'Non-gated social sentiment summary: the aggregate market-mood score/label plus the top 5 tokens' largely repeats the first clause, and 'Cached ~5min' reiterates 'served from cache.' The content is valuable, but the structure is slightly bloated and could be tightened.

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

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

For a zero-parameter tool with no output schema, the description is practically complete: it states the returned data (sentiment score/label plus top 5 tokens), what is excluded (AI insight text), access requirements (non-gated), caching behavior, and the sibling tool for time-series needs. An agent has enough context to select and call this tool 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?

The tool has zero parameters and an empty input schema, so the description has no parameter burden to carry; the baseline of 4 applies. It still clarifies what the output contains and that no authentication is needed, which is sufficient context for invocation.

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

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

Description opens with a specific verb and resource: 'Get aggregate market mood — overall sentiment score/label + top 5 tokens.' It clearly distinguishes itself from sentiment_history by stating that per-token time-series belongs there, and explicitly notes that AI insight text is excluded. The purpose is unambiguous even without reading 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 explicitly names sentiment_history as the alternative for per-token time-series, giving a clear when-to-use condition. It also notes that full per-token AI insights require a Max Alpha subscription, which tells agents when this free, cached summary is the appropriate choice. Access and cost expectations are clearly stated.

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

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

With no annotations present, the description carries the full burden. It clearly states that data is a current snapshot, that values represent 24h net change with positive/negative semantics, that the source is DefiLlama, and that results are cached ~30 minutes. These are meaningful behavioral details beyond the basic operation.

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

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

The description is front-loaded with the core purpose and then efficiently routes to alternatives. It is slightly longer than strictly necessary, but each segment adds value and the use of dashes and endpoint references keeps it structured and scannable.

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

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

For a zero-parameter snapshot tool, this description is complete: it explains what is returned, the source, the refresh cadence, the interpretation of the numbers, and explicitly points to sibling tools for historical data. There is no output schema, so the description's coverage of the response semantics is sufficient.

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

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

The input schema is empty, so there are no parameters to document; the baseline for zero-parameter tools is 4. The description adds no parameter-specific semantics, but none are needed, and it clarifies the scope of data returned.

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

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

The description names a specific verb ('Get'), a specific resource ('current stablecoin supply & 24h net flows'), and specific coins (USDT, USDC, DAI), and it explicitly contrasts itself with stablecoin_history. This leaves no ambiguity about what the tool does or how it differs from nearby 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?

The description gives explicit routing guidance: use this tool for the current snapshot, stablecoin_history for daily time-series, and stablecoin_monthly for long-term trends. It also tells the agent the exact alternative endpoints to call, so there is no inference required.

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

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

With no annotations, the description carries the full transparency burden and does substantial work: it discloses cold-start days are omitted, data is recorded once from the live DefiLlama cycle, results are cached 5 minutes, and defines the sign conventions for totalFlow24h. The only notable transparency flaw is the inconsistent max window (180 in prose vs. 90 in the schema).

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

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

The description is front-loaded and information-dense, covering purpose, alternative, parameter behavior, field semantics, and cache behavior in one paragraph. It contains minor redundancy, such as restating daily net-flow and the days window, but overall every major aspect earns its place.

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

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

Given the simple single-parameter interface and no output schema, the description does a thorough job of explaining return semantics: totalFlow24h, totalNow, and signal. It is nearly complete, but the contradictory max-days information makes the invocation contract unreliable.

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 single parameter is fully covered by the schema and the description adds usage guidance like '?days=30', the description repeatedly claims a maximum of 180 days while the input schema enforces a maximum of 90. This contradiction is directly actionable and could cause an agent to request an invalid window.

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

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

The description opens with a specific verb and resource: 'Get daily historical stablecoin supply changes'. It clearly communicates scope (net inflow/outflow per day, total supply over N days) and explicitly differentiates from the sibling stablecoin_flows by noting that tool is for the current snapshot.

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

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

It gives a concrete routing cue: 'use stablecoin_flows for the current snapshot', which helps an agent choose between the two most related sibling tools. It also explains the days window and defaults, though it does not discuss exclusions or alternatives beyond stablecoin_flows.

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

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

With no annotations provided, the description carries the full burden and fully delivers: it discloses aggregation before purge, non-deletion, no authentication, a 60 req/min rate limit, and a 5-minute cache. It also describes the exact monthly row contents, making behavior highly transparent.

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

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

The description is well-structured and front-loaded with the core purpose, followed by useful operational details. There is minor redundancy in repeating 'permanent monthly archive' early on, but every sentence contributes meaningful information overall.

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

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

For a zero-parameter read-only archive tool with no output schema, the description is complete: it specifies the row granularity, aggregation logic, included metrics, data permanence, authentication needs, rate limit, and cache behavior. An agent has enough information to select and invoke the tool 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?

The tool has zero parameters and an empty input schema, so there are no parameter semantics to document. The description instead clarifies what each returned month contains, which is helpful given the absence of an output 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 a clear resource: permanent monthly archive of stablecoin flow data, one row per calendar month. The description distinguishes this from daily or live stablecoin tools by emphasizing monthly aggregation, permanence, and long-term macro liquidity 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?

Clear context is provided: this tool is for long-term macro liquidity context via permanent monthly archives, as opposed to presumably daily or transient stablecoin flow data. It does not explicitly name alternatives or state when not to use it, but the intended use case is evident.

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

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

With no annotations provided, the description fully covers behavior: it returns overall verdict, per-source health, recent errors, tool/path counts, and discloses a 30-second cache. This is transparent beyond what annotations would typically provide.

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

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

The description is three sentences, front-loaded with the main purpose, and every sentence adds necessary context without redundancy.

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

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

Given no parameters, no output schema, and simple functionality, the description provides all necessary information: what it does, returns, and when to use it. Sibling tools are clearly different.

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

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

No parameters exist, so schema coverage is 100%. The description adds value by explaining the return fields and caching, which is more than the empty schema provides, meeting the baseline of 4 for zero-parameter tools.

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

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

The description clearly states 'Check live API & system health' with a specific verb and resource, and distinguishes it from sibling tools like recent_whales and fear_greed by focusing on health status rather than specific data.

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

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

It explicitly recommends use for verifying platform live status before making requests, which provides clear context. However, it does not mention when not to use or alternatives.

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

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

Discloses educational purpose and 1-hour cache, but no annotations provided. Lacks details on authentication, rate limits, or potential side effects, though tool is read-only.

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

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

Two efficient sentences with front-loaded purpose, no unnecessary words.

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

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

Adequate for a parameterless tool; specifies what is returned (tax brackets) but no output schema explains format. Minor gap in completeness.

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

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

No parameters; description adds value by listing supported jurisdictions beyond schema. Coverage is 100% by default.

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?

Clearly states it gets crypto capital-gains tax rate brackets by jurisdiction, listing supported countries. Distinguishes from sibling tools which are market metrics.

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?

Implicitly indicates use for tax bracket reference; mentions educational only and caching. No explicit when-not-to-use, but context makes it 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?

There are no annotations, so the description carries the full disclosure burden. It does well by revealing the 5-minute cache, telling the agent to check meta.cacheAgeSeconds, and explaining meta.tokenCount. It does not detail the response shape beyond meta, but for a zero-parameter read tool this is reasonably transparent.

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

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

The purpose is front-loaded, but the description is somewhat redundant: "currently trending crypto tokens" and the DexScreener/CoinGecko source are stated twice. It could be tightened without losing meaning, though it remains reasonably compact.

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

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

For a zero-parameter tool with no output schema, the description covers the essential context: data sources, ranking method, cache behavior, and relevant meta fields. It is sufficient for an agent to understand what it is getting, though a bit more detail about the token fields would make it fully complete.

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

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

The tool accepts zero parameters, so parameter documentation is not needed; this matches the baseline for no-parameter tools. The description still usefully clarifies what the response meta contains, though that is more about outputs than inputs.

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

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

The description names a specific operation and resource: "Get currently trending crypto tokens." It further sharpens the scope with concrete criteria — "top gainers by 24h volume," sourced from DexScreener + CoinGecko — which clearly distinguishes it from broader analytics siblings like market_heatmap or narratives.

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: when a user wants currently trending tokens by volume. However, it offers no explicit when-not-to-use guidance or alternatives, leaving the agent to infer suitability relative to the many sibling tools.

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

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

With no annotations, the description carries the full burden and does well: it discloses no per-transaction detail, no wallet addresses/explorer links, no USD volume, cache staleness (~5 min), no per-request cost, the underlying data source, and the supported direction categories. This is far richer behavioral context than annotations alone would provide.

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

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

The description is front-loaded with the core purpose and limitation, followed by useful caveats. There is minor redundancy — 'movement COUNTS' appears twice and the 1–30 day range is mentioned both in the opening and in the parameter note — but no filler or irrelevant content.

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

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

For a one-parameter aggregate tool with no output schema and no annotations, this covers input, output grouping, data source, exclusions, caching behavior, and cost. An agent has everything needed to decide whether to call it and what to expect in 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?

The schema already covers window with default, min, max, and clamping, so the baseline is 3. The description adds the serialized usage hint (?window=N), ties the look-back to day-bucketed counts, and reiterates the default. This clarifies how the parameter drives output granularity, though it partially repeats schema content.

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

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

The description names a specific resource ('whale activity') and verb ('Get'), and specifies aggregation dimensions (chain, direction, day). It explicitly states this returns movement COUNTS rather than individual transfers, distinguishing it from sibling tools like whale_movements.

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

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

It explicitly warns 'not individual transfers' and directs the agent to whale_movements for individual records with amounts, and it documents the window parameter with its default and range. It does not lay out a full decision tree against other aggregate siblings such as whale_daily_summary or whale_movements_summary, but the primary alternative is clearly covered.

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

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

There are no annotations, so the description must carry the full disclosure burden. It does: the 5-minute cron upsert guarantees today's row is current, rows older than 365 days are purged, data is cached for 5 minutes, and rows are daily UTC aggregates with a chains_breakdown object.

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 content is dense and mostly front-loaded, with the core purpose stated before the return-field details. Some redundancy exists ('daily aggregated whale movement counts' repeats the opening 'daily whale movement counts' about 20 words later), but the structure is readable and every sentence contributes a fact.

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

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

With no output schema, the description thoroughly explains the returned row fields, freshness, retention, caching, look-back control, and example questions. However, the unresolved max-90-vs-max-180 contradiction and lack of stated row ordering are noticeable completeness gaps for actually relying on the tool's output.

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

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

Although the single parameter has 100% schema description coverage (baseline 3), the description adds no new meaning and, worse, conflicts with the schema's own validation: the text says 'max 180' / '1–180' while the JSON Schema maximum is 90. An agent cannot tell whether 100–180 is valid, making the parameter definition misleading.

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

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

The description opens with a concrete verb and object—'Get daily whale movement counts'—and immediately specifies per-chain inflow/outflow aggregation over a look-back window. It also explicitly scopes this as trend analysis 'not individual transfers', distinguishing it from the whale_movements/whale_activity 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 establishes when to use this tool ('trend analysis', 'Which network was most active this week?') and states an exclusion ('not individual transfers'). It does not name a specific sibling alternative for the individual-transfer case, so it stops short of an explicit when-not/alternative statement.

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

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

No annotations are provided, so the description carries the full burden—and it delivers. It discloses that the archive is never deleted and grows indefinitely, months with fewer than 20 daily records are excluded, the data source, no authentication needed, 60 req/min rate limit, and 5-min cache. These traits go far beyond what a minimal description would provide.

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

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

The description is appropriately sized and front-loaded: it opens with the core purpose before adding use case, field summary, exclusion rule, source, and operational details. Every sentence adds value, with only minor internal repetition of 'permanent' strengthening rather than bloating the message.

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 0-parameter tool with no output schema, the description is complete. It explains what is returned, exclusions, data provenance, authentication, rate limits, caching, and a concrete historical use case. An agent has everything needed to decide whether to call this tool and what to expect from it.

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

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

The input schema has zero parameters, so the baseline of 4 applies; there are no parameter semantics to clarify. The description additionally lists response fields (totalMoves, totalUsdValue, etc.), which helps interpret the data even though it's not needed for invocation.

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

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

The description states a specific verb+resource: 'Returns the permanent monthly archive of whale movement activity' with one row per calendar month. It clearly differentiates from siblings through the monthly aggregation, permanence, and historical focus. Ambiguity is minimal.

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 clear context for use: answering historical questions like 'in which month were whale movements highest?' across years, and notes the archive is aggregated from daily summaries before purge. It doesn't explicitly name sibling alternatives or exclusion cases, but the monthly-versus-daily/live distinction is strongly implied.

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

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

With no annotations, the description carries the burden and does well: it discloses no-auth access, MCP compatibility, pagination, a 1-year cap, and the omission of the Pro-only explorerUrl field. It stops short of describing response fields or rate limits, but the key behavioral traits are present.

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

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

The description is front-loaded but redundant: 'paginated 1-year history' is repeated as 'paginated archive ... covering up to 1 year', auth status is stated twice, and the enum lists duplicate the schema. It also ends with a truncated example ('e.g. ?'), suggesting the text is cut off.

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

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

The tool is adequately described for filtering and invoking, with supported chains, directions, and examples. It is less complete because there is no output schema and the description never explains the response shape, and the minUsd mention is unsupported by the schema.

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

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

Schema coverage is 100%, so the schema already documents all five parameters; the description adds helpful examples for q and enumerates chain and direction values. However, it also references a minUsd parameter that does not exist in the input schema, which is a reliability problem.

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

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

The description clearly states the tool returns a paginated archive of large whale on-chain movements from a history database, so the verb, resource, and timeframe are explicit. It identifies itself as the public counterpart of an authenticated endpoint, but it does not differentiate from MCP siblings like recent_whales or whale_movements_summary.

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

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

It gives a clear use case — analysing historical on-chain flow direction without credentials — and contrasts the public endpoint with the authenticated /api/whale-history endpoint that includes explorerUrl. It does not, however, spell out when to choose this over sibling tools such as recent_whales or whale_movements_summary.

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

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

With no annotations provided, the description carries the full burden, and it covers auth (no authentication required), rate limits (60 requests/min), data semantics (USD totals only include rows with resolvable price, `unresolvedUsdCount` prevents silent inflation), and response contents. This is unusually transparent for a tool definition.

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 longer than average but densely informative, with front-loaded purpose and clear labels for period filter and response shape. Every section earns its place given there is no output schema. Slight redundancy such as 'MCP-compatible' keeps it from a perfect 5.

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

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

Despite having no output schema, the description enumerates the full response fields, documents the only parameter, covers authentication and rate limits, and explains the data quality caveat. An agent has everything needed to decide whether to call it and how to interpret the result.

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

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

Schema coverage is 100%, so the baseline is 3. The description adds meaningful context beyond the schema by explaining why the default is 7d and comparing it to the raw archive's 90d, which helps an agent reason about the period choice. It does not add much more, but the extra default rationale justifies a 4.

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

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

The description opens with a specific verb and resource: returns an aggregated statistics rollup of whale on-chain movements over a period. It clearly distinguishes itself from the raw sibling `whale_movements` by stating agents can use it instead of paging through raw rows to compute totals.

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 explicitly frames when to use the tool: when an agent wants aggregate totals rather than paging through raw `/api/public/whale-movements` rows. It also explains the period default choice relative to the raw archive. It stops short of explicitly naming a when-not-to-use condition or direct sibling alternative, so it gets a 4 rather than 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?

With no annotations provided, the description shoulders the transparency burden and does so thoroughly: it discloses the ≥5 resolved-signals eligibility rule, the 'honest, never fabricated' stance, the 5-minute DB cache, the whale_score_daily backing table, and 365-day retention with permanent monthly archive. It also clarifies row granularity and output fields, leaving little ambiguity about 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 compact and information-dense, with the core purpose front-loaded. It contains one redundant clause ('Daily historical composite scores for tracked whale wallets' restates the opener) but otherwise every sentence contributes a detail (eligibility, cache, retention, fields).

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 tool must describe return values, and it does: one row per wallet per day with address, chain, label, score, win rate, average return %, and sample count. It also covers data recency, caching, retention, and the minimum-signals rule, making it fully self-contained for an agent to invoke.

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 per the rubric. The description's parameter-related additions (e.g., 'Filter by ?chain=') largely echo the schema, and it adds no syntax or format details beyond what the schema already documents. Overall it neither needs nor adds much parameter semantics.

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

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

The description opens with a specific verb+resource ('Get daily whale score history'), names the exact ranking basis (composite score from win rate + avg return), and states the 90-day window. It also enumerates the output fields, making the tool's identity unmistakable among whale/history 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?

Says the tool is 'Useful for tracking smart-money wallet performance trends,' giving a clear intended use case, and explains the optional chain filter. It does not name alternatives or explicit when-not-to-use conditions, so it earns a 4 rather than 5.

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